/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace Lightsail { /** *

Amazon Lightsail is the easiest way to get started with Amazon Web Services * (Amazon Web Services) for developers who need to build websites or web * applications. It includes everything you need to launch your project quickly - * instances (virtual private servers), container services, storage buckets, * managed databases, SSD-based block storage, static IP addresses, load balancers, * content delivery network (CDN) distributions, DNS management of registered * domains, and resource snapshots (backups) - for a low, predictable monthly * price.

You can manage your Lightsail resources using the Lightsail * console, Lightsail API, Command Line Interface (CLI), or SDKs. For more * information about Lightsail concepts and tasks, see the Amazon * Lightsail Developer Guide.

This API Reference provides detailed * information about the actions, data types, parameters, and errors of the * Lightsail service. For more information about the supported Amazon Web Services * Regions, endpoints, and service quotas of the Lightsail service, see Amazon * Lightsail Endpoints and Quotas in the Amazon Web Services General * Reference.

*/ class AWS_LIGHTSAIL_API LightsailClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef LightsailClientConfiguration ClientConfigurationType; typedef LightsailEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ LightsailClient(const Aws::Lightsail::LightsailClientConfiguration& clientConfiguration = Aws::Lightsail::LightsailClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ LightsailClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::Lightsail::LightsailClientConfiguration& clientConfiguration = Aws::Lightsail::LightsailClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ LightsailClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::Lightsail::LightsailClientConfiguration& clientConfiguration = Aws::Lightsail::LightsailClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ LightsailClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ LightsailClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ LightsailClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~LightsailClient(); /** *

Allocates a static IP address.

See Also:

AWS * API Reference

*/ virtual Model::AllocateStaticIpOutcome AllocateStaticIp(const Model::AllocateStaticIpRequest& request) const; /** * A Callable wrapper for AllocateStaticIp that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AllocateStaticIpOutcomeCallable AllocateStaticIpCallable(const AllocateStaticIpRequestT& request) const { return SubmitCallable(&LightsailClient::AllocateStaticIp, request); } /** * An Async wrapper for AllocateStaticIp that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AllocateStaticIpAsync(const AllocateStaticIpRequestT& request, const AllocateStaticIpResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::AllocateStaticIp, request, handler, context); } /** *

Attaches an SSL/TLS certificate to your Amazon Lightsail content delivery * network (CDN) distribution.

After the certificate is attached, your * distribution accepts HTTPS traffic for all of the domains that are associated * with the certificate.

Use the CreateCertificate action to * create a certificate that you can attach to your distribution.

*

Only certificates created in the us-east-1 Amazon Web Services * Region can be attached to Lightsail distributions. Lightsail distributions are * global resources that can reference an origin in any Amazon Web Services Region, * and distribute its content globally. However, all distributions are located in * the us-east-1 Region.

See Also:

AWS * API Reference

*/ virtual Model::AttachCertificateToDistributionOutcome AttachCertificateToDistribution(const Model::AttachCertificateToDistributionRequest& request) const; /** * A Callable wrapper for AttachCertificateToDistribution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AttachCertificateToDistributionOutcomeCallable AttachCertificateToDistributionCallable(const AttachCertificateToDistributionRequestT& request) const { return SubmitCallable(&LightsailClient::AttachCertificateToDistribution, request); } /** * An Async wrapper for AttachCertificateToDistribution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AttachCertificateToDistributionAsync(const AttachCertificateToDistributionRequestT& request, const AttachCertificateToDistributionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::AttachCertificateToDistribution, request, handler, context); } /** *

Attaches a block storage disk to a running or stopped Lightsail instance and * exposes it to the instance with the specified disk name.

The attach * disk operation supports tag-based access control via resource tags * applied to the resource identified by disk name. For more * information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::AttachDiskOutcome AttachDisk(const Model::AttachDiskRequest& request) const; /** * A Callable wrapper for AttachDisk that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AttachDiskOutcomeCallable AttachDiskCallable(const AttachDiskRequestT& request) const { return SubmitCallable(&LightsailClient::AttachDisk, request); } /** * An Async wrapper for AttachDisk that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AttachDiskAsync(const AttachDiskRequestT& request, const AttachDiskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::AttachDisk, request, handler, context); } /** *

Attaches one or more Lightsail instances to a load balancer.

After * some time, the instances are attached to the load balancer and the health check * status is available.

The attach instances to load balancer * operation supports tag-based access control via resource tags applied to the * resource identified by load balancer name. For more information, * see the Lightsail * Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::AttachInstancesToLoadBalancerOutcome AttachInstancesToLoadBalancer(const Model::AttachInstancesToLoadBalancerRequest& request) const; /** * A Callable wrapper for AttachInstancesToLoadBalancer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AttachInstancesToLoadBalancerOutcomeCallable AttachInstancesToLoadBalancerCallable(const AttachInstancesToLoadBalancerRequestT& request) const { return SubmitCallable(&LightsailClient::AttachInstancesToLoadBalancer, request); } /** * An Async wrapper for AttachInstancesToLoadBalancer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AttachInstancesToLoadBalancerAsync(const AttachInstancesToLoadBalancerRequestT& request, const AttachInstancesToLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::AttachInstancesToLoadBalancer, request, handler, context); } /** *

Attaches a Transport Layer Security (TLS) certificate to your load balancer. * TLS is just an updated, more secure version of Secure Socket Layer (SSL).

*

Once you create and validate your certificate, you can attach it to your load * balancer. You can also use this API to rotate the certificates on your account. * Use the AttachLoadBalancerTlsCertificate action with the * non-attached certificate, and it will replace the existing one and become the * attached certificate.

The AttachLoadBalancerTlsCertificate * operation supports tag-based access control via resource tags applied to the * resource identified by load balancer name. For more information, * see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::AttachLoadBalancerTlsCertificateOutcome AttachLoadBalancerTlsCertificate(const Model::AttachLoadBalancerTlsCertificateRequest& request) const; /** * A Callable wrapper for AttachLoadBalancerTlsCertificate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AttachLoadBalancerTlsCertificateOutcomeCallable AttachLoadBalancerTlsCertificateCallable(const AttachLoadBalancerTlsCertificateRequestT& request) const { return SubmitCallable(&LightsailClient::AttachLoadBalancerTlsCertificate, request); } /** * An Async wrapper for AttachLoadBalancerTlsCertificate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AttachLoadBalancerTlsCertificateAsync(const AttachLoadBalancerTlsCertificateRequestT& request, const AttachLoadBalancerTlsCertificateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::AttachLoadBalancerTlsCertificate, request, handler, context); } /** *

Attaches a static IP address to a specific Amazon Lightsail * instance.

See Also:

AWS * API Reference

*/ virtual Model::AttachStaticIpOutcome AttachStaticIp(const Model::AttachStaticIpRequest& request) const; /** * A Callable wrapper for AttachStaticIp that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AttachStaticIpOutcomeCallable AttachStaticIpCallable(const AttachStaticIpRequestT& request) const { return SubmitCallable(&LightsailClient::AttachStaticIp, request); } /** * An Async wrapper for AttachStaticIp that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AttachStaticIpAsync(const AttachStaticIpRequestT& request, const AttachStaticIpResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::AttachStaticIp, request, handler, context); } /** *

Closes ports for a specific Amazon Lightsail instance.

The * CloseInstancePublicPorts action supports tag-based access control * via resource tags applied to the resource identified by * instanceName. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CloseInstancePublicPortsOutcome CloseInstancePublicPorts(const Model::CloseInstancePublicPortsRequest& request) const; /** * A Callable wrapper for CloseInstancePublicPorts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CloseInstancePublicPortsOutcomeCallable CloseInstancePublicPortsCallable(const CloseInstancePublicPortsRequestT& request) const { return SubmitCallable(&LightsailClient::CloseInstancePublicPorts, request); } /** * An Async wrapper for CloseInstancePublicPorts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CloseInstancePublicPortsAsync(const CloseInstancePublicPortsRequestT& request, const CloseInstancePublicPortsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CloseInstancePublicPorts, request, handler, context); } /** *

Copies a manual snapshot of an instance or disk as another manual snapshot, * or copies an automatic snapshot of an instance or disk as a manual snapshot. * This operation can also be used to copy a manual or automatic snapshot of an * instance or a disk from one Amazon Web Services Region to another in Amazon * Lightsail.

When copying a manual snapshot, be sure to define the * source region, source snapshot name, and target * snapshot name parameters.

When copying an automatic * snapshot, be sure to define the source region, source * resource name, target snapshot name, and either the * restore date or the use latest restorable auto * snapshot parameters.

See Also:

AWS * API Reference

*/ virtual Model::CopySnapshotOutcome CopySnapshot(const Model::CopySnapshotRequest& request) const; /** * A Callable wrapper for CopySnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CopySnapshotOutcomeCallable CopySnapshotCallable(const CopySnapshotRequestT& request) const { return SubmitCallable(&LightsailClient::CopySnapshot, request); } /** * An Async wrapper for CopySnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CopySnapshotAsync(const CopySnapshotRequestT& request, const CopySnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CopySnapshot, request, handler, context); } /** *

Creates an Amazon Lightsail bucket.

A bucket is a cloud storage * resource available in the Lightsail object storage service. Use buckets to store * objects such as data and its descriptive metadata. For more information about * buckets, see Buckets * in Amazon Lightsail in the Amazon Lightsail Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateBucketOutcome CreateBucket(const Model::CreateBucketRequest& request) const; /** * A Callable wrapper for CreateBucket that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateBucketOutcomeCallable CreateBucketCallable(const CreateBucketRequestT& request) const { return SubmitCallable(&LightsailClient::CreateBucket, request); } /** * An Async wrapper for CreateBucket that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateBucketAsync(const CreateBucketRequestT& request, const CreateBucketResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateBucket, request, handler, context); } /** *

Creates a new access key for the specified Amazon Lightsail bucket. Access * keys consist of an access key ID and corresponding secret access key.

*

Access keys grant full programmatic access to the specified bucket and its * objects. You can have a maximum of two access keys per bucket. Use the GetBucketAccessKeys * action to get a list of current access keys for a specific bucket. For more * information about access keys, see Creating * access keys for a bucket in Amazon Lightsail in the Amazon Lightsail * Developer Guide.

The secretAccessKey value * is returned only in response to the CreateBucketAccessKey action. * You can get a secret access key only when you first create an access key; you * cannot get the secret access key later. If you lose the secret access key, you * must create a new access key.

See Also:

AWS * API Reference

*/ virtual Model::CreateBucketAccessKeyOutcome CreateBucketAccessKey(const Model::CreateBucketAccessKeyRequest& request) const; /** * A Callable wrapper for CreateBucketAccessKey that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateBucketAccessKeyOutcomeCallable CreateBucketAccessKeyCallable(const CreateBucketAccessKeyRequestT& request) const { return SubmitCallable(&LightsailClient::CreateBucketAccessKey, request); } /** * An Async wrapper for CreateBucketAccessKey that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateBucketAccessKeyAsync(const CreateBucketAccessKeyRequestT& request, const CreateBucketAccessKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateBucketAccessKey, request, handler, context); } /** *

Creates an SSL/TLS certificate for an Amazon Lightsail content delivery * network (CDN) distribution and a container service.

After the certificate * is valid, use the AttachCertificateToDistribution action to use the * certificate and its domains with your distribution. Or use the * UpdateContainerService action to use the certificate and its * domains with your container service.

Only certificates * created in the us-east-1 Amazon Web Services Region can be attached * to Lightsail distributions. Lightsail distributions are global resources that * can reference an origin in any Amazon Web Services Region, and distribute its * content globally. However, all distributions are located in the * us-east-1 Region.

See Also:

AWS * API Reference

*/ virtual Model::CreateCertificateOutcome CreateCertificate(const Model::CreateCertificateRequest& request) const; /** * A Callable wrapper for CreateCertificate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCertificateOutcomeCallable CreateCertificateCallable(const CreateCertificateRequestT& request) const { return SubmitCallable(&LightsailClient::CreateCertificate, request); } /** * An Async wrapper for CreateCertificate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCertificateAsync(const CreateCertificateRequestT& request, const CreateCertificateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateCertificate, request, handler, context); } /** *

Creates an AWS CloudFormation stack, which creates a new Amazon EC2 instance * from an exported Amazon Lightsail snapshot. This operation results in a * CloudFormation stack record that can be used to track the AWS CloudFormation * stack created. Use the get cloud formation stack records operation * to get a list of the CloudFormation stacks created.

Wait * until after your new Amazon EC2 instance is created before running the * create cloud formation stack operation again with the same export * snapshot record.

See Also:

AWS * API Reference

*/ virtual Model::CreateCloudFormationStackOutcome CreateCloudFormationStack(const Model::CreateCloudFormationStackRequest& request) const; /** * A Callable wrapper for CreateCloudFormationStack that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCloudFormationStackOutcomeCallable CreateCloudFormationStackCallable(const CreateCloudFormationStackRequestT& request) const { return SubmitCallable(&LightsailClient::CreateCloudFormationStack, request); } /** * An Async wrapper for CreateCloudFormationStack that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCloudFormationStackAsync(const CreateCloudFormationStackRequestT& request, const CreateCloudFormationStackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateCloudFormationStack, request, handler, context); } /** *

Creates an email or SMS text message contact method.

A contact method * is used to send you notifications about your Amazon Lightsail resources. You can * add one email address and one mobile phone number contact method in each Amazon * Web Services Region. However, SMS text messaging is not supported in some Amazon * Web Services Regions, and SMS text messages cannot be sent to some * countries/regions. For more information, see Notifications * in Amazon Lightsail.

See Also:

AWS * API Reference

*/ virtual Model::CreateContactMethodOutcome CreateContactMethod(const Model::CreateContactMethodRequest& request) const; /** * A Callable wrapper for CreateContactMethod that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateContactMethodOutcomeCallable CreateContactMethodCallable(const CreateContactMethodRequestT& request) const { return SubmitCallable(&LightsailClient::CreateContactMethod, request); } /** * An Async wrapper for CreateContactMethod that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateContactMethodAsync(const CreateContactMethodRequestT& request, const CreateContactMethodResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateContactMethod, request, handler, context); } /** *

Creates an Amazon Lightsail container service.

A Lightsail container * service is a compute resource to which you can deploy containers. For more * information, see Container * services in Amazon Lightsail in the Lightsail Dev * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateContainerServiceOutcome CreateContainerService(const Model::CreateContainerServiceRequest& request) const; /** * A Callable wrapper for CreateContainerService that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateContainerServiceOutcomeCallable CreateContainerServiceCallable(const CreateContainerServiceRequestT& request) const { return SubmitCallable(&LightsailClient::CreateContainerService, request); } /** * An Async wrapper for CreateContainerService that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateContainerServiceAsync(const CreateContainerServiceRequestT& request, const CreateContainerServiceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateContainerService, request, handler, context); } /** *

Creates a deployment for your Amazon Lightsail container service.

A * deployment specifies the containers that will be launched on the container * service and their settings, such as the ports to open, the environment variables * to apply, and the launch command to run. It also specifies the container that * will serve as the public endpoint of the deployment and its settings, such as * the HTTP or HTTPS port to use, and the health check configuration.

You * can deploy containers to your container service using container images from a * public registry such as Amazon ECR Public, or from your local machine. For more * information, see Creating * container images for your Amazon Lightsail container services in the * Amazon Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateContainerServiceDeploymentOutcome CreateContainerServiceDeployment(const Model::CreateContainerServiceDeploymentRequest& request) const; /** * A Callable wrapper for CreateContainerServiceDeployment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateContainerServiceDeploymentOutcomeCallable CreateContainerServiceDeploymentCallable(const CreateContainerServiceDeploymentRequestT& request) const { return SubmitCallable(&LightsailClient::CreateContainerServiceDeployment, request); } /** * An Async wrapper for CreateContainerServiceDeployment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateContainerServiceDeploymentAsync(const CreateContainerServiceDeploymentRequestT& request, const CreateContainerServiceDeploymentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateContainerServiceDeployment, request, handler, context); } /** *

Creates a temporary set of log in credentials that you can use to log in to * the Docker process on your local machine. After you're logged in, you can use * the native Docker commands to push your local container images to the container * image registry of your Amazon Lightsail account so that you can use them with * your Lightsail container service. The log in credentials expire 12 hours after * they are created, at which point you will need to create a new set of log in * credentials.

You can only push container images to the container * service registry of your Lightsail account. You cannot pull container images or * perform any other container image management actions on the container service * registry.

After you push your container images to the container * image registry of your Lightsail account, use the * RegisterContainerImage action to register the pushed images to a * specific Lightsail container service.

This action is not required * if you install and use the Lightsail Control (lightsailctl) plugin to push * container images to your Lightsail container service. For more information, see * Pushing * and managing container images on your Amazon Lightsail container services in * the Amazon Lightsail Developer Guide.

See Also:

* AWS * API Reference

*/ virtual Model::CreateContainerServiceRegistryLoginOutcome CreateContainerServiceRegistryLogin(const Model::CreateContainerServiceRegistryLoginRequest& request) const; /** * A Callable wrapper for CreateContainerServiceRegistryLogin that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateContainerServiceRegistryLoginOutcomeCallable CreateContainerServiceRegistryLoginCallable(const CreateContainerServiceRegistryLoginRequestT& request) const { return SubmitCallable(&LightsailClient::CreateContainerServiceRegistryLogin, request); } /** * An Async wrapper for CreateContainerServiceRegistryLogin that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateContainerServiceRegistryLoginAsync(const CreateContainerServiceRegistryLoginRequestT& request, const CreateContainerServiceRegistryLoginResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateContainerServiceRegistryLogin, request, handler, context); } /** *

Creates a block storage disk that can be attached to an Amazon Lightsail * instance in the same Availability Zone (e.g., us-east-2a).

*

The create disk operation supports tag-based access control via * request tags. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateDiskOutcome CreateDisk(const Model::CreateDiskRequest& request) const; /** * A Callable wrapper for CreateDisk that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDiskOutcomeCallable CreateDiskCallable(const CreateDiskRequestT& request) const { return SubmitCallable(&LightsailClient::CreateDisk, request); } /** * An Async wrapper for CreateDisk that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDiskAsync(const CreateDiskRequestT& request, const CreateDiskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateDisk, request, handler, context); } /** *

Creates a block storage disk from a manual or automatic snapshot of a disk. * The resulting disk can be attached to an Amazon Lightsail instance in the same * Availability Zone (e.g., us-east-2a).

The create disk * from snapshot operation supports tag-based access control via request * tags and resource tags applied to the resource identified by disk snapshot * name. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateDiskFromSnapshotOutcome CreateDiskFromSnapshot(const Model::CreateDiskFromSnapshotRequest& request) const; /** * A Callable wrapper for CreateDiskFromSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDiskFromSnapshotOutcomeCallable CreateDiskFromSnapshotCallable(const CreateDiskFromSnapshotRequestT& request) const { return SubmitCallable(&LightsailClient::CreateDiskFromSnapshot, request); } /** * An Async wrapper for CreateDiskFromSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDiskFromSnapshotAsync(const CreateDiskFromSnapshotRequestT& request, const CreateDiskFromSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateDiskFromSnapshot, request, handler, context); } /** *

Creates a snapshot of a block storage disk. You can use snapshots for * backups, to make copies of disks, and to save data before shutting down a * Lightsail instance.

You can take a snapshot of an attached disk that is * in use; however, snapshots only capture data that has been written to your disk * at the time the snapshot command is issued. This may exclude any data that has * been cached by any applications or the operating system. If you can pause any * file systems on the disk long enough to take a snapshot, your snapshot should be * complete. Nevertheless, if you cannot pause all file writes to the disk, you * should unmount the disk from within the Lightsail instance, issue the create * disk snapshot command, and then remount the disk to ensure a consistent and * complete snapshot. You may remount and use your disk while the snapshot status * is pending.

You can also use this operation to create a snapshot of an * instance's system volume. You might want to do this, for example, to recover * data from the system volume of a botched instance or to create a backup of the * system volume like you would for a block storage disk. To create a snapshot of a * system volume, just define the instance name parameter when issuing * the snapshot command, and a snapshot of the defined instance's system volume * will be created. After the snapshot is available, you can create a block storage * disk from the snapshot and attach it to a running instance to access the data on * the disk.

The create disk snapshot operation supports * tag-based access control via request tags. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateDiskSnapshotOutcome CreateDiskSnapshot(const Model::CreateDiskSnapshotRequest& request) const; /** * A Callable wrapper for CreateDiskSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDiskSnapshotOutcomeCallable CreateDiskSnapshotCallable(const CreateDiskSnapshotRequestT& request) const { return SubmitCallable(&LightsailClient::CreateDiskSnapshot, request); } /** * An Async wrapper for CreateDiskSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDiskSnapshotAsync(const CreateDiskSnapshotRequestT& request, const CreateDiskSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateDiskSnapshot, request, handler, context); } /** *

Creates an Amazon Lightsail content delivery network (CDN) distribution.

*

A distribution is a globally distributed network of caching servers that * improve the performance of your website or web application hosted on a Lightsail * instance. For more information, see Content * delivery networks in Amazon Lightsail.

See Also:

AWS * API Reference

*/ virtual Model::CreateDistributionOutcome CreateDistribution(const Model::CreateDistributionRequest& request) const; /** * A Callable wrapper for CreateDistribution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDistributionOutcomeCallable CreateDistributionCallable(const CreateDistributionRequestT& request) const { return SubmitCallable(&LightsailClient::CreateDistribution, request); } /** * An Async wrapper for CreateDistribution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDistributionAsync(const CreateDistributionRequestT& request, const CreateDistributionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateDistribution, request, handler, context); } /** *

Creates a domain resource for the specified domain (e.g., example.com).

*

The create domain operation supports tag-based access control * via request tags. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateDomainOutcome CreateDomain(const Model::CreateDomainRequest& request) const; /** * A Callable wrapper for CreateDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDomainOutcomeCallable CreateDomainCallable(const CreateDomainRequestT& request) const { return SubmitCallable(&LightsailClient::CreateDomain, request); } /** * An Async wrapper for CreateDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDomainAsync(const CreateDomainRequestT& request, const CreateDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateDomain, request, handler, context); } /** *

Creates one of the following domain name system (DNS) records in a domain DNS * zone: Address (A), canonical name (CNAME), mail exchanger (MX), name server * (NS), start of authority (SOA), service locator (SRV), or text (TXT).

The * create domain entry operation supports tag-based access control via * resource tags applied to the resource identified by domain name. * For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateDomainEntryOutcome CreateDomainEntry(const Model::CreateDomainEntryRequest& request) const; /** * A Callable wrapper for CreateDomainEntry that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDomainEntryOutcomeCallable CreateDomainEntryCallable(const CreateDomainEntryRequestT& request) const { return SubmitCallable(&LightsailClient::CreateDomainEntry, request); } /** * An Async wrapper for CreateDomainEntry that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDomainEntryAsync(const CreateDomainEntryRequestT& request, const CreateDomainEntryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateDomainEntry, request, handler, context); } /** *

Creates two URLs that are used to access a virtual computer’s graphical user * interface (GUI) session. The primary URL initiates a web-based NICE DCV session * to the virtual computer's application. The secondary URL initiates a web-based * NICE DCV session to the virtual computer's operating session.

Use * StartGUISession to open the session.

See Also:

AWS * API Reference

*/ virtual Model::CreateGUISessionAccessDetailsOutcome CreateGUISessionAccessDetails(const Model::CreateGUISessionAccessDetailsRequest& request) const; /** * A Callable wrapper for CreateGUISessionAccessDetails that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateGUISessionAccessDetailsOutcomeCallable CreateGUISessionAccessDetailsCallable(const CreateGUISessionAccessDetailsRequestT& request) const { return SubmitCallable(&LightsailClient::CreateGUISessionAccessDetails, request); } /** * An Async wrapper for CreateGUISessionAccessDetails that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateGUISessionAccessDetailsAsync(const CreateGUISessionAccessDetailsRequestT& request, const CreateGUISessionAccessDetailsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateGUISessionAccessDetails, request, handler, context); } /** *

Creates a snapshot of a specific virtual private server, or instance. * You can use a snapshot to create a new instance that is based on that * snapshot.

The create instance snapshot operation supports * tag-based access control via request tags. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateInstanceSnapshotOutcome CreateInstanceSnapshot(const Model::CreateInstanceSnapshotRequest& request) const; /** * A Callable wrapper for CreateInstanceSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateInstanceSnapshotOutcomeCallable CreateInstanceSnapshotCallable(const CreateInstanceSnapshotRequestT& request) const { return SubmitCallable(&LightsailClient::CreateInstanceSnapshot, request); } /** * An Async wrapper for CreateInstanceSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateInstanceSnapshotAsync(const CreateInstanceSnapshotRequestT& request, const CreateInstanceSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateInstanceSnapshot, request, handler, context); } /** *

Creates one or more Amazon Lightsail instances.

The create * instances operation supports tag-based access control via request tags. * For more information, see the Lightsail * Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateInstancesOutcome CreateInstances(const Model::CreateInstancesRequest& request) const; /** * A Callable wrapper for CreateInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateInstancesOutcomeCallable CreateInstancesCallable(const CreateInstancesRequestT& request) const { return SubmitCallable(&LightsailClient::CreateInstances, request); } /** * An Async wrapper for CreateInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateInstancesAsync(const CreateInstancesRequestT& request, const CreateInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateInstances, request, handler, context); } /** *

Creates one or more new instances from a manual or automatic snapshot of an * instance.

The create instances from snapshot operation * supports tag-based access control via request tags and resource tags applied to * the resource identified by instance snapshot name. For more * information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateInstancesFromSnapshotOutcome CreateInstancesFromSnapshot(const Model::CreateInstancesFromSnapshotRequest& request) const; /** * A Callable wrapper for CreateInstancesFromSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateInstancesFromSnapshotOutcomeCallable CreateInstancesFromSnapshotCallable(const CreateInstancesFromSnapshotRequestT& request) const { return SubmitCallable(&LightsailClient::CreateInstancesFromSnapshot, request); } /** * An Async wrapper for CreateInstancesFromSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateInstancesFromSnapshotAsync(const CreateInstancesFromSnapshotRequestT& request, const CreateInstancesFromSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateInstancesFromSnapshot, request, handler, context); } /** *

Creates a custom SSH key pair that you can use with an Amazon Lightsail * instance.

Use the DownloadDefaultKeyPair * action to create a Lightsail default key pair in an Amazon Web Services Region * where a default key pair does not currently exist.

The * create key pair operation supports tag-based access control via * request tags. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateKeyPairOutcome CreateKeyPair(const Model::CreateKeyPairRequest& request) const; /** * A Callable wrapper for CreateKeyPair that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateKeyPairOutcomeCallable CreateKeyPairCallable(const CreateKeyPairRequestT& request) const { return SubmitCallable(&LightsailClient::CreateKeyPair, request); } /** * An Async wrapper for CreateKeyPair that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateKeyPairAsync(const CreateKeyPairRequestT& request, const CreateKeyPairResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateKeyPair, request, handler, context); } /** *

Creates a Lightsail load balancer. To learn more about deciding whether to * load balance your application, see Configure * your Lightsail instances for load balancing. You can create up to 5 load * balancers per AWS Region in your account.

When you create a load * balancer, you can specify a unique name and port settings. To change additional * load balancer settings, use the UpdateLoadBalancerAttribute * operation.

The create load balancer operation supports * tag-based access control via request tags. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateLoadBalancerOutcome CreateLoadBalancer(const Model::CreateLoadBalancerRequest& request) const; /** * A Callable wrapper for CreateLoadBalancer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLoadBalancerOutcomeCallable CreateLoadBalancerCallable(const CreateLoadBalancerRequestT& request) const { return SubmitCallable(&LightsailClient::CreateLoadBalancer, request); } /** * An Async wrapper for CreateLoadBalancer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLoadBalancerAsync(const CreateLoadBalancerRequestT& request, const CreateLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateLoadBalancer, request, handler, context); } /** *

Creates an SSL/TLS certificate for an Amazon Lightsail load balancer.

*

TLS is just an updated, more secure version of Secure Socket Layer (SSL).

*

The CreateLoadBalancerTlsCertificate operation supports * tag-based access control via resource tags applied to the resource identified by * load balancer name. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateLoadBalancerTlsCertificateOutcome CreateLoadBalancerTlsCertificate(const Model::CreateLoadBalancerTlsCertificateRequest& request) const; /** * A Callable wrapper for CreateLoadBalancerTlsCertificate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLoadBalancerTlsCertificateOutcomeCallable CreateLoadBalancerTlsCertificateCallable(const CreateLoadBalancerTlsCertificateRequestT& request) const { return SubmitCallable(&LightsailClient::CreateLoadBalancerTlsCertificate, request); } /** * An Async wrapper for CreateLoadBalancerTlsCertificate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLoadBalancerTlsCertificateAsync(const CreateLoadBalancerTlsCertificateRequestT& request, const CreateLoadBalancerTlsCertificateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateLoadBalancerTlsCertificate, request, handler, context); } /** *

Creates a new database in Amazon Lightsail.

The create * relational database operation supports tag-based access control via * request tags. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateRelationalDatabaseOutcome CreateRelationalDatabase(const Model::CreateRelationalDatabaseRequest& request) const; /** * A Callable wrapper for CreateRelationalDatabase that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateRelationalDatabaseOutcomeCallable CreateRelationalDatabaseCallable(const CreateRelationalDatabaseRequestT& request) const { return SubmitCallable(&LightsailClient::CreateRelationalDatabase, request); } /** * An Async wrapper for CreateRelationalDatabase that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateRelationalDatabaseAsync(const CreateRelationalDatabaseRequestT& request, const CreateRelationalDatabaseResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateRelationalDatabase, request, handler, context); } /** *

Creates a new database from an existing database snapshot in Amazon * Lightsail.

You can create a new database from a snapshot in if something * goes wrong with your original database, or to change it to a different plan, * such as a high availability or standard plan.

The create relational * database from snapshot operation supports tag-based access control via * request tags and resource tags applied to the resource identified by * relationalDatabaseSnapshotName. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateRelationalDatabaseFromSnapshotOutcome CreateRelationalDatabaseFromSnapshot(const Model::CreateRelationalDatabaseFromSnapshotRequest& request) const; /** * A Callable wrapper for CreateRelationalDatabaseFromSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateRelationalDatabaseFromSnapshotOutcomeCallable CreateRelationalDatabaseFromSnapshotCallable(const CreateRelationalDatabaseFromSnapshotRequestT& request) const { return SubmitCallable(&LightsailClient::CreateRelationalDatabaseFromSnapshot, request); } /** * An Async wrapper for CreateRelationalDatabaseFromSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateRelationalDatabaseFromSnapshotAsync(const CreateRelationalDatabaseFromSnapshotRequestT& request, const CreateRelationalDatabaseFromSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateRelationalDatabaseFromSnapshot, request, handler, context); } /** *

Creates a snapshot of your database in Amazon Lightsail. You can use * snapshots for backups, to make copies of a database, and to save data before * deleting a database.

The create relational database snapshot * operation supports tag-based access control via request tags. For more * information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateRelationalDatabaseSnapshotOutcome CreateRelationalDatabaseSnapshot(const Model::CreateRelationalDatabaseSnapshotRequest& request) const; /** * A Callable wrapper for CreateRelationalDatabaseSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateRelationalDatabaseSnapshotOutcomeCallable CreateRelationalDatabaseSnapshotCallable(const CreateRelationalDatabaseSnapshotRequestT& request) const { return SubmitCallable(&LightsailClient::CreateRelationalDatabaseSnapshot, request); } /** * An Async wrapper for CreateRelationalDatabaseSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateRelationalDatabaseSnapshotAsync(const CreateRelationalDatabaseSnapshotRequestT& request, const CreateRelationalDatabaseSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::CreateRelationalDatabaseSnapshot, request, handler, context); } /** *

Deletes an alarm.

An alarm is used to monitor a single metric for one * of your resources. When a metric condition is met, the alarm can notify you by * email, SMS text message, and a banner displayed on the Amazon Lightsail console. * For more information, see Alarms * in Amazon Lightsail.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAlarmOutcome DeleteAlarm(const Model::DeleteAlarmRequest& request) const; /** * A Callable wrapper for DeleteAlarm that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAlarmOutcomeCallable DeleteAlarmCallable(const DeleteAlarmRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteAlarm, request); } /** * An Async wrapper for DeleteAlarm that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAlarmAsync(const DeleteAlarmRequestT& request, const DeleteAlarmResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteAlarm, request, handler, context); } /** *

Deletes an automatic snapshot of an instance or disk. For more information, * see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAutoSnapshotOutcome DeleteAutoSnapshot(const Model::DeleteAutoSnapshotRequest& request) const; /** * A Callable wrapper for DeleteAutoSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAutoSnapshotOutcomeCallable DeleteAutoSnapshotCallable(const DeleteAutoSnapshotRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteAutoSnapshot, request); } /** * An Async wrapper for DeleteAutoSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAutoSnapshotAsync(const DeleteAutoSnapshotRequestT& request, const DeleteAutoSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteAutoSnapshot, request, handler, context); } /** *

Deletes a Amazon Lightsail bucket.

When you delete your bucket, * the bucket name is released and can be reused for a new bucket in your account * or another Amazon Web Services account.

See Also:

AWS * API Reference

*/ virtual Model::DeleteBucketOutcome DeleteBucket(const Model::DeleteBucketRequest& request) const; /** * A Callable wrapper for DeleteBucket that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBucketOutcomeCallable DeleteBucketCallable(const DeleteBucketRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteBucket, request); } /** * An Async wrapper for DeleteBucket that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBucketAsync(const DeleteBucketRequestT& request, const DeleteBucketResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteBucket, request, handler, context); } /** *

Deletes an access key for the specified Amazon Lightsail bucket.

We * recommend that you delete an access key if the secret access key is * compromised.

For more information about access keys, see Creating * access keys for a bucket in Amazon Lightsail in the Amazon Lightsail * Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteBucketAccessKeyOutcome DeleteBucketAccessKey(const Model::DeleteBucketAccessKeyRequest& request) const; /** * A Callable wrapper for DeleteBucketAccessKey that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBucketAccessKeyOutcomeCallable DeleteBucketAccessKeyCallable(const DeleteBucketAccessKeyRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteBucketAccessKey, request); } /** * An Async wrapper for DeleteBucketAccessKey that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBucketAccessKeyAsync(const DeleteBucketAccessKeyRequestT& request, const DeleteBucketAccessKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteBucketAccessKey, request, handler, context); } /** *

Deletes an SSL/TLS certificate for your Amazon Lightsail content delivery * network (CDN) distribution.

Certificates that are currently attached to a * distribution cannot be deleted. Use the * DetachCertificateFromDistribution action to detach a certificate * from a distribution.

See Also:

AWS * API Reference

*/ virtual Model::DeleteCertificateOutcome DeleteCertificate(const Model::DeleteCertificateRequest& request) const; /** * A Callable wrapper for DeleteCertificate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCertificateOutcomeCallable DeleteCertificateCallable(const DeleteCertificateRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteCertificate, request); } /** * An Async wrapper for DeleteCertificate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCertificateAsync(const DeleteCertificateRequestT& request, const DeleteCertificateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteCertificate, request, handler, context); } /** *

Deletes a contact method.

A contact method is used to send you * notifications about your Amazon Lightsail resources. You can add one email * address and one mobile phone number contact method in each Amazon Web Services * Region. However, SMS text messaging is not supported in some Amazon Web Services * Regions, and SMS text messages cannot be sent to some countries/regions. For * more information, see Notifications * in Amazon Lightsail.

See Also:

AWS * API Reference

*/ virtual Model::DeleteContactMethodOutcome DeleteContactMethod(const Model::DeleteContactMethodRequest& request) const; /** * A Callable wrapper for DeleteContactMethod that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteContactMethodOutcomeCallable DeleteContactMethodCallable(const DeleteContactMethodRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteContactMethod, request); } /** * An Async wrapper for DeleteContactMethod that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteContactMethodAsync(const DeleteContactMethodRequestT& request, const DeleteContactMethodResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteContactMethod, request, handler, context); } /** *

Deletes a container image that is registered to your Amazon Lightsail * container service.

See Also:

AWS * API Reference

*/ virtual Model::DeleteContainerImageOutcome DeleteContainerImage(const Model::DeleteContainerImageRequest& request) const; /** * A Callable wrapper for DeleteContainerImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteContainerImageOutcomeCallable DeleteContainerImageCallable(const DeleteContainerImageRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteContainerImage, request); } /** * An Async wrapper for DeleteContainerImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteContainerImageAsync(const DeleteContainerImageRequestT& request, const DeleteContainerImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteContainerImage, request, handler, context); } /** *

Deletes your Amazon Lightsail container service.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteContainerServiceOutcome DeleteContainerService(const Model::DeleteContainerServiceRequest& request) const; /** * A Callable wrapper for DeleteContainerService that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteContainerServiceOutcomeCallable DeleteContainerServiceCallable(const DeleteContainerServiceRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteContainerService, request); } /** * An Async wrapper for DeleteContainerService that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteContainerServiceAsync(const DeleteContainerServiceRequestT& request, const DeleteContainerServiceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteContainerService, request, handler, context); } /** *

Deletes the specified block storage disk. The disk must be in the * available state (not attached to a Lightsail instance).

*

The disk may remain in the deleting state for several * minutes.

The delete disk operation supports * tag-based access control via resource tags applied to the resource identified by * disk name. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDiskOutcome DeleteDisk(const Model::DeleteDiskRequest& request) const; /** * A Callable wrapper for DeleteDisk that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDiskOutcomeCallable DeleteDiskCallable(const DeleteDiskRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteDisk, request); } /** * An Async wrapper for DeleteDisk that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDiskAsync(const DeleteDiskRequestT& request, const DeleteDiskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteDisk, request, handler, context); } /** *

Deletes the specified disk snapshot.

When you make periodic snapshots * of a disk, the snapshots are incremental, and only the blocks on the device that * have changed since your last snapshot are saved in the new snapshot. When you * delete a snapshot, only the data not needed for any other snapshot is removed. * So regardless of which prior snapshots have been deleted, all active snapshots * will have access to all the information needed to restore the disk.

The * delete disk snapshot operation supports tag-based access control * via resource tags applied to the resource identified by disk snapshot * name. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDiskSnapshotOutcome DeleteDiskSnapshot(const Model::DeleteDiskSnapshotRequest& request) const; /** * A Callable wrapper for DeleteDiskSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDiskSnapshotOutcomeCallable DeleteDiskSnapshotCallable(const DeleteDiskSnapshotRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteDiskSnapshot, request); } /** * An Async wrapper for DeleteDiskSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDiskSnapshotAsync(const DeleteDiskSnapshotRequestT& request, const DeleteDiskSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteDiskSnapshot, request, handler, context); } /** *

Deletes your Amazon Lightsail content delivery network (CDN) * distribution.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDistributionOutcome DeleteDistribution(const Model::DeleteDistributionRequest& request) const; /** * A Callable wrapper for DeleteDistribution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDistributionOutcomeCallable DeleteDistributionCallable(const DeleteDistributionRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteDistribution, request); } /** * An Async wrapper for DeleteDistribution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDistributionAsync(const DeleteDistributionRequestT& request, const DeleteDistributionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteDistribution, request, handler, context); } /** *

Deletes the specified domain recordset and all of its domain records.

*

The delete domain operation supports tag-based access control * via resource tags applied to the resource identified by domain * name. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDomainOutcome DeleteDomain(const Model::DeleteDomainRequest& request) const; /** * A Callable wrapper for DeleteDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDomainOutcomeCallable DeleteDomainCallable(const DeleteDomainRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteDomain, request); } /** * An Async wrapper for DeleteDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDomainAsync(const DeleteDomainRequestT& request, const DeleteDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteDomain, request, handler, context); } /** *

Deletes a specific domain entry.

The delete domain entry * operation supports tag-based access control via resource tags applied to the * resource identified by domain name. For more information, see the * Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDomainEntryOutcome DeleteDomainEntry(const Model::DeleteDomainEntryRequest& request) const; /** * A Callable wrapper for DeleteDomainEntry that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDomainEntryOutcomeCallable DeleteDomainEntryCallable(const DeleteDomainEntryRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteDomainEntry, request); } /** * An Async wrapper for DeleteDomainEntry that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDomainEntryAsync(const DeleteDomainEntryRequestT& request, const DeleteDomainEntryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteDomainEntry, request, handler, context); } /** *

Deletes an Amazon Lightsail instance.

The delete instance * operation supports tag-based access control via resource tags applied to the * resource identified by instance name. For more information, see the * Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteInstanceOutcome DeleteInstance(const Model::DeleteInstanceRequest& request) const; /** * A Callable wrapper for DeleteInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteInstanceOutcomeCallable DeleteInstanceCallable(const DeleteInstanceRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteInstance, request); } /** * An Async wrapper for DeleteInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteInstanceAsync(const DeleteInstanceRequestT& request, const DeleteInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteInstance, request, handler, context); } /** *

Deletes a specific snapshot of a virtual private server (or * instance).

The delete instance snapshot operation * supports tag-based access control via resource tags applied to the resource * identified by instance snapshot name. For more information, see the * Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteInstanceSnapshotOutcome DeleteInstanceSnapshot(const Model::DeleteInstanceSnapshotRequest& request) const; /** * A Callable wrapper for DeleteInstanceSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteInstanceSnapshotOutcomeCallable DeleteInstanceSnapshotCallable(const DeleteInstanceSnapshotRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteInstanceSnapshot, request); } /** * An Async wrapper for DeleteInstanceSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteInstanceSnapshotAsync(const DeleteInstanceSnapshotRequestT& request, const DeleteInstanceSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteInstanceSnapshot, request, handler, context); } /** *

Deletes the specified key pair by removing the public key from Amazon * Lightsail.

You can delete key pairs that were created using the ImportKeyPair * and CreateKeyPair * actions, as well as the Lightsail default key pair. A new default key pair will * not be created unless you launch an instance without specifying a custom key * pair, or you call the DownloadDefaultKeyPair * API.

The delete key pair operation supports tag-based * access control via resource tags applied to the resource identified by key * pair name. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteKeyPairOutcome DeleteKeyPair(const Model::DeleteKeyPairRequest& request) const; /** * A Callable wrapper for DeleteKeyPair that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteKeyPairOutcomeCallable DeleteKeyPairCallable(const DeleteKeyPairRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteKeyPair, request); } /** * An Async wrapper for DeleteKeyPair that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteKeyPairAsync(const DeleteKeyPairRequestT& request, const DeleteKeyPairResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteKeyPair, request, handler, context); } /** *

Deletes the known host key or certificate used by the Amazon Lightsail * browser-based SSH or RDP clients to authenticate an instance. This operation * enables the Lightsail browser-based SSH or RDP clients to connect to the * instance after a host key mismatch.

Perform this operation * only if you were expecting the host key or certificate mismatch or if you are * familiar with the new host key or certificate on the instance. For more * information, see Troubleshooting * connection issues when using the Amazon Lightsail browser-based SSH or RDP * client.

See Also:

AWS * API Reference

*/ virtual Model::DeleteKnownHostKeysOutcome DeleteKnownHostKeys(const Model::DeleteKnownHostKeysRequest& request) const; /** * A Callable wrapper for DeleteKnownHostKeys that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteKnownHostKeysOutcomeCallable DeleteKnownHostKeysCallable(const DeleteKnownHostKeysRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteKnownHostKeys, request); } /** * An Async wrapper for DeleteKnownHostKeys that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteKnownHostKeysAsync(const DeleteKnownHostKeysRequestT& request, const DeleteKnownHostKeysResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteKnownHostKeys, request, handler, context); } /** *

Deletes a Lightsail load balancer and all its associated SSL/TLS * certificates. Once the load balancer is deleted, you will need to create a new * load balancer, create a new certificate, and verify domain ownership again.

*

The delete load balancer operation supports tag-based access * control via resource tags applied to the resource identified by load * balancer name. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteLoadBalancerOutcome DeleteLoadBalancer(const Model::DeleteLoadBalancerRequest& request) const; /** * A Callable wrapper for DeleteLoadBalancer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteLoadBalancerOutcomeCallable DeleteLoadBalancerCallable(const DeleteLoadBalancerRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteLoadBalancer, request); } /** * An Async wrapper for DeleteLoadBalancer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteLoadBalancerAsync(const DeleteLoadBalancerRequestT& request, const DeleteLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteLoadBalancer, request, handler, context); } /** *

Deletes an SSL/TLS certificate associated with a Lightsail load balancer.

*

The DeleteLoadBalancerTlsCertificate operation supports * tag-based access control via resource tags applied to the resource identified by * load balancer name. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteLoadBalancerTlsCertificateOutcome DeleteLoadBalancerTlsCertificate(const Model::DeleteLoadBalancerTlsCertificateRequest& request) const; /** * A Callable wrapper for DeleteLoadBalancerTlsCertificate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteLoadBalancerTlsCertificateOutcomeCallable DeleteLoadBalancerTlsCertificateCallable(const DeleteLoadBalancerTlsCertificateRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteLoadBalancerTlsCertificate, request); } /** * An Async wrapper for DeleteLoadBalancerTlsCertificate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteLoadBalancerTlsCertificateAsync(const DeleteLoadBalancerTlsCertificateRequestT& request, const DeleteLoadBalancerTlsCertificateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteLoadBalancerTlsCertificate, request, handler, context); } /** *

Deletes a database in Amazon Lightsail.

The delete relational * database operation supports tag-based access control via resource tags * applied to the resource identified by relationalDatabaseName. For more * information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteRelationalDatabaseOutcome DeleteRelationalDatabase(const Model::DeleteRelationalDatabaseRequest& request) const; /** * A Callable wrapper for DeleteRelationalDatabase that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRelationalDatabaseOutcomeCallable DeleteRelationalDatabaseCallable(const DeleteRelationalDatabaseRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteRelationalDatabase, request); } /** * An Async wrapper for DeleteRelationalDatabase that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRelationalDatabaseAsync(const DeleteRelationalDatabaseRequestT& request, const DeleteRelationalDatabaseResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteRelationalDatabase, request, handler, context); } /** *

Deletes a database snapshot in Amazon Lightsail.

The delete * relational database snapshot operation supports tag-based access control * via resource tags applied to the resource identified by relationalDatabaseName. * For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteRelationalDatabaseSnapshotOutcome DeleteRelationalDatabaseSnapshot(const Model::DeleteRelationalDatabaseSnapshotRequest& request) const; /** * A Callable wrapper for DeleteRelationalDatabaseSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRelationalDatabaseSnapshotOutcomeCallable DeleteRelationalDatabaseSnapshotCallable(const DeleteRelationalDatabaseSnapshotRequestT& request) const { return SubmitCallable(&LightsailClient::DeleteRelationalDatabaseSnapshot, request); } /** * An Async wrapper for DeleteRelationalDatabaseSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRelationalDatabaseSnapshotAsync(const DeleteRelationalDatabaseSnapshotRequestT& request, const DeleteRelationalDatabaseSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DeleteRelationalDatabaseSnapshot, request, handler, context); } /** *

Detaches an SSL/TLS certificate from your Amazon Lightsail content delivery * network (CDN) distribution.

After the certificate is detached, your * distribution stops accepting traffic for all of the domains that are associated * with the certificate.

See Also:

AWS * API Reference

*/ virtual Model::DetachCertificateFromDistributionOutcome DetachCertificateFromDistribution(const Model::DetachCertificateFromDistributionRequest& request) const; /** * A Callable wrapper for DetachCertificateFromDistribution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DetachCertificateFromDistributionOutcomeCallable DetachCertificateFromDistributionCallable(const DetachCertificateFromDistributionRequestT& request) const { return SubmitCallable(&LightsailClient::DetachCertificateFromDistribution, request); } /** * An Async wrapper for DetachCertificateFromDistribution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DetachCertificateFromDistributionAsync(const DetachCertificateFromDistributionRequestT& request, const DetachCertificateFromDistributionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DetachCertificateFromDistribution, request, handler, context); } /** *

Detaches a stopped block storage disk from a Lightsail instance. Make sure to * unmount any file systems on the device within your operating system before * stopping the instance and detaching the disk.

The detach * disk operation supports tag-based access control via resource tags * applied to the resource identified by disk name. For more * information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::DetachDiskOutcome DetachDisk(const Model::DetachDiskRequest& request) const; /** * A Callable wrapper for DetachDisk that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DetachDiskOutcomeCallable DetachDiskCallable(const DetachDiskRequestT& request) const { return SubmitCallable(&LightsailClient::DetachDisk, request); } /** * An Async wrapper for DetachDisk that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DetachDiskAsync(const DetachDiskRequestT& request, const DetachDiskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DetachDisk, request, handler, context); } /** *

Detaches the specified instances from a Lightsail load balancer.

This * operation waits until the instances are no longer needed before they are * detached from the load balancer.

The detach instances from load * balancer operation supports tag-based access control via resource tags * applied to the resource identified by load balancer name. For more * information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::DetachInstancesFromLoadBalancerOutcome DetachInstancesFromLoadBalancer(const Model::DetachInstancesFromLoadBalancerRequest& request) const; /** * A Callable wrapper for DetachInstancesFromLoadBalancer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DetachInstancesFromLoadBalancerOutcomeCallable DetachInstancesFromLoadBalancerCallable(const DetachInstancesFromLoadBalancerRequestT& request) const { return SubmitCallable(&LightsailClient::DetachInstancesFromLoadBalancer, request); } /** * An Async wrapper for DetachInstancesFromLoadBalancer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DetachInstancesFromLoadBalancerAsync(const DetachInstancesFromLoadBalancerRequestT& request, const DetachInstancesFromLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DetachInstancesFromLoadBalancer, request, handler, context); } /** *

Detaches a static IP from the Amazon Lightsail instance to which it is * attached.

See Also:

AWS * API Reference

*/ virtual Model::DetachStaticIpOutcome DetachStaticIp(const Model::DetachStaticIpRequest& request) const; /** * A Callable wrapper for DetachStaticIp that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DetachStaticIpOutcomeCallable DetachStaticIpCallable(const DetachStaticIpRequestT& request) const { return SubmitCallable(&LightsailClient::DetachStaticIp, request); } /** * An Async wrapper for DetachStaticIp that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DetachStaticIpAsync(const DetachStaticIpRequestT& request, const DetachStaticIpResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DetachStaticIp, request, handler, context); } /** *

Disables an add-on for an Amazon Lightsail resource. For more information, * see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::DisableAddOnOutcome DisableAddOn(const Model::DisableAddOnRequest& request) const; /** * A Callable wrapper for DisableAddOn that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableAddOnOutcomeCallable DisableAddOnCallable(const DisableAddOnRequestT& request) const { return SubmitCallable(&LightsailClient::DisableAddOn, request); } /** * An Async wrapper for DisableAddOn that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableAddOnAsync(const DisableAddOnRequestT& request, const DisableAddOnResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DisableAddOn, request, handler, context); } /** *

Downloads the regional Amazon Lightsail default key pair.

This action * also creates a Lightsail default key pair if a default key pair does not * currently exist in the Amazon Web Services Region.

See Also:

AWS * API Reference

*/ virtual Model::DownloadDefaultKeyPairOutcome DownloadDefaultKeyPair(const Model::DownloadDefaultKeyPairRequest& request) const; /** * A Callable wrapper for DownloadDefaultKeyPair that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DownloadDefaultKeyPairOutcomeCallable DownloadDefaultKeyPairCallable(const DownloadDefaultKeyPairRequestT& request) const { return SubmitCallable(&LightsailClient::DownloadDefaultKeyPair, request); } /** * An Async wrapper for DownloadDefaultKeyPair that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DownloadDefaultKeyPairAsync(const DownloadDefaultKeyPairRequestT& request, const DownloadDefaultKeyPairResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::DownloadDefaultKeyPair, request, handler, context); } /** *

Enables or modifies an add-on for an Amazon Lightsail resource. For more * information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::EnableAddOnOutcome EnableAddOn(const Model::EnableAddOnRequest& request) const; /** * A Callable wrapper for EnableAddOn that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableAddOnOutcomeCallable EnableAddOnCallable(const EnableAddOnRequestT& request) const { return SubmitCallable(&LightsailClient::EnableAddOn, request); } /** * An Async wrapper for EnableAddOn that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableAddOnAsync(const EnableAddOnRequestT& request, const EnableAddOnResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::EnableAddOn, request, handler, context); } /** *

Exports an Amazon Lightsail instance or block storage disk snapshot to Amazon * Elastic Compute Cloud (Amazon EC2). This operation results in an export snapshot * record that can be used with the create cloud formation stack * operation to create new Amazon EC2 instances.

Exported instance snapshots * appear in Amazon EC2 as Amazon Machine Images (AMIs), and the instance system * disk appears as an Amazon Elastic Block Store (Amazon EBS) volume. Exported disk * snapshots appear in Amazon EC2 as Amazon EBS volumes. Snapshots are exported to * the same Amazon Web Services Region in Amazon EC2 as the source Lightsail * snapshot.

The export snapshot operation supports * tag-based access control via resource tags applied to the resource identified by * source snapshot name. For more information, see the Amazon * Lightsail Developer Guide.

Use the get instance * snapshots or get disk snapshots operations to get a list of * snapshots that you can export to Amazon EC2.

See Also:

* AWS * API Reference

*/ virtual Model::ExportSnapshotOutcome ExportSnapshot(const Model::ExportSnapshotRequest& request) const; /** * A Callable wrapper for ExportSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ExportSnapshotOutcomeCallable ExportSnapshotCallable(const ExportSnapshotRequestT& request) const { return SubmitCallable(&LightsailClient::ExportSnapshot, request); } /** * An Async wrapper for ExportSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ExportSnapshotAsync(const ExportSnapshotRequestT& request, const ExportSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::ExportSnapshot, request, handler, context); } /** *

Returns the names of all active (not deleted) resources.

See * Also:

AWS * API Reference

*/ virtual Model::GetActiveNamesOutcome GetActiveNames(const Model::GetActiveNamesRequest& request) const; /** * A Callable wrapper for GetActiveNames that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetActiveNamesOutcomeCallable GetActiveNamesCallable(const GetActiveNamesRequestT& request) const { return SubmitCallable(&LightsailClient::GetActiveNames, request); } /** * An Async wrapper for GetActiveNames that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetActiveNamesAsync(const GetActiveNamesRequestT& request, const GetActiveNamesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetActiveNames, request, handler, context); } /** *

Returns information about the configured alarms. Specify an alarm name in * your request to return information about a specific alarm, or specify a * monitored resource name to return information about all alarms for a specific * resource.

An alarm is used to monitor a single metric for one of your * resources. When a metric condition is met, the alarm can notify you by email, * SMS text message, and a banner displayed on the Amazon Lightsail console. For * more information, see Alarms * in Amazon Lightsail.

See Also:

AWS * API Reference

*/ virtual Model::GetAlarmsOutcome GetAlarms(const Model::GetAlarmsRequest& request) const; /** * A Callable wrapper for GetAlarms that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAlarmsOutcomeCallable GetAlarmsCallable(const GetAlarmsRequestT& request) const { return SubmitCallable(&LightsailClient::GetAlarms, request); } /** * An Async wrapper for GetAlarms that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAlarmsAsync(const GetAlarmsRequestT& request, const GetAlarmsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetAlarms, request, handler, context); } /** *

Returns the available automatic snapshots for an instance or disk. For more * information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetAutoSnapshotsOutcome GetAutoSnapshots(const Model::GetAutoSnapshotsRequest& request) const; /** * A Callable wrapper for GetAutoSnapshots that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAutoSnapshotsOutcomeCallable GetAutoSnapshotsCallable(const GetAutoSnapshotsRequestT& request) const { return SubmitCallable(&LightsailClient::GetAutoSnapshots, request); } /** * An Async wrapper for GetAutoSnapshots that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAutoSnapshotsAsync(const GetAutoSnapshotsRequestT& request, const GetAutoSnapshotsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetAutoSnapshots, request, handler, context); } /** *

Returns the list of available instance images, or blueprints. You can * use a blueprint to create a new instance already running a specific operating * system, as well as a preinstalled app or development stack. The software each * instance is running depends on the blueprint image you choose.

Use * active blueprints when creating new instances. Inactive blueprints are listed to * support customers with existing instances and are not necessarily available to * create new instances. Blueprints are marked inactive when they become outdated * due to operating system updates or new application releases.

*

See Also:

AWS * API Reference

*/ virtual Model::GetBlueprintsOutcome GetBlueprints(const Model::GetBlueprintsRequest& request) const; /** * A Callable wrapper for GetBlueprints that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBlueprintsOutcomeCallable GetBlueprintsCallable(const GetBlueprintsRequestT& request) const { return SubmitCallable(&LightsailClient::GetBlueprints, request); } /** * An Async wrapper for GetBlueprints that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBlueprintsAsync(const GetBlueprintsRequestT& request, const GetBlueprintsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetBlueprints, request, handler, context); } /** *

Returns the existing access key IDs for the specified Amazon Lightsail * bucket.

This action does not return the secret access key * value of an access key. You can get a secret access key only when you create it * from the response of the CreateBucketAccessKey * action. If you lose the secret access key, you must create a new access key.

*

See Also:

AWS * API Reference

*/ virtual Model::GetBucketAccessKeysOutcome GetBucketAccessKeys(const Model::GetBucketAccessKeysRequest& request) const; /** * A Callable wrapper for GetBucketAccessKeys that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketAccessKeysOutcomeCallable GetBucketAccessKeysCallable(const GetBucketAccessKeysRequestT& request) const { return SubmitCallable(&LightsailClient::GetBucketAccessKeys, request); } /** * An Async wrapper for GetBucketAccessKeys that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketAccessKeysAsync(const GetBucketAccessKeysRequestT& request, const GetBucketAccessKeysResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetBucketAccessKeys, request, handler, context); } /** *

Returns the bundles that you can apply to a Amazon Lightsail bucket.

*

The bucket bundle specifies the monthly cost, storage quota, and data * transfer quota for a bucket.

Use the UpdateBucketBundle * action to update the bundle for a bucket.

See Also:

AWS * API Reference

*/ virtual Model::GetBucketBundlesOutcome GetBucketBundles(const Model::GetBucketBundlesRequest& request) const; /** * A Callable wrapper for GetBucketBundles that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketBundlesOutcomeCallable GetBucketBundlesCallable(const GetBucketBundlesRequestT& request) const { return SubmitCallable(&LightsailClient::GetBucketBundles, request); } /** * An Async wrapper for GetBucketBundles that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketBundlesAsync(const GetBucketBundlesRequestT& request, const GetBucketBundlesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetBucketBundles, request, handler, context); } /** *

Returns the data points of a specific metric for an Amazon Lightsail * bucket.

Metrics report the utilization of a bucket. View and collect * metric data regularly to monitor the number of objects stored in a bucket * (including object versions) and the storage space used by those * objects.

See Also:

AWS * API Reference

*/ virtual Model::GetBucketMetricDataOutcome GetBucketMetricData(const Model::GetBucketMetricDataRequest& request) const; /** * A Callable wrapper for GetBucketMetricData that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketMetricDataOutcomeCallable GetBucketMetricDataCallable(const GetBucketMetricDataRequestT& request) const { return SubmitCallable(&LightsailClient::GetBucketMetricData, request); } /** * An Async wrapper for GetBucketMetricData that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketMetricDataAsync(const GetBucketMetricDataRequestT& request, const GetBucketMetricDataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetBucketMetricData, request, handler, context); } /** *

Returns information about one or more Amazon Lightsail buckets. The * information returned includes the synchronization status of the Amazon Simple * Storage Service (Amazon S3) account-level block public access feature for your * Lightsail buckets.

For more information about buckets, see Buckets * in Amazon Lightsail in the Amazon Lightsail Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetBucketsOutcome GetBuckets(const Model::GetBucketsRequest& request) const; /** * A Callable wrapper for GetBuckets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketsOutcomeCallable GetBucketsCallable(const GetBucketsRequestT& request) const { return SubmitCallable(&LightsailClient::GetBuckets, request); } /** * An Async wrapper for GetBuckets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketsAsync(const GetBucketsRequestT& request, const GetBucketsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetBuckets, request, handler, context); } /** *

Returns the bundles that you can apply to an Amazon Lightsail instance when * you create it.

A bundle describes the specifications of an instance, such * as the monthly cost, amount of memory, the number of vCPUs, amount of storage * space, and monthly network data transfer quota.

Bundles are * referred to as instance plans in the Lightsail console.

*

See Also:

AWS * API Reference

*/ virtual Model::GetBundlesOutcome GetBundles(const Model::GetBundlesRequest& request) const; /** * A Callable wrapper for GetBundles that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBundlesOutcomeCallable GetBundlesCallable(const GetBundlesRequestT& request) const { return SubmitCallable(&LightsailClient::GetBundles, request); } /** * An Async wrapper for GetBundles that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBundlesAsync(const GetBundlesRequestT& request, const GetBundlesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetBundles, request, handler, context); } /** *

Returns information about one or more Amazon Lightsail SSL/TLS * certificates.

To get a summary of a certificate, omit * includeCertificateDetails from your request. The response will * include only the certificate Amazon Resource Name (ARN), certificate name, * domain name, and tags.

See Also:

AWS * API Reference

*/ virtual Model::GetCertificatesOutcome GetCertificates(const Model::GetCertificatesRequest& request) const; /** * A Callable wrapper for GetCertificates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCertificatesOutcomeCallable GetCertificatesCallable(const GetCertificatesRequestT& request) const { return SubmitCallable(&LightsailClient::GetCertificates, request); } /** * An Async wrapper for GetCertificates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCertificatesAsync(const GetCertificatesRequestT& request, const GetCertificatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetCertificates, request, handler, context); } /** *

Returns the CloudFormation stack record created as a result of the * create cloud formation stack operation.

An AWS * CloudFormation stack is used to create a new Amazon EC2 instance from an * exported Lightsail snapshot.

See Also:

AWS * API Reference

*/ virtual Model::GetCloudFormationStackRecordsOutcome GetCloudFormationStackRecords(const Model::GetCloudFormationStackRecordsRequest& request) const; /** * A Callable wrapper for GetCloudFormationStackRecords that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCloudFormationStackRecordsOutcomeCallable GetCloudFormationStackRecordsCallable(const GetCloudFormationStackRecordsRequestT& request) const { return SubmitCallable(&LightsailClient::GetCloudFormationStackRecords, request); } /** * An Async wrapper for GetCloudFormationStackRecords that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCloudFormationStackRecordsAsync(const GetCloudFormationStackRecordsRequestT& request, const GetCloudFormationStackRecordsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetCloudFormationStackRecords, request, handler, context); } /** *

Returns information about the configured contact methods. Specify a protocol * in your request to return information about a specific contact method.

A * contact method is used to send you notifications about your Amazon Lightsail * resources. You can add one email address and one mobile phone number contact * method in each Amazon Web Services Region. However, SMS text messaging is not * supported in some Amazon Web Services Regions, and SMS text messages cannot be * sent to some countries/regions. For more information, see Notifications * in Amazon Lightsail.

See Also:

AWS * API Reference

*/ virtual Model::GetContactMethodsOutcome GetContactMethods(const Model::GetContactMethodsRequest& request) const; /** * A Callable wrapper for GetContactMethods that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetContactMethodsOutcomeCallable GetContactMethodsCallable(const GetContactMethodsRequestT& request) const { return SubmitCallable(&LightsailClient::GetContactMethods, request); } /** * An Async wrapper for GetContactMethods that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetContactMethodsAsync(const GetContactMethodsRequestT& request, const GetContactMethodsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetContactMethods, request, handler, context); } /** *

Returns information about Amazon Lightsail containers, such as the current * version of the Lightsail Control (lightsailctl) plugin.

See Also:

* AWS * API Reference

*/ virtual Model::GetContainerAPIMetadataOutcome GetContainerAPIMetadata(const Model::GetContainerAPIMetadataRequest& request) const; /** * A Callable wrapper for GetContainerAPIMetadata that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetContainerAPIMetadataOutcomeCallable GetContainerAPIMetadataCallable(const GetContainerAPIMetadataRequestT& request) const { return SubmitCallable(&LightsailClient::GetContainerAPIMetadata, request); } /** * An Async wrapper for GetContainerAPIMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetContainerAPIMetadataAsync(const GetContainerAPIMetadataRequestT& request, const GetContainerAPIMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetContainerAPIMetadata, request, handler, context); } /** *

Returns the container images that are registered to your Amazon Lightsail * container service.

If you created a deployment on your Lightsail * container service that uses container images from a public registry like Docker * Hub, those images are not returned as part of this action. Those images are not * registered to your Lightsail container service.

See Also:

* AWS * API Reference

*/ virtual Model::GetContainerImagesOutcome GetContainerImages(const Model::GetContainerImagesRequest& request) const; /** * A Callable wrapper for GetContainerImages that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetContainerImagesOutcomeCallable GetContainerImagesCallable(const GetContainerImagesRequestT& request) const { return SubmitCallable(&LightsailClient::GetContainerImages, request); } /** * An Async wrapper for GetContainerImages that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetContainerImagesAsync(const GetContainerImagesRequestT& request, const GetContainerImagesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetContainerImages, request, handler, context); } /** *

Returns the log events of a container of your Amazon Lightsail container * service.

If your container service has more than one node (i.e., a scale * greater than 1), then the log events that are returned for the specified * container are merged from all nodes on your container service.

*

Container logs are retained for a certain amount of time. For more * information, see Amazon * Lightsail endpoints and quotas in the Amazon Web Services General * Reference.

See Also:

AWS * API Reference

*/ virtual Model::GetContainerLogOutcome GetContainerLog(const Model::GetContainerLogRequest& request) const; /** * A Callable wrapper for GetContainerLog that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetContainerLogOutcomeCallable GetContainerLogCallable(const GetContainerLogRequestT& request) const { return SubmitCallable(&LightsailClient::GetContainerLog, request); } /** * An Async wrapper for GetContainerLog that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetContainerLogAsync(const GetContainerLogRequestT& request, const GetContainerLogResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetContainerLog, request, handler, context); } /** *

Returns the deployments for your Amazon Lightsail container service

A * deployment specifies the settings, such as the ports and launch command, of * containers that are deployed to your container service.

The deployments * are ordered by version in ascending order. The newest version is listed at the * top of the response.

A set number of deployments are kept before * the oldest one is replaced with the newest one. For more information, see Amazon * Lightsail endpoints and quotas in the Amazon Web Services General * Reference.

See Also:

AWS * API Reference

*/ virtual Model::GetContainerServiceDeploymentsOutcome GetContainerServiceDeployments(const Model::GetContainerServiceDeploymentsRequest& request) const; /** * A Callable wrapper for GetContainerServiceDeployments that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetContainerServiceDeploymentsOutcomeCallable GetContainerServiceDeploymentsCallable(const GetContainerServiceDeploymentsRequestT& request) const { return SubmitCallable(&LightsailClient::GetContainerServiceDeployments, request); } /** * An Async wrapper for GetContainerServiceDeployments that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetContainerServiceDeploymentsAsync(const GetContainerServiceDeploymentsRequestT& request, const GetContainerServiceDeploymentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetContainerServiceDeployments, request, handler, context); } /** *

Returns the data points of a specific metric of your Amazon Lightsail * container service.

Metrics report the utilization of your resources. * Monitor and collect metric data regularly to maintain the reliability, * availability, and performance of your resources.

See Also:

AWS * API Reference

*/ virtual Model::GetContainerServiceMetricDataOutcome GetContainerServiceMetricData(const Model::GetContainerServiceMetricDataRequest& request) const; /** * A Callable wrapper for GetContainerServiceMetricData that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetContainerServiceMetricDataOutcomeCallable GetContainerServiceMetricDataCallable(const GetContainerServiceMetricDataRequestT& request) const { return SubmitCallable(&LightsailClient::GetContainerServiceMetricData, request); } /** * An Async wrapper for GetContainerServiceMetricData that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetContainerServiceMetricDataAsync(const GetContainerServiceMetricDataRequestT& request, const GetContainerServiceMetricDataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetContainerServiceMetricData, request, handler, context); } /** *

Returns the list of powers that can be specified for your Amazon Lightsail * container services.

The power specifies the amount of memory, the number * of vCPUs, and the base price of the container service.

See Also:

* AWS * API Reference

*/ virtual Model::GetContainerServicePowersOutcome GetContainerServicePowers(const Model::GetContainerServicePowersRequest& request) const; /** * A Callable wrapper for GetContainerServicePowers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetContainerServicePowersOutcomeCallable GetContainerServicePowersCallable(const GetContainerServicePowersRequestT& request) const { return SubmitCallable(&LightsailClient::GetContainerServicePowers, request); } /** * An Async wrapper for GetContainerServicePowers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetContainerServicePowersAsync(const GetContainerServicePowersRequestT& request, const GetContainerServicePowersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetContainerServicePowers, request, handler, context); } /** *

Returns information about one or more of your Amazon Lightsail container * services.

See Also:

AWS * API Reference

*/ virtual Model::GetContainerServicesOutcome GetContainerServices(const Model::GetContainerServicesRequest& request) const; /** * A Callable wrapper for GetContainerServices that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetContainerServicesOutcomeCallable GetContainerServicesCallable(const GetContainerServicesRequestT& request) const { return SubmitCallable(&LightsailClient::GetContainerServices, request); } /** * An Async wrapper for GetContainerServices that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetContainerServicesAsync(const GetContainerServicesRequestT& request, const GetContainerServicesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetContainerServices, request, handler, context); } /** *

Retrieves information about the cost estimate for a specified resource. A * cost estimate will not generate for a resource that has been * deleted.

See Also:

AWS * API Reference

*/ virtual Model::GetCostEstimateOutcome GetCostEstimate(const Model::GetCostEstimateRequest& request) const; /** * A Callable wrapper for GetCostEstimate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCostEstimateOutcomeCallable GetCostEstimateCallable(const GetCostEstimateRequestT& request) const { return SubmitCallable(&LightsailClient::GetCostEstimate, request); } /** * An Async wrapper for GetCostEstimate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCostEstimateAsync(const GetCostEstimateRequestT& request, const GetCostEstimateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetCostEstimate, request, handler, context); } /** *

Returns information about a specific block storage disk.

See * Also:

AWS * API Reference

*/ virtual Model::GetDiskOutcome GetDisk(const Model::GetDiskRequest& request) const; /** * A Callable wrapper for GetDisk that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDiskOutcomeCallable GetDiskCallable(const GetDiskRequestT& request) const { return SubmitCallable(&LightsailClient::GetDisk, request); } /** * An Async wrapper for GetDisk that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDiskAsync(const GetDiskRequestT& request, const GetDiskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetDisk, request, handler, context); } /** *

Returns information about a specific block storage disk * snapshot.

See Also:

AWS * API Reference

*/ virtual Model::GetDiskSnapshotOutcome GetDiskSnapshot(const Model::GetDiskSnapshotRequest& request) const; /** * A Callable wrapper for GetDiskSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDiskSnapshotOutcomeCallable GetDiskSnapshotCallable(const GetDiskSnapshotRequestT& request) const { return SubmitCallable(&LightsailClient::GetDiskSnapshot, request); } /** * An Async wrapper for GetDiskSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDiskSnapshotAsync(const GetDiskSnapshotRequestT& request, const GetDiskSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetDiskSnapshot, request, handler, context); } /** *

Returns information about all block storage disk snapshots in your AWS * account and region.

See Also:

AWS * API Reference

*/ virtual Model::GetDiskSnapshotsOutcome GetDiskSnapshots(const Model::GetDiskSnapshotsRequest& request) const; /** * A Callable wrapper for GetDiskSnapshots that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDiskSnapshotsOutcomeCallable GetDiskSnapshotsCallable(const GetDiskSnapshotsRequestT& request) const { return SubmitCallable(&LightsailClient::GetDiskSnapshots, request); } /** * An Async wrapper for GetDiskSnapshots that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDiskSnapshotsAsync(const GetDiskSnapshotsRequestT& request, const GetDiskSnapshotsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetDiskSnapshots, request, handler, context); } /** *

Returns information about all block storage disks in your AWS account and * region.

See Also:

AWS * API Reference

*/ virtual Model::GetDisksOutcome GetDisks(const Model::GetDisksRequest& request) const; /** * A Callable wrapper for GetDisks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDisksOutcomeCallable GetDisksCallable(const GetDisksRequestT& request) const { return SubmitCallable(&LightsailClient::GetDisks, request); } /** * An Async wrapper for GetDisks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDisksAsync(const GetDisksRequestT& request, const GetDisksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetDisks, request, handler, context); } /** *

Returns the bundles that can be applied to your Amazon Lightsail content * delivery network (CDN) distributions.

A distribution bundle specifies the * monthly network transfer quota and monthly cost of your * distribution.

See Also:

AWS * API Reference

*/ virtual Model::GetDistributionBundlesOutcome GetDistributionBundles(const Model::GetDistributionBundlesRequest& request) const; /** * A Callable wrapper for GetDistributionBundles that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDistributionBundlesOutcomeCallable GetDistributionBundlesCallable(const GetDistributionBundlesRequestT& request) const { return SubmitCallable(&LightsailClient::GetDistributionBundles, request); } /** * An Async wrapper for GetDistributionBundles that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDistributionBundlesAsync(const GetDistributionBundlesRequestT& request, const GetDistributionBundlesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetDistributionBundles, request, handler, context); } /** *

Returns the timestamp and status of the last cache reset of a specific Amazon * Lightsail content delivery network (CDN) distribution.

See Also:

* AWS * API Reference

*/ virtual Model::GetDistributionLatestCacheResetOutcome GetDistributionLatestCacheReset(const Model::GetDistributionLatestCacheResetRequest& request) const; /** * A Callable wrapper for GetDistributionLatestCacheReset that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDistributionLatestCacheResetOutcomeCallable GetDistributionLatestCacheResetCallable(const GetDistributionLatestCacheResetRequestT& request) const { return SubmitCallable(&LightsailClient::GetDistributionLatestCacheReset, request); } /** * An Async wrapper for GetDistributionLatestCacheReset that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDistributionLatestCacheResetAsync(const GetDistributionLatestCacheResetRequestT& request, const GetDistributionLatestCacheResetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetDistributionLatestCacheReset, request, handler, context); } /** *

Returns the data points of a specific metric for an Amazon Lightsail content * delivery network (CDN) distribution.

Metrics report the utilization of * your resources, and the error counts generated by them. Monitor and collect * metric data regularly to maintain the reliability, availability, and performance * of your resources.

See Also:

AWS * API Reference

*/ virtual Model::GetDistributionMetricDataOutcome GetDistributionMetricData(const Model::GetDistributionMetricDataRequest& request) const; /** * A Callable wrapper for GetDistributionMetricData that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDistributionMetricDataOutcomeCallable GetDistributionMetricDataCallable(const GetDistributionMetricDataRequestT& request) const { return SubmitCallable(&LightsailClient::GetDistributionMetricData, request); } /** * An Async wrapper for GetDistributionMetricData that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDistributionMetricDataAsync(const GetDistributionMetricDataRequestT& request, const GetDistributionMetricDataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetDistributionMetricData, request, handler, context); } /** *

Returns information about one or more of your Amazon Lightsail content * delivery network (CDN) distributions.

See Also:

AWS * API Reference

*/ virtual Model::GetDistributionsOutcome GetDistributions(const Model::GetDistributionsRequest& request) const; /** * A Callable wrapper for GetDistributions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDistributionsOutcomeCallable GetDistributionsCallable(const GetDistributionsRequestT& request) const { return SubmitCallable(&LightsailClient::GetDistributions, request); } /** * An Async wrapper for GetDistributions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDistributionsAsync(const GetDistributionsRequestT& request, const GetDistributionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetDistributions, request, handler, context); } /** *

Returns information about a specific domain recordset.

See * Also:

AWS * API Reference

*/ virtual Model::GetDomainOutcome GetDomain(const Model::GetDomainRequest& request) const; /** * A Callable wrapper for GetDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDomainOutcomeCallable GetDomainCallable(const GetDomainRequestT& request) const { return SubmitCallable(&LightsailClient::GetDomain, request); } /** * An Async wrapper for GetDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDomainAsync(const GetDomainRequestT& request, const GetDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetDomain, request, handler, context); } /** *

Returns a list of all domains in the user's account.

See Also:

* AWS * API Reference

*/ virtual Model::GetDomainsOutcome GetDomains(const Model::GetDomainsRequest& request) const; /** * A Callable wrapper for GetDomains that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDomainsOutcomeCallable GetDomainsCallable(const GetDomainsRequestT& request) const { return SubmitCallable(&LightsailClient::GetDomains, request); } /** * An Async wrapper for GetDomains that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDomainsAsync(const GetDomainsRequestT& request, const GetDomainsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetDomains, request, handler, context); } /** *

Returns all export snapshot records created as a result of the export * snapshot operation.

An export snapshot record can be used to * create a new Amazon EC2 instance and its related resources with the CreateCloudFormationStack * action.

See Also:

AWS * API Reference

*/ virtual Model::GetExportSnapshotRecordsOutcome GetExportSnapshotRecords(const Model::GetExportSnapshotRecordsRequest& request) const; /** * A Callable wrapper for GetExportSnapshotRecords that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetExportSnapshotRecordsOutcomeCallable GetExportSnapshotRecordsCallable(const GetExportSnapshotRecordsRequestT& request) const { return SubmitCallable(&LightsailClient::GetExportSnapshotRecords, request); } /** * An Async wrapper for GetExportSnapshotRecords that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetExportSnapshotRecordsAsync(const GetExportSnapshotRecordsRequestT& request, const GetExportSnapshotRecordsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetExportSnapshotRecords, request, handler, context); } /** *

Returns information about a specific Amazon Lightsail instance, which is a * virtual private server.

See Also:

AWS * API Reference

*/ virtual Model::GetInstanceOutcome GetInstance(const Model::GetInstanceRequest& request) const; /** * A Callable wrapper for GetInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetInstanceOutcomeCallable GetInstanceCallable(const GetInstanceRequestT& request) const { return SubmitCallable(&LightsailClient::GetInstance, request); } /** * An Async wrapper for GetInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetInstanceAsync(const GetInstanceRequestT& request, const GetInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetInstance, request, handler, context); } /** *

Returns temporary SSH keys you can use to connect to a specific virtual * private server, or instance.

The get instance access * details operation supports tag-based access control via resource tags * applied to the resource identified by instance name. For more * information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetInstanceAccessDetailsOutcome GetInstanceAccessDetails(const Model::GetInstanceAccessDetailsRequest& request) const; /** * A Callable wrapper for GetInstanceAccessDetails that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetInstanceAccessDetailsOutcomeCallable GetInstanceAccessDetailsCallable(const GetInstanceAccessDetailsRequestT& request) const { return SubmitCallable(&LightsailClient::GetInstanceAccessDetails, request); } /** * An Async wrapper for GetInstanceAccessDetails that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetInstanceAccessDetailsAsync(const GetInstanceAccessDetailsRequestT& request, const GetInstanceAccessDetailsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetInstanceAccessDetails, request, handler, context); } /** *

Returns the data points for the specified Amazon Lightsail instance metric, * given an instance name.

Metrics report the utilization of your resources, * and the error counts generated by them. Monitor and collect metric data * regularly to maintain the reliability, availability, and performance of your * resources.

See Also:

AWS * API Reference

*/ virtual Model::GetInstanceMetricDataOutcome GetInstanceMetricData(const Model::GetInstanceMetricDataRequest& request) const; /** * A Callable wrapper for GetInstanceMetricData that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetInstanceMetricDataOutcomeCallable GetInstanceMetricDataCallable(const GetInstanceMetricDataRequestT& request) const { return SubmitCallable(&LightsailClient::GetInstanceMetricData, request); } /** * An Async wrapper for GetInstanceMetricData that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetInstanceMetricDataAsync(const GetInstanceMetricDataRequestT& request, const GetInstanceMetricDataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetInstanceMetricData, request, handler, context); } /** *

Returns the firewall port states for a specific Amazon Lightsail instance, * the IP addresses allowed to connect to the instance through the ports, and the * protocol.

See Also:

AWS * API Reference

*/ virtual Model::GetInstancePortStatesOutcome GetInstancePortStates(const Model::GetInstancePortStatesRequest& request) const; /** * A Callable wrapper for GetInstancePortStates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetInstancePortStatesOutcomeCallable GetInstancePortStatesCallable(const GetInstancePortStatesRequestT& request) const { return SubmitCallable(&LightsailClient::GetInstancePortStates, request); } /** * An Async wrapper for GetInstancePortStates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetInstancePortStatesAsync(const GetInstancePortStatesRequestT& request, const GetInstancePortStatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetInstancePortStates, request, handler, context); } /** *

Returns information about a specific instance snapshot.

See * Also:

AWS * API Reference

*/ virtual Model::GetInstanceSnapshotOutcome GetInstanceSnapshot(const Model::GetInstanceSnapshotRequest& request) const; /** * A Callable wrapper for GetInstanceSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetInstanceSnapshotOutcomeCallable GetInstanceSnapshotCallable(const GetInstanceSnapshotRequestT& request) const { return SubmitCallable(&LightsailClient::GetInstanceSnapshot, request); } /** * An Async wrapper for GetInstanceSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetInstanceSnapshotAsync(const GetInstanceSnapshotRequestT& request, const GetInstanceSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetInstanceSnapshot, request, handler, context); } /** *

Returns all instance snapshots for the user's account.

See * Also:

AWS * API Reference

*/ virtual Model::GetInstanceSnapshotsOutcome GetInstanceSnapshots(const Model::GetInstanceSnapshotsRequest& request) const; /** * A Callable wrapper for GetInstanceSnapshots that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetInstanceSnapshotsOutcomeCallable GetInstanceSnapshotsCallable(const GetInstanceSnapshotsRequestT& request) const { return SubmitCallable(&LightsailClient::GetInstanceSnapshots, request); } /** * An Async wrapper for GetInstanceSnapshots that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetInstanceSnapshotsAsync(const GetInstanceSnapshotsRequestT& request, const GetInstanceSnapshotsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetInstanceSnapshots, request, handler, context); } /** *

Returns the state of a specific instance. Works on one instance at a * time.

See Also:

AWS * API Reference

*/ virtual Model::GetInstanceStateOutcome GetInstanceState(const Model::GetInstanceStateRequest& request) const; /** * A Callable wrapper for GetInstanceState that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetInstanceStateOutcomeCallable GetInstanceStateCallable(const GetInstanceStateRequestT& request) const { return SubmitCallable(&LightsailClient::GetInstanceState, request); } /** * An Async wrapper for GetInstanceState that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetInstanceStateAsync(const GetInstanceStateRequestT& request, const GetInstanceStateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetInstanceState, request, handler, context); } /** *

Returns information about all Amazon Lightsail virtual private servers, or * instances.

See Also:

AWS * API Reference

*/ virtual Model::GetInstancesOutcome GetInstances(const Model::GetInstancesRequest& request) const; /** * A Callable wrapper for GetInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetInstancesOutcomeCallable GetInstancesCallable(const GetInstancesRequestT& request) const { return SubmitCallable(&LightsailClient::GetInstances, request); } /** * An Async wrapper for GetInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetInstancesAsync(const GetInstancesRequestT& request, const GetInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetInstances, request, handler, context); } /** *

Returns information about a specific key pair.

See Also:

AWS * API Reference

*/ virtual Model::GetKeyPairOutcome GetKeyPair(const Model::GetKeyPairRequest& request) const; /** * A Callable wrapper for GetKeyPair that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetKeyPairOutcomeCallable GetKeyPairCallable(const GetKeyPairRequestT& request) const { return SubmitCallable(&LightsailClient::GetKeyPair, request); } /** * An Async wrapper for GetKeyPair that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetKeyPairAsync(const GetKeyPairRequestT& request, const GetKeyPairResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetKeyPair, request, handler, context); } /** *

Returns information about all key pairs in the user's account.

See * Also:

AWS * API Reference

*/ virtual Model::GetKeyPairsOutcome GetKeyPairs(const Model::GetKeyPairsRequest& request) const; /** * A Callable wrapper for GetKeyPairs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetKeyPairsOutcomeCallable GetKeyPairsCallable(const GetKeyPairsRequestT& request) const { return SubmitCallable(&LightsailClient::GetKeyPairs, request); } /** * An Async wrapper for GetKeyPairs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetKeyPairsAsync(const GetKeyPairsRequestT& request, const GetKeyPairsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetKeyPairs, request, handler, context); } /** *

Returns information about the specified Lightsail load * balancer.

See Also:

AWS * API Reference

*/ virtual Model::GetLoadBalancerOutcome GetLoadBalancer(const Model::GetLoadBalancerRequest& request) const; /** * A Callable wrapper for GetLoadBalancer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetLoadBalancerOutcomeCallable GetLoadBalancerCallable(const GetLoadBalancerRequestT& request) const { return SubmitCallable(&LightsailClient::GetLoadBalancer, request); } /** * An Async wrapper for GetLoadBalancer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetLoadBalancerAsync(const GetLoadBalancerRequestT& request, const GetLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetLoadBalancer, request, handler, context); } /** *

Returns information about health metrics for your Lightsail load * balancer.

Metrics report the utilization of your resources, and the error * counts generated by them. Monitor and collect metric data regularly to maintain * the reliability, availability, and performance of your resources.

See * Also:

AWS * API Reference

*/ virtual Model::GetLoadBalancerMetricDataOutcome GetLoadBalancerMetricData(const Model::GetLoadBalancerMetricDataRequest& request) const; /** * A Callable wrapper for GetLoadBalancerMetricData that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetLoadBalancerMetricDataOutcomeCallable GetLoadBalancerMetricDataCallable(const GetLoadBalancerMetricDataRequestT& request) const { return SubmitCallable(&LightsailClient::GetLoadBalancerMetricData, request); } /** * An Async wrapper for GetLoadBalancerMetricData that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetLoadBalancerMetricDataAsync(const GetLoadBalancerMetricDataRequestT& request, const GetLoadBalancerMetricDataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetLoadBalancerMetricData, request, handler, context); } /** *

Returns information about the TLS certificates that are associated with the * specified Lightsail load balancer.

TLS is just an updated, more secure * version of Secure Socket Layer (SSL).

You can have a maximum of 2 * certificates associated with a Lightsail load balancer. One is active and the * other is inactive.

See Also:

AWS * API Reference

*/ virtual Model::GetLoadBalancerTlsCertificatesOutcome GetLoadBalancerTlsCertificates(const Model::GetLoadBalancerTlsCertificatesRequest& request) const; /** * A Callable wrapper for GetLoadBalancerTlsCertificates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetLoadBalancerTlsCertificatesOutcomeCallable GetLoadBalancerTlsCertificatesCallable(const GetLoadBalancerTlsCertificatesRequestT& request) const { return SubmitCallable(&LightsailClient::GetLoadBalancerTlsCertificates, request); } /** * An Async wrapper for GetLoadBalancerTlsCertificates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetLoadBalancerTlsCertificatesAsync(const GetLoadBalancerTlsCertificatesRequestT& request, const GetLoadBalancerTlsCertificatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetLoadBalancerTlsCertificates, request, handler, context); } /** *

Returns a list of TLS security policies that you can apply to Lightsail load * balancers.

For more information about load balancer TLS security * policies, see Configuring * TLS security policies on your Amazon Lightsail load balancers in the * Amazon Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetLoadBalancerTlsPoliciesOutcome GetLoadBalancerTlsPolicies(const Model::GetLoadBalancerTlsPoliciesRequest& request) const; /** * A Callable wrapper for GetLoadBalancerTlsPolicies that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetLoadBalancerTlsPoliciesOutcomeCallable GetLoadBalancerTlsPoliciesCallable(const GetLoadBalancerTlsPoliciesRequestT& request) const { return SubmitCallable(&LightsailClient::GetLoadBalancerTlsPolicies, request); } /** * An Async wrapper for GetLoadBalancerTlsPolicies that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetLoadBalancerTlsPoliciesAsync(const GetLoadBalancerTlsPoliciesRequestT& request, const GetLoadBalancerTlsPoliciesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetLoadBalancerTlsPolicies, request, handler, context); } /** *

Returns information about all load balancers in an account.

See * Also:

AWS * API Reference

*/ virtual Model::GetLoadBalancersOutcome GetLoadBalancers(const Model::GetLoadBalancersRequest& request) const; /** * A Callable wrapper for GetLoadBalancers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetLoadBalancersOutcomeCallable GetLoadBalancersCallable(const GetLoadBalancersRequestT& request) const { return SubmitCallable(&LightsailClient::GetLoadBalancers, request); } /** * An Async wrapper for GetLoadBalancers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetLoadBalancersAsync(const GetLoadBalancersRequestT& request, const GetLoadBalancersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetLoadBalancers, request, handler, context); } /** *

Returns information about a specific operation. Operations include events * such as when you create an instance, allocate a static IP, attach a static IP, * and so on.

See Also:

AWS * API Reference

*/ virtual Model::GetOperationOutcome GetOperation(const Model::GetOperationRequest& request) const; /** * A Callable wrapper for GetOperation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetOperationOutcomeCallable GetOperationCallable(const GetOperationRequestT& request) const { return SubmitCallable(&LightsailClient::GetOperation, request); } /** * An Async wrapper for GetOperation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetOperationAsync(const GetOperationRequestT& request, const GetOperationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetOperation, request, handler, context); } /** *

Returns information about all operations.

Results are returned from * oldest to newest, up to a maximum of 200. Results can be paged by making each * subsequent call to GetOperations use the maximum (last) * statusChangedAt value from the previous request.

See * Also:

AWS * API Reference

*/ virtual Model::GetOperationsOutcome GetOperations(const Model::GetOperationsRequest& request) const; /** * A Callable wrapper for GetOperations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetOperationsOutcomeCallable GetOperationsCallable(const GetOperationsRequestT& request) const { return SubmitCallable(&LightsailClient::GetOperations, request); } /** * An Async wrapper for GetOperations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetOperationsAsync(const GetOperationsRequestT& request, const GetOperationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetOperations, request, handler, context); } /** *

Gets operations for a specific resource (e.g., an instance or a static * IP).

See Also:

AWS * API Reference

*/ virtual Model::GetOperationsForResourceOutcome GetOperationsForResource(const Model::GetOperationsForResourceRequest& request) const; /** * A Callable wrapper for GetOperationsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetOperationsForResourceOutcomeCallable GetOperationsForResourceCallable(const GetOperationsForResourceRequestT& request) const { return SubmitCallable(&LightsailClient::GetOperationsForResource, request); } /** * An Async wrapper for GetOperationsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetOperationsForResourceAsync(const GetOperationsForResourceRequestT& request, const GetOperationsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetOperationsForResource, request, handler, context); } /** *

Returns a list of all valid regions for Amazon Lightsail. Use the * include availability zones parameter to also return the * Availability Zones in a region.

See Also:

AWS * API Reference

*/ virtual Model::GetRegionsOutcome GetRegions(const Model::GetRegionsRequest& request) const; /** * A Callable wrapper for GetRegions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRegionsOutcomeCallable GetRegionsCallable(const GetRegionsRequestT& request) const { return SubmitCallable(&LightsailClient::GetRegions, request); } /** * An Async wrapper for GetRegions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRegionsAsync(const GetRegionsRequestT& request, const GetRegionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetRegions, request, handler, context); } /** *

Returns information about a specific database in Amazon * Lightsail.

See Also:

AWS * API Reference

*/ virtual Model::GetRelationalDatabaseOutcome GetRelationalDatabase(const Model::GetRelationalDatabaseRequest& request) const; /** * A Callable wrapper for GetRelationalDatabase that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRelationalDatabaseOutcomeCallable GetRelationalDatabaseCallable(const GetRelationalDatabaseRequestT& request) const { return SubmitCallable(&LightsailClient::GetRelationalDatabase, request); } /** * An Async wrapper for GetRelationalDatabase that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRelationalDatabaseAsync(const GetRelationalDatabaseRequestT& request, const GetRelationalDatabaseResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetRelationalDatabase, request, handler, context); } /** *

Returns a list of available database blueprints in Amazon Lightsail. A * blueprint describes the major engine version of a database.

You can use a * blueprint ID to create a new database that runs a specific database * engine.

See Also:

AWS * API Reference

*/ virtual Model::GetRelationalDatabaseBlueprintsOutcome GetRelationalDatabaseBlueprints(const Model::GetRelationalDatabaseBlueprintsRequest& request) const; /** * A Callable wrapper for GetRelationalDatabaseBlueprints that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRelationalDatabaseBlueprintsOutcomeCallable GetRelationalDatabaseBlueprintsCallable(const GetRelationalDatabaseBlueprintsRequestT& request) const { return SubmitCallable(&LightsailClient::GetRelationalDatabaseBlueprints, request); } /** * An Async wrapper for GetRelationalDatabaseBlueprints that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRelationalDatabaseBlueprintsAsync(const GetRelationalDatabaseBlueprintsRequestT& request, const GetRelationalDatabaseBlueprintsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetRelationalDatabaseBlueprints, request, handler, context); } /** *

Returns the list of bundles that are available in Amazon Lightsail. A bundle * describes the performance specifications for a database.

You can use a * bundle ID to create a new database with explicit performance * specifications.

See Also:

AWS * API Reference

*/ virtual Model::GetRelationalDatabaseBundlesOutcome GetRelationalDatabaseBundles(const Model::GetRelationalDatabaseBundlesRequest& request) const; /** * A Callable wrapper for GetRelationalDatabaseBundles that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRelationalDatabaseBundlesOutcomeCallable GetRelationalDatabaseBundlesCallable(const GetRelationalDatabaseBundlesRequestT& request) const { return SubmitCallable(&LightsailClient::GetRelationalDatabaseBundles, request); } /** * An Async wrapper for GetRelationalDatabaseBundles that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRelationalDatabaseBundlesAsync(const GetRelationalDatabaseBundlesRequestT& request, const GetRelationalDatabaseBundlesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetRelationalDatabaseBundles, request, handler, context); } /** *

Returns a list of events for a specific database in Amazon * Lightsail.

See Also:

AWS * API Reference

*/ virtual Model::GetRelationalDatabaseEventsOutcome GetRelationalDatabaseEvents(const Model::GetRelationalDatabaseEventsRequest& request) const; /** * A Callable wrapper for GetRelationalDatabaseEvents that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRelationalDatabaseEventsOutcomeCallable GetRelationalDatabaseEventsCallable(const GetRelationalDatabaseEventsRequestT& request) const { return SubmitCallable(&LightsailClient::GetRelationalDatabaseEvents, request); } /** * An Async wrapper for GetRelationalDatabaseEvents that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRelationalDatabaseEventsAsync(const GetRelationalDatabaseEventsRequestT& request, const GetRelationalDatabaseEventsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetRelationalDatabaseEvents, request, handler, context); } /** *

Returns a list of log events for a database in Amazon * Lightsail.

See Also:

AWS * API Reference

*/ virtual Model::GetRelationalDatabaseLogEventsOutcome GetRelationalDatabaseLogEvents(const Model::GetRelationalDatabaseLogEventsRequest& request) const; /** * A Callable wrapper for GetRelationalDatabaseLogEvents that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRelationalDatabaseLogEventsOutcomeCallable GetRelationalDatabaseLogEventsCallable(const GetRelationalDatabaseLogEventsRequestT& request) const { return SubmitCallable(&LightsailClient::GetRelationalDatabaseLogEvents, request); } /** * An Async wrapper for GetRelationalDatabaseLogEvents that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRelationalDatabaseLogEventsAsync(const GetRelationalDatabaseLogEventsRequestT& request, const GetRelationalDatabaseLogEventsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetRelationalDatabaseLogEvents, request, handler, context); } /** *

Returns a list of available log streams for a specific database in Amazon * Lightsail.

See Also:

AWS * API Reference

*/ virtual Model::GetRelationalDatabaseLogStreamsOutcome GetRelationalDatabaseLogStreams(const Model::GetRelationalDatabaseLogStreamsRequest& request) const; /** * A Callable wrapper for GetRelationalDatabaseLogStreams that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRelationalDatabaseLogStreamsOutcomeCallable GetRelationalDatabaseLogStreamsCallable(const GetRelationalDatabaseLogStreamsRequestT& request) const { return SubmitCallable(&LightsailClient::GetRelationalDatabaseLogStreams, request); } /** * An Async wrapper for GetRelationalDatabaseLogStreams that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRelationalDatabaseLogStreamsAsync(const GetRelationalDatabaseLogStreamsRequestT& request, const GetRelationalDatabaseLogStreamsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetRelationalDatabaseLogStreams, request, handler, context); } /** *

Returns the current, previous, or pending versions of the master user * password for a Lightsail database.

The * GetRelationalDatabaseMasterUserPassword operation supports * tag-based access control via resource tags applied to the resource identified by * relationalDatabaseName.

See Also:

AWS * API Reference

*/ virtual Model::GetRelationalDatabaseMasterUserPasswordOutcome GetRelationalDatabaseMasterUserPassword(const Model::GetRelationalDatabaseMasterUserPasswordRequest& request) const; /** * A Callable wrapper for GetRelationalDatabaseMasterUserPassword that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRelationalDatabaseMasterUserPasswordOutcomeCallable GetRelationalDatabaseMasterUserPasswordCallable(const GetRelationalDatabaseMasterUserPasswordRequestT& request) const { return SubmitCallable(&LightsailClient::GetRelationalDatabaseMasterUserPassword, request); } /** * An Async wrapper for GetRelationalDatabaseMasterUserPassword that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRelationalDatabaseMasterUserPasswordAsync(const GetRelationalDatabaseMasterUserPasswordRequestT& request, const GetRelationalDatabaseMasterUserPasswordResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetRelationalDatabaseMasterUserPassword, request, handler, context); } /** *

Returns the data points of the specified metric for a database in Amazon * Lightsail.

Metrics report the utilization of your resources, and the * error counts generated by them. Monitor and collect metric data regularly to * maintain the reliability, availability, and performance of your * resources.

See Also:

AWS * API Reference

*/ virtual Model::GetRelationalDatabaseMetricDataOutcome GetRelationalDatabaseMetricData(const Model::GetRelationalDatabaseMetricDataRequest& request) const; /** * A Callable wrapper for GetRelationalDatabaseMetricData that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRelationalDatabaseMetricDataOutcomeCallable GetRelationalDatabaseMetricDataCallable(const GetRelationalDatabaseMetricDataRequestT& request) const { return SubmitCallable(&LightsailClient::GetRelationalDatabaseMetricData, request); } /** * An Async wrapper for GetRelationalDatabaseMetricData that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRelationalDatabaseMetricDataAsync(const GetRelationalDatabaseMetricDataRequestT& request, const GetRelationalDatabaseMetricDataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetRelationalDatabaseMetricData, request, handler, context); } /** *

Returns all of the runtime parameters offered by the underlying database * software, or engine, for a specific database in Amazon Lightsail.

In * addition to the parameter names and values, this operation returns other * information about each parameter. This information includes whether changes * require a reboot, whether the parameter is modifiable, the allowed values, and * the data types.

See Also:

AWS * API Reference

*/ virtual Model::GetRelationalDatabaseParametersOutcome GetRelationalDatabaseParameters(const Model::GetRelationalDatabaseParametersRequest& request) const; /** * A Callable wrapper for GetRelationalDatabaseParameters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRelationalDatabaseParametersOutcomeCallable GetRelationalDatabaseParametersCallable(const GetRelationalDatabaseParametersRequestT& request) const { return SubmitCallable(&LightsailClient::GetRelationalDatabaseParameters, request); } /** * An Async wrapper for GetRelationalDatabaseParameters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRelationalDatabaseParametersAsync(const GetRelationalDatabaseParametersRequestT& request, const GetRelationalDatabaseParametersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetRelationalDatabaseParameters, request, handler, context); } /** *

Returns information about a specific database snapshot in Amazon * Lightsail.

See Also:

AWS * API Reference

*/ virtual Model::GetRelationalDatabaseSnapshotOutcome GetRelationalDatabaseSnapshot(const Model::GetRelationalDatabaseSnapshotRequest& request) const; /** * A Callable wrapper for GetRelationalDatabaseSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRelationalDatabaseSnapshotOutcomeCallable GetRelationalDatabaseSnapshotCallable(const GetRelationalDatabaseSnapshotRequestT& request) const { return SubmitCallable(&LightsailClient::GetRelationalDatabaseSnapshot, request); } /** * An Async wrapper for GetRelationalDatabaseSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRelationalDatabaseSnapshotAsync(const GetRelationalDatabaseSnapshotRequestT& request, const GetRelationalDatabaseSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetRelationalDatabaseSnapshot, request, handler, context); } /** *

Returns information about all of your database snapshots in Amazon * Lightsail.

See Also:

AWS * API Reference

*/ virtual Model::GetRelationalDatabaseSnapshotsOutcome GetRelationalDatabaseSnapshots(const Model::GetRelationalDatabaseSnapshotsRequest& request) const; /** * A Callable wrapper for GetRelationalDatabaseSnapshots that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRelationalDatabaseSnapshotsOutcomeCallable GetRelationalDatabaseSnapshotsCallable(const GetRelationalDatabaseSnapshotsRequestT& request) const { return SubmitCallable(&LightsailClient::GetRelationalDatabaseSnapshots, request); } /** * An Async wrapper for GetRelationalDatabaseSnapshots that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRelationalDatabaseSnapshotsAsync(const GetRelationalDatabaseSnapshotsRequestT& request, const GetRelationalDatabaseSnapshotsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetRelationalDatabaseSnapshots, request, handler, context); } /** *

Returns information about all of your databases in Amazon * Lightsail.

See Also:

AWS * API Reference

*/ virtual Model::GetRelationalDatabasesOutcome GetRelationalDatabases(const Model::GetRelationalDatabasesRequest& request) const; /** * A Callable wrapper for GetRelationalDatabases that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRelationalDatabasesOutcomeCallable GetRelationalDatabasesCallable(const GetRelationalDatabasesRequestT& request) const { return SubmitCallable(&LightsailClient::GetRelationalDatabases, request); } /** * An Async wrapper for GetRelationalDatabases that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRelationalDatabasesAsync(const GetRelationalDatabasesRequestT& request, const GetRelationalDatabasesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetRelationalDatabases, request, handler, context); } /** *

Returns information about an Amazon Lightsail static IP.

See * Also:

AWS * API Reference

*/ virtual Model::GetStaticIpOutcome GetStaticIp(const Model::GetStaticIpRequest& request) const; /** * A Callable wrapper for GetStaticIp that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetStaticIpOutcomeCallable GetStaticIpCallable(const GetStaticIpRequestT& request) const { return SubmitCallable(&LightsailClient::GetStaticIp, request); } /** * An Async wrapper for GetStaticIp that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetStaticIpAsync(const GetStaticIpRequestT& request, const GetStaticIpResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetStaticIp, request, handler, context); } /** *

Returns information about all static IPs in the user's account.

See * Also:

AWS * API Reference

*/ virtual Model::GetStaticIpsOutcome GetStaticIps(const Model::GetStaticIpsRequest& request) const; /** * A Callable wrapper for GetStaticIps that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetStaticIpsOutcomeCallable GetStaticIpsCallable(const GetStaticIpsRequestT& request) const { return SubmitCallable(&LightsailClient::GetStaticIps, request); } /** * An Async wrapper for GetStaticIps that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetStaticIpsAsync(const GetStaticIpsRequestT& request, const GetStaticIpsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::GetStaticIps, request, handler, context); } /** *

Imports a public SSH key from a specific key pair.

See Also:

* AWS * API Reference

*/ virtual Model::ImportKeyPairOutcome ImportKeyPair(const Model::ImportKeyPairRequest& request) const; /** * A Callable wrapper for ImportKeyPair that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ImportKeyPairOutcomeCallable ImportKeyPairCallable(const ImportKeyPairRequestT& request) const { return SubmitCallable(&LightsailClient::ImportKeyPair, request); } /** * An Async wrapper for ImportKeyPair that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ImportKeyPairAsync(const ImportKeyPairRequestT& request, const ImportKeyPairResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::ImportKeyPair, request, handler, context); } /** *

Returns a Boolean value indicating whether your Lightsail VPC is * peered.

See Also:

AWS * API Reference

*/ virtual Model::IsVpcPeeredOutcome IsVpcPeered(const Model::IsVpcPeeredRequest& request) const; /** * A Callable wrapper for IsVpcPeered that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::IsVpcPeeredOutcomeCallable IsVpcPeeredCallable(const IsVpcPeeredRequestT& request) const { return SubmitCallable(&LightsailClient::IsVpcPeered, request); } /** * An Async wrapper for IsVpcPeered that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void IsVpcPeeredAsync(const IsVpcPeeredRequestT& request, const IsVpcPeeredResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::IsVpcPeered, request, handler, context); } /** *

Opens ports for a specific Amazon Lightsail instance, and specifies the IP * addresses allowed to connect to the instance through the ports, and the * protocol.

The OpenInstancePublicPorts action supports * tag-based access control via resource tags applied to the resource identified by * instanceName. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::OpenInstancePublicPortsOutcome OpenInstancePublicPorts(const Model::OpenInstancePublicPortsRequest& request) const; /** * A Callable wrapper for OpenInstancePublicPorts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::OpenInstancePublicPortsOutcomeCallable OpenInstancePublicPortsCallable(const OpenInstancePublicPortsRequestT& request) const { return SubmitCallable(&LightsailClient::OpenInstancePublicPorts, request); } /** * An Async wrapper for OpenInstancePublicPorts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void OpenInstancePublicPortsAsync(const OpenInstancePublicPortsRequestT& request, const OpenInstancePublicPortsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::OpenInstancePublicPorts, request, handler, context); } /** *

Peers the Lightsail VPC with the user's default VPC.

See Also:

* AWS * API Reference

*/ virtual Model::PeerVpcOutcome PeerVpc(const Model::PeerVpcRequest& request) const; /** * A Callable wrapper for PeerVpc that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PeerVpcOutcomeCallable PeerVpcCallable(const PeerVpcRequestT& request) const { return SubmitCallable(&LightsailClient::PeerVpc, request); } /** * An Async wrapper for PeerVpc that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PeerVpcAsync(const PeerVpcRequestT& request, const PeerVpcResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::PeerVpc, request, handler, context); } /** *

Creates or updates an alarm, and associates it with the specified metric.

*

An alarm is used to monitor a single metric for one of your resources. When a * metric condition is met, the alarm can notify you by email, SMS text message, * and a banner displayed on the Amazon Lightsail console. For more information, * see Alarms * in Amazon Lightsail.

When this action creates an alarm, the alarm * state is immediately set to INSUFFICIENT_DATA. The alarm is then * evaluated and its state is set appropriately. Any actions associated with the * new state are then executed.

When you update an existing alarm, its state * is left unchanged, but the update completely overwrites the previous * configuration of the alarm. The alarm is then evaluated with the updated * configuration.

See Also:

AWS * API Reference

*/ virtual Model::PutAlarmOutcome PutAlarm(const Model::PutAlarmRequest& request) const; /** * A Callable wrapper for PutAlarm that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutAlarmOutcomeCallable PutAlarmCallable(const PutAlarmRequestT& request) const { return SubmitCallable(&LightsailClient::PutAlarm, request); } /** * An Async wrapper for PutAlarm that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutAlarmAsync(const PutAlarmRequestT& request, const PutAlarmResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::PutAlarm, request, handler, context); } /** *

Opens ports for a specific Amazon Lightsail instance, and specifies the IP * addresses allowed to connect to the instance through the ports, and the * protocol. This action also closes all currently open ports that are not included * in the request. Include all of the ports and the protocols you want to open in * your PutInstancePublicPortsrequest. Or use the * OpenInstancePublicPorts action to open ports without closing * currently open ports.

The PutInstancePublicPorts action * supports tag-based access control via resource tags applied to the resource * identified by instanceName. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::PutInstancePublicPortsOutcome PutInstancePublicPorts(const Model::PutInstancePublicPortsRequest& request) const; /** * A Callable wrapper for PutInstancePublicPorts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutInstancePublicPortsOutcomeCallable PutInstancePublicPortsCallable(const PutInstancePublicPortsRequestT& request) const { return SubmitCallable(&LightsailClient::PutInstancePublicPorts, request); } /** * An Async wrapper for PutInstancePublicPorts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutInstancePublicPortsAsync(const PutInstancePublicPortsRequestT& request, const PutInstancePublicPortsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::PutInstancePublicPorts, request, handler, context); } /** *

Restarts a specific instance.

The reboot instance * operation supports tag-based access control via resource tags applied to the * resource identified by instance name. For more information, see the * Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::RebootInstanceOutcome RebootInstance(const Model::RebootInstanceRequest& request) const; /** * A Callable wrapper for RebootInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RebootInstanceOutcomeCallable RebootInstanceCallable(const RebootInstanceRequestT& request) const { return SubmitCallable(&LightsailClient::RebootInstance, request); } /** * An Async wrapper for RebootInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RebootInstanceAsync(const RebootInstanceRequestT& request, const RebootInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::RebootInstance, request, handler, context); } /** *

Restarts a specific database in Amazon Lightsail.

The reboot * relational database operation supports tag-based access control via * resource tags applied to the resource identified by relationalDatabaseName. For * more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::RebootRelationalDatabaseOutcome RebootRelationalDatabase(const Model::RebootRelationalDatabaseRequest& request) const; /** * A Callable wrapper for RebootRelationalDatabase that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RebootRelationalDatabaseOutcomeCallable RebootRelationalDatabaseCallable(const RebootRelationalDatabaseRequestT& request) const { return SubmitCallable(&LightsailClient::RebootRelationalDatabase, request); } /** * An Async wrapper for RebootRelationalDatabase that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RebootRelationalDatabaseAsync(const RebootRelationalDatabaseRequestT& request, const RebootRelationalDatabaseResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::RebootRelationalDatabase, request, handler, context); } /** *

Registers a container image to your Amazon Lightsail container service.

*

This action is not required if you install and use the Lightsail * Control (lightsailctl) plugin to push container images to your Lightsail * container service. For more information, see Pushing * and managing container images on your Amazon Lightsail container services in * the Amazon Lightsail Developer Guide.

See Also:

* AWS * API Reference

*/ virtual Model::RegisterContainerImageOutcome RegisterContainerImage(const Model::RegisterContainerImageRequest& request) const; /** * A Callable wrapper for RegisterContainerImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterContainerImageOutcomeCallable RegisterContainerImageCallable(const RegisterContainerImageRequestT& request) const { return SubmitCallable(&LightsailClient::RegisterContainerImage, request); } /** * An Async wrapper for RegisterContainerImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterContainerImageAsync(const RegisterContainerImageRequestT& request, const RegisterContainerImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::RegisterContainerImage, request, handler, context); } /** *

Deletes a specific static IP from your account.

See Also:

AWS * API Reference

*/ virtual Model::ReleaseStaticIpOutcome ReleaseStaticIp(const Model::ReleaseStaticIpRequest& request) const; /** * A Callable wrapper for ReleaseStaticIp that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ReleaseStaticIpOutcomeCallable ReleaseStaticIpCallable(const ReleaseStaticIpRequestT& request) const { return SubmitCallable(&LightsailClient::ReleaseStaticIp, request); } /** * An Async wrapper for ReleaseStaticIp that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ReleaseStaticIpAsync(const ReleaseStaticIpRequestT& request, const ReleaseStaticIpResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::ReleaseStaticIp, request, handler, context); } /** *

Deletes currently cached content from your Amazon Lightsail content delivery * network (CDN) distribution.

After resetting the cache, the next time a * content request is made, your distribution pulls, serves, and caches it from the * origin.

See Also:

AWS * API Reference

*/ virtual Model::ResetDistributionCacheOutcome ResetDistributionCache(const Model::ResetDistributionCacheRequest& request) const; /** * A Callable wrapper for ResetDistributionCache that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ResetDistributionCacheOutcomeCallable ResetDistributionCacheCallable(const ResetDistributionCacheRequestT& request) const { return SubmitCallable(&LightsailClient::ResetDistributionCache, request); } /** * An Async wrapper for ResetDistributionCache that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ResetDistributionCacheAsync(const ResetDistributionCacheRequestT& request, const ResetDistributionCacheResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::ResetDistributionCache, request, handler, context); } /** *

Sends a verification request to an email contact method to ensure it's owned * by the requester. SMS contact methods don't need to be verified.

A * contact method is used to send you notifications about your Amazon Lightsail * resources. You can add one email address and one mobile phone number contact * method in each Amazon Web Services Region. However, SMS text messaging is not * supported in some Amazon Web Services Regions, and SMS text messages cannot be * sent to some countries/regions. For more information, see Notifications * in Amazon Lightsail.

A verification request is sent to the contact * method when you initially create it. Use this action to send another * verification request if a previous verification request was deleted, or has * expired.

Notifications are not sent to an email contact * method until after it is verified, and confirmed as valid.

*

See Also:

AWS * API Reference

*/ virtual Model::SendContactMethodVerificationOutcome SendContactMethodVerification(const Model::SendContactMethodVerificationRequest& request) const; /** * A Callable wrapper for SendContactMethodVerification that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SendContactMethodVerificationOutcomeCallable SendContactMethodVerificationCallable(const SendContactMethodVerificationRequestT& request) const { return SubmitCallable(&LightsailClient::SendContactMethodVerification, request); } /** * An Async wrapper for SendContactMethodVerification that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SendContactMethodVerificationAsync(const SendContactMethodVerificationRequestT& request, const SendContactMethodVerificationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::SendContactMethodVerification, request, handler, context); } /** *

Sets the IP address type for an Amazon Lightsail resource.

Use this * action to enable dual-stack for a resource, which enables IPv4 and IPv6 for the * specified resource. Alternately, you can use this action to disable dual-stack, * and enable IPv4 only.

See Also:

AWS * API Reference

*/ virtual Model::SetIpAddressTypeOutcome SetIpAddressType(const Model::SetIpAddressTypeRequest& request) const; /** * A Callable wrapper for SetIpAddressType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetIpAddressTypeOutcomeCallable SetIpAddressTypeCallable(const SetIpAddressTypeRequestT& request) const { return SubmitCallable(&LightsailClient::SetIpAddressType, request); } /** * An Async wrapper for SetIpAddressType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetIpAddressTypeAsync(const SetIpAddressTypeRequestT& request, const SetIpAddressTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::SetIpAddressType, request, handler, context); } /** *

Sets the Amazon Lightsail resources that can access the specified Lightsail * bucket.

Lightsail buckets currently support setting access for Lightsail * instances in the same Amazon Web Services Region.

See Also:

AWS * API Reference

*/ virtual Model::SetResourceAccessForBucketOutcome SetResourceAccessForBucket(const Model::SetResourceAccessForBucketRequest& request) const; /** * A Callable wrapper for SetResourceAccessForBucket that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetResourceAccessForBucketOutcomeCallable SetResourceAccessForBucketCallable(const SetResourceAccessForBucketRequestT& request) const { return SubmitCallable(&LightsailClient::SetResourceAccessForBucket, request); } /** * An Async wrapper for SetResourceAccessForBucket that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetResourceAccessForBucketAsync(const SetResourceAccessForBucketRequestT& request, const SetResourceAccessForBucketResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::SetResourceAccessForBucket, request, handler, context); } /** *

Initiates a graphical user interface (GUI) session that’s used to access a * virtual computer’s operating system and application. The session will be active * for 1 hour. Use this action to resume the session after it expires. *

See Also:

AWS * API Reference

*/ virtual Model::StartGUISessionOutcome StartGUISession(const Model::StartGUISessionRequest& request) const; /** * A Callable wrapper for StartGUISession that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartGUISessionOutcomeCallable StartGUISessionCallable(const StartGUISessionRequestT& request) const { return SubmitCallable(&LightsailClient::StartGUISession, request); } /** * An Async wrapper for StartGUISession that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartGUISessionAsync(const StartGUISessionRequestT& request, const StartGUISessionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::StartGUISession, request, handler, context); } /** *

Starts a specific Amazon Lightsail instance from a stopped state. To restart * an instance, use the reboot instance operation.

When * you start a stopped instance, Lightsail assigns a new public IP address to the * instance. To use the same IP address after stopping and starting an instance, * create a static IP address and attach it to the instance. For more information, * see the Amazon * Lightsail Developer Guide.

The start instance * operation supports tag-based access control via resource tags applied to the * resource identified by instance name. For more information, see the * Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::StartInstanceOutcome StartInstance(const Model::StartInstanceRequest& request) const; /** * A Callable wrapper for StartInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartInstanceOutcomeCallable StartInstanceCallable(const StartInstanceRequestT& request) const { return SubmitCallable(&LightsailClient::StartInstance, request); } /** * An Async wrapper for StartInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartInstanceAsync(const StartInstanceRequestT& request, const StartInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::StartInstance, request, handler, context); } /** *

Starts a specific database from a stopped state in Amazon Lightsail. To * restart a database, use the reboot relational database * operation.

The start relational database operation supports * tag-based access control via resource tags applied to the resource identified by * relationalDatabaseName. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::StartRelationalDatabaseOutcome StartRelationalDatabase(const Model::StartRelationalDatabaseRequest& request) const; /** * A Callable wrapper for StartRelationalDatabase that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartRelationalDatabaseOutcomeCallable StartRelationalDatabaseCallable(const StartRelationalDatabaseRequestT& request) const { return SubmitCallable(&LightsailClient::StartRelationalDatabase, request); } /** * An Async wrapper for StartRelationalDatabase that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartRelationalDatabaseAsync(const StartRelationalDatabaseRequestT& request, const StartRelationalDatabaseResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::StartRelationalDatabase, request, handler, context); } /** *

Terminates a web-based NICE DCV session that’s used to access a virtual * computer’s operating system or application. The session will close and any * unsaved data will be lost.

See Also:

AWS * API Reference

*/ virtual Model::StopGUISessionOutcome StopGUISession(const Model::StopGUISessionRequest& request) const; /** * A Callable wrapper for StopGUISession that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopGUISessionOutcomeCallable StopGUISessionCallable(const StopGUISessionRequestT& request) const { return SubmitCallable(&LightsailClient::StopGUISession, request); } /** * An Async wrapper for StopGUISession that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopGUISessionAsync(const StopGUISessionRequestT& request, const StopGUISessionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::StopGUISession, request, handler, context); } /** *

Stops a specific Amazon Lightsail instance that is currently running.

*

When you start a stopped instance, Lightsail assigns a new public IP * address to the instance. To use the same IP address after stopping and starting * an instance, create a static IP address and attach it to the instance. For more * information, see the Amazon * Lightsail Developer Guide.

The stop instance * operation supports tag-based access control via resource tags applied to the * resource identified by instance name. For more information, see the * Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::StopInstanceOutcome StopInstance(const Model::StopInstanceRequest& request) const; /** * A Callable wrapper for StopInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopInstanceOutcomeCallable StopInstanceCallable(const StopInstanceRequestT& request) const { return SubmitCallable(&LightsailClient::StopInstance, request); } /** * An Async wrapper for StopInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopInstanceAsync(const StopInstanceRequestT& request, const StopInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::StopInstance, request, handler, context); } /** *

Stops a specific database that is currently running in Amazon Lightsail.

*

The stop relational database operation supports tag-based access * control via resource tags applied to the resource identified by * relationalDatabaseName. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::StopRelationalDatabaseOutcome StopRelationalDatabase(const Model::StopRelationalDatabaseRequest& request) const; /** * A Callable wrapper for StopRelationalDatabase that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopRelationalDatabaseOutcomeCallable StopRelationalDatabaseCallable(const StopRelationalDatabaseRequestT& request) const { return SubmitCallable(&LightsailClient::StopRelationalDatabase, request); } /** * An Async wrapper for StopRelationalDatabase that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopRelationalDatabaseAsync(const StopRelationalDatabaseRequestT& request, const StopRelationalDatabaseResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::StopRelationalDatabase, request, handler, context); } /** *

Adds one or more tags to the specified Amazon Lightsail resource. Each * resource can have a maximum of 50 tags. Each tag consists of a key and an * optional value. Tag keys must be unique per resource. For more information about * tags, see the Amazon * Lightsail Developer Guide.

The tag resource operation * supports tag-based access control via request tags and resource tags applied to * the resource identified by resource name. For more information, see * the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&LightsailClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::TagResource, request, handler, context); } /** *

Tests an alarm by displaying a banner on the Amazon Lightsail console. If a * notification trigger is configured for the specified alarm, the test also sends * a notification to the notification protocol (Email and/or * SMS) configured for the alarm.

An alarm is used to monitor a * single metric for one of your resources. When a metric condition is met, the * alarm can notify you by email, SMS text message, and a banner displayed on the * Amazon Lightsail console. For more information, see Alarms * in Amazon Lightsail.

See Also:

AWS * API Reference

*/ virtual Model::TestAlarmOutcome TestAlarm(const Model::TestAlarmRequest& request) const; /** * A Callable wrapper for TestAlarm that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TestAlarmOutcomeCallable TestAlarmCallable(const TestAlarmRequestT& request) const { return SubmitCallable(&LightsailClient::TestAlarm, request); } /** * An Async wrapper for TestAlarm that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TestAlarmAsync(const TestAlarmRequestT& request, const TestAlarmResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::TestAlarm, request, handler, context); } /** *

Unpeers the Lightsail VPC from the user's default VPC.

See * Also:

AWS * API Reference

*/ virtual Model::UnpeerVpcOutcome UnpeerVpc(const Model::UnpeerVpcRequest& request) const; /** * A Callable wrapper for UnpeerVpc that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UnpeerVpcOutcomeCallable UnpeerVpcCallable(const UnpeerVpcRequestT& request) const { return SubmitCallable(&LightsailClient::UnpeerVpc, request); } /** * An Async wrapper for UnpeerVpc that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UnpeerVpcAsync(const UnpeerVpcRequestT& request, const UnpeerVpcResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::UnpeerVpc, request, handler, context); } /** *

Deletes the specified set of tag keys and their values from the specified * Amazon Lightsail resource.

The untag resource operation * supports tag-based access control via request tags and resource tags applied to * the resource identified by resource name. For more information, see * the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&LightsailClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::UntagResource, request, handler, context); } /** *

Updates an existing Amazon Lightsail bucket.

Use this action to update * the configuration of an existing bucket, such as versioning, public * accessibility, and the Amazon Web Services accounts that can access the * bucket.

See Also:

AWS * API Reference

*/ virtual Model::UpdateBucketOutcome UpdateBucket(const Model::UpdateBucketRequest& request) const; /** * A Callable wrapper for UpdateBucket that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateBucketOutcomeCallable UpdateBucketCallable(const UpdateBucketRequestT& request) const { return SubmitCallable(&LightsailClient::UpdateBucket, request); } /** * An Async wrapper for UpdateBucket that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateBucketAsync(const UpdateBucketRequestT& request, const UpdateBucketResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::UpdateBucket, request, handler, context); } /** *

Updates the bundle, or storage plan, of an existing Amazon Lightsail * bucket.

A bucket bundle specifies the monthly cost, storage space, and * data transfer quota for a bucket. You can update a bucket's bundle only one time * within a monthly Amazon Web Services billing cycle. To determine if you can * update a bucket's bundle, use the GetBuckets * action. The ableToUpdateBundle parameter in the response will * indicate whether you can currently update a bucket's bundle.

Update a * bucket's bundle if it's consistently going over its storage space or data * transfer quota, or if a bucket's usage is consistently in the lower range of its * storage space or data transfer quota. Due to the unpredictable usage * fluctuations that a bucket might experience, we strongly recommend that you * update a bucket's bundle only as a long-term strategy, instead of as a * short-term, monthly cost-cutting measure. Choose a bucket bundle that will * provide the bucket with ample storage space and data transfer for a long time to * come.

See Also:

AWS * API Reference

*/ virtual Model::UpdateBucketBundleOutcome UpdateBucketBundle(const Model::UpdateBucketBundleRequest& request) const; /** * A Callable wrapper for UpdateBucketBundle that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateBucketBundleOutcomeCallable UpdateBucketBundleCallable(const UpdateBucketBundleRequestT& request) const { return SubmitCallable(&LightsailClient::UpdateBucketBundle, request); } /** * An Async wrapper for UpdateBucketBundle that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateBucketBundleAsync(const UpdateBucketBundleRequestT& request, const UpdateBucketBundleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::UpdateBucketBundle, request, handler, context); } /** *

Updates the configuration of your Amazon Lightsail container service, such as * its power, scale, and public domain names.

See Also:

AWS * API Reference

*/ virtual Model::UpdateContainerServiceOutcome UpdateContainerService(const Model::UpdateContainerServiceRequest& request) const; /** * A Callable wrapper for UpdateContainerService that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateContainerServiceOutcomeCallable UpdateContainerServiceCallable(const UpdateContainerServiceRequestT& request) const { return SubmitCallable(&LightsailClient::UpdateContainerService, request); } /** * An Async wrapper for UpdateContainerService that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateContainerServiceAsync(const UpdateContainerServiceRequestT& request, const UpdateContainerServiceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::UpdateContainerService, request, handler, context); } /** *

Updates an existing Amazon Lightsail content delivery network (CDN) * distribution.

Use this action to update the configuration of your * existing distribution.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDistributionOutcome UpdateDistribution(const Model::UpdateDistributionRequest& request) const; /** * A Callable wrapper for UpdateDistribution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDistributionOutcomeCallable UpdateDistributionCallable(const UpdateDistributionRequestT& request) const { return SubmitCallable(&LightsailClient::UpdateDistribution, request); } /** * An Async wrapper for UpdateDistribution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDistributionAsync(const UpdateDistributionRequestT& request, const UpdateDistributionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::UpdateDistribution, request, handler, context); } /** *

Updates the bundle of your Amazon Lightsail content delivery network (CDN) * distribution.

A distribution bundle specifies the monthly network * transfer quota and monthly cost of your distribution.

Update your * distribution's bundle if your distribution is going over its monthly network * transfer quota and is incurring an overage fee.

You can update your * distribution's bundle only one time within your monthly Amazon Web Services * billing cycle. To determine if you can update your distribution's bundle, use * the GetDistributions action. The ableToUpdateBundle * parameter in the result will indicate whether you can currently update your * distribution's bundle.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDistributionBundleOutcome UpdateDistributionBundle(const Model::UpdateDistributionBundleRequest& request) const; /** * A Callable wrapper for UpdateDistributionBundle that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDistributionBundleOutcomeCallable UpdateDistributionBundleCallable(const UpdateDistributionBundleRequestT& request) const { return SubmitCallable(&LightsailClient::UpdateDistributionBundle, request); } /** * An Async wrapper for UpdateDistributionBundle that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDistributionBundleAsync(const UpdateDistributionBundleRequestT& request, const UpdateDistributionBundleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::UpdateDistributionBundle, request, handler, context); } /** *

Updates a domain recordset after it is created.

The update * domain entry operation supports tag-based access control via resource * tags applied to the resource identified by domain name. For more * information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDomainEntryOutcome UpdateDomainEntry(const Model::UpdateDomainEntryRequest& request) const; /** * A Callable wrapper for UpdateDomainEntry that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDomainEntryOutcomeCallable UpdateDomainEntryCallable(const UpdateDomainEntryRequestT& request) const { return SubmitCallable(&LightsailClient::UpdateDomainEntry, request); } /** * An Async wrapper for UpdateDomainEntry that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDomainEntryAsync(const UpdateDomainEntryRequestT& request, const UpdateDomainEntryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::UpdateDomainEntry, request, handler, context); } /** *

Modifies the Amazon Lightsail instance metadata parameters on a running or * stopped instance. When you modify the parameters on a running instance, the * GetInstance or GetInstances API operation initially * responds with a state of pending. After the parameter modifications * are successfully applied, the state changes to applied in * subsequent GetInstance or GetInstances API calls. For * more information, see Use * IMDSv2 with an Amazon Lightsail instance in the Amazon Lightsail * Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::UpdateInstanceMetadataOptionsOutcome UpdateInstanceMetadataOptions(const Model::UpdateInstanceMetadataOptionsRequest& request) const; /** * A Callable wrapper for UpdateInstanceMetadataOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateInstanceMetadataOptionsOutcomeCallable UpdateInstanceMetadataOptionsCallable(const UpdateInstanceMetadataOptionsRequestT& request) const { return SubmitCallable(&LightsailClient::UpdateInstanceMetadataOptions, request); } /** * An Async wrapper for UpdateInstanceMetadataOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateInstanceMetadataOptionsAsync(const UpdateInstanceMetadataOptionsRequestT& request, const UpdateInstanceMetadataOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::UpdateInstanceMetadataOptions, request, handler, context); } /** *

Updates the specified attribute for a load balancer. You can only update one * attribute at a time.

The update load balancer attribute * operation supports tag-based access control via resource tags applied to the * resource identified by load balancer name. For more information, * see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::UpdateLoadBalancerAttributeOutcome UpdateLoadBalancerAttribute(const Model::UpdateLoadBalancerAttributeRequest& request) const; /** * A Callable wrapper for UpdateLoadBalancerAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateLoadBalancerAttributeOutcomeCallable UpdateLoadBalancerAttributeCallable(const UpdateLoadBalancerAttributeRequestT& request) const { return SubmitCallable(&LightsailClient::UpdateLoadBalancerAttribute, request); } /** * An Async wrapper for UpdateLoadBalancerAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateLoadBalancerAttributeAsync(const UpdateLoadBalancerAttributeRequestT& request, const UpdateLoadBalancerAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::UpdateLoadBalancerAttribute, request, handler, context); } /** *

Allows the update of one or more attributes of a database in Amazon * Lightsail.

Updates are applied immediately, or in cases where the updates * could result in an outage, are applied during the database's predefined * maintenance window.

The update relational database operation * supports tag-based access control via resource tags applied to the resource * identified by relationalDatabaseName. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::UpdateRelationalDatabaseOutcome UpdateRelationalDatabase(const Model::UpdateRelationalDatabaseRequest& request) const; /** * A Callable wrapper for UpdateRelationalDatabase that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateRelationalDatabaseOutcomeCallable UpdateRelationalDatabaseCallable(const UpdateRelationalDatabaseRequestT& request) const { return SubmitCallable(&LightsailClient::UpdateRelationalDatabase, request); } /** * An Async wrapper for UpdateRelationalDatabase that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateRelationalDatabaseAsync(const UpdateRelationalDatabaseRequestT& request, const UpdateRelationalDatabaseResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::UpdateRelationalDatabase, request, handler, context); } /** *

Allows the update of one or more parameters of a database in Amazon * Lightsail.

Parameter updates don't cause outages; therefore, their * application is not subject to the preferred maintenance window. However, there * are two ways in which parameter updates are applied: dynamic or * pending-reboot. Parameters marked with a dynamic apply * type are applied immediately. Parameters marked with a * pending-reboot apply type are applied only after the database is * rebooted using the reboot relational database operation.

The * update relational database parameters operation supports tag-based * access control via resource tags applied to the resource identified by * relationalDatabaseName. For more information, see the Amazon * Lightsail Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::UpdateRelationalDatabaseParametersOutcome UpdateRelationalDatabaseParameters(const Model::UpdateRelationalDatabaseParametersRequest& request) const; /** * A Callable wrapper for UpdateRelationalDatabaseParameters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateRelationalDatabaseParametersOutcomeCallable UpdateRelationalDatabaseParametersCallable(const UpdateRelationalDatabaseParametersRequestT& request) const { return SubmitCallable(&LightsailClient::UpdateRelationalDatabaseParameters, request); } /** * An Async wrapper for UpdateRelationalDatabaseParameters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateRelationalDatabaseParametersAsync(const UpdateRelationalDatabaseParametersRequestT& request, const UpdateRelationalDatabaseParametersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LightsailClient::UpdateRelationalDatabaseParameters, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const LightsailClientConfiguration& clientConfiguration); LightsailClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace Lightsail } // namespace Aws