/* * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. */ /* * Do not modify this file. This file is generated from the lightsail-2016-11-28.normal.json service model. */ using System; using System.Collections.Generic; using System.Net; using Amazon.Lightsail.Model; using Amazon.Lightsail.Model.Internal.MarshallTransformations; using Amazon.Lightsail.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.Lightsail { ///

/// Implementation for accessing 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. /// ///

public partial class AmazonLightsailClient : AmazonServiceClient, IAmazonLightsail { private static IServiceMetadata serviceMetadata = new AmazonLightsailMetadata(); #region Constructors ///

/// Constructs AmazonLightsailClient with the credentials loaded from the application's /// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance. /// /// Example App.config with credentials set. ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

public AmazonLightsailClient() : base(FallbackCredentialsFactory.GetCredentials(), new AmazonLightsailConfig()) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The region to connect. public AmazonLightsailClient(RegionEndpoint region) : base(FallbackCredentialsFactory.GetCredentials(), new AmazonLightsailConfig{RegionEndpoint = region}) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The AmazonLightsailClient Configuration Object public AmazonLightsailClient(AmazonLightsailConfig config) : base(FallbackCredentialsFactory.GetCredentials(config), config){} ///

/// Constructs AmazonLightsailClient with AWS Credentials ///

/// AWS Credentials public AmazonLightsailClient(AWSCredentials credentials) : this(credentials, new AmazonLightsailConfig()) { } ///

/// Constructs AmazonLightsailClient with AWS Credentials ///

/// AWS Credentials /// The region to connect. public AmazonLightsailClient(AWSCredentials credentials, RegionEndpoint region) : this(credentials, new AmazonLightsailConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonLightsailClient with AWS Credentials and an /// AmazonLightsailClient Configuration object. ///

/// AWS Credentials /// The AmazonLightsailClient Configuration Object public AmazonLightsailClient(AWSCredentials credentials, AmazonLightsailConfig clientConfig) : base(credentials, clientConfig) { } ///

/// Constructs AmazonLightsailClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key public AmazonLightsailClient(string awsAccessKeyId, string awsSecretAccessKey) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonLightsailConfig()) { } ///

/// Constructs AmazonLightsailClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// The region to connect. public AmazonLightsailClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonLightsailConfig() {RegionEndpoint=region}) { } ///

/// Constructs AmazonLightsailClient with AWS Access Key ID, AWS Secret Key and an /// AmazonLightsailClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// The AmazonLightsailClient Configuration Object public AmazonLightsailClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonLightsailConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, clientConfig) { } ///

/// Constructs AmazonLightsailClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token public AmazonLightsailClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonLightsailConfig()) { } ///

/// Constructs AmazonLightsailClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The region to connect. public AmazonLightsailClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonLightsailConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonLightsailClient with AWS Access Key ID, AWS Secret Key and an /// AmazonLightsailClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The AmazonLightsailClient Configuration Object public AmazonLightsailClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonLightsailConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig) { } #endregion #region Overrides ///

/// Creates the signer for the service. ///

protected override AbstractAWSSigner CreateSigner() { return new AWS4Signer(); } ///

/// Customize the pipeline ///

/// protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline) { pipeline.RemoveHandler(); pipeline.AddHandlerAfter(new AmazonLightsailEndpointResolver()); } ///

/// Capture metadata for the service. ///

protected override IServiceMetadata ServiceMetadata { get { return serviceMetadata; } } #endregion #region Dispose ///

/// Disposes the service client. ///

protected override void Dispose(bool disposing) { base.Dispose(disposing); } #endregion #region AllocateStaticIp ///

/// Allocates a static IP address. ///

/// Container for the necessary parameters to execute the AllocateStaticIp service method. /// /// The response from the AllocateStaticIp service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for AllocateStaticIp Operation public virtual AllocateStaticIpResponse AllocateStaticIp(AllocateStaticIpRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AllocateStaticIpRequestMarshaller.Instance; options.ResponseUnmarshaller = AllocateStaticIpResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the AllocateStaticIp operation. ///

/// /// Container for the necessary parameters to execute the AllocateStaticIp operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAllocateStaticIp /// operation. /// REST API Reference for AllocateStaticIp Operation public virtual IAsyncResult BeginAllocateStaticIp(AllocateStaticIpRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = AllocateStaticIpRequestMarshaller.Instance; options.ResponseUnmarshaller = AllocateStaticIpResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the AllocateStaticIp operation. ///

/// /// The IAsyncResult returned by the call to BeginAllocateStaticIp. /// /// Returns a AllocateStaticIpResult from Lightsail. /// REST API Reference for AllocateStaticIp Operation public virtual AllocateStaticIpResponse EndAllocateStaticIp(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region AttachCertificateToDistribution ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the AttachCertificateToDistribution service method. /// /// The response from the AttachCertificateToDistribution service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for AttachCertificateToDistribution Operation public virtual AttachCertificateToDistributionResponse AttachCertificateToDistribution(AttachCertificateToDistributionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AttachCertificateToDistributionRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachCertificateToDistributionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the AttachCertificateToDistribution operation. ///

/// /// Container for the necessary parameters to execute the AttachCertificateToDistribution operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAttachCertificateToDistribution /// operation. /// REST API Reference for AttachCertificateToDistribution Operation public virtual IAsyncResult BeginAttachCertificateToDistribution(AttachCertificateToDistributionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = AttachCertificateToDistributionRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachCertificateToDistributionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the AttachCertificateToDistribution operation. ///

/// /// The IAsyncResult returned by the call to BeginAttachCertificateToDistribution. /// /// Returns a AttachCertificateToDistributionResult from Lightsail. /// REST API Reference for AttachCertificateToDistribution Operation public virtual AttachCertificateToDistributionResponse EndAttachCertificateToDistribution(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region AttachDisk ///

/// 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. /// ///

/// Container for the necessary parameters to execute the AttachDisk service method. /// /// The response from the AttachDisk service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for AttachDisk Operation public virtual AttachDiskResponse AttachDisk(AttachDiskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AttachDiskRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachDiskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the AttachDisk operation. ///

/// /// Container for the necessary parameters to execute the AttachDisk operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAttachDisk /// operation. /// REST API Reference for AttachDisk Operation public virtual IAsyncResult BeginAttachDisk(AttachDiskRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = AttachDiskRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachDiskResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the AttachDisk operation. ///

/// /// The IAsyncResult returned by the call to BeginAttachDisk. /// /// Returns a AttachDiskResult from Lightsail. /// REST API Reference for AttachDisk Operation public virtual AttachDiskResponse EndAttachDisk(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region AttachInstancesToLoadBalancer ///

/// 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. /// ///

/// Container for the necessary parameters to execute the AttachInstancesToLoadBalancer service method. /// /// The response from the AttachInstancesToLoadBalancer service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for AttachInstancesToLoadBalancer Operation public virtual AttachInstancesToLoadBalancerResponse AttachInstancesToLoadBalancer(AttachInstancesToLoadBalancerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AttachInstancesToLoadBalancerRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachInstancesToLoadBalancerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the AttachInstancesToLoadBalancer operation. ///

/// /// Container for the necessary parameters to execute the AttachInstancesToLoadBalancer operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAttachInstancesToLoadBalancer /// operation. /// REST API Reference for AttachInstancesToLoadBalancer Operation public virtual IAsyncResult BeginAttachInstancesToLoadBalancer(AttachInstancesToLoadBalancerRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = AttachInstancesToLoadBalancerRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachInstancesToLoadBalancerResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the AttachInstancesToLoadBalancer operation. ///

/// /// The IAsyncResult returned by the call to BeginAttachInstancesToLoadBalancer. /// /// Returns a AttachInstancesToLoadBalancerResult from Lightsail. /// REST API Reference for AttachInstancesToLoadBalancer Operation public virtual AttachInstancesToLoadBalancerResponse EndAttachInstancesToLoadBalancer(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region AttachLoadBalancerTlsCertificate ///

/// 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. /// ///

/// Container for the necessary parameters to execute the AttachLoadBalancerTlsCertificate service method. /// /// The response from the AttachLoadBalancerTlsCertificate service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for AttachLoadBalancerTlsCertificate Operation public virtual AttachLoadBalancerTlsCertificateResponse AttachLoadBalancerTlsCertificate(AttachLoadBalancerTlsCertificateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AttachLoadBalancerTlsCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachLoadBalancerTlsCertificateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the AttachLoadBalancerTlsCertificate operation. ///

/// /// Container for the necessary parameters to execute the AttachLoadBalancerTlsCertificate operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAttachLoadBalancerTlsCertificate /// operation. /// REST API Reference for AttachLoadBalancerTlsCertificate Operation public virtual IAsyncResult BeginAttachLoadBalancerTlsCertificate(AttachLoadBalancerTlsCertificateRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = AttachLoadBalancerTlsCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachLoadBalancerTlsCertificateResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the AttachLoadBalancerTlsCertificate operation. ///

/// /// The IAsyncResult returned by the call to BeginAttachLoadBalancerTlsCertificate. /// /// Returns a AttachLoadBalancerTlsCertificateResult from Lightsail. /// REST API Reference for AttachLoadBalancerTlsCertificate Operation public virtual AttachLoadBalancerTlsCertificateResponse EndAttachLoadBalancerTlsCertificate(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region AttachStaticIp ///

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

/// Container for the necessary parameters to execute the AttachStaticIp service method. /// /// The response from the AttachStaticIp service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for AttachStaticIp Operation public virtual AttachStaticIpResponse AttachStaticIp(AttachStaticIpRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AttachStaticIpRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachStaticIpResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the AttachStaticIp operation. ///

/// /// Container for the necessary parameters to execute the AttachStaticIp operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAttachStaticIp /// operation. /// REST API Reference for AttachStaticIp Operation public virtual IAsyncResult BeginAttachStaticIp(AttachStaticIpRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = AttachStaticIpRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachStaticIpResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the AttachStaticIp operation. ///

/// /// The IAsyncResult returned by the call to BeginAttachStaticIp. /// /// Returns a AttachStaticIpResult from Lightsail. /// REST API Reference for AttachStaticIp Operation public virtual AttachStaticIpResponse EndAttachStaticIp(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CloseInstancePublicPorts ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CloseInstancePublicPorts service method. /// /// The response from the CloseInstancePublicPorts service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CloseInstancePublicPorts Operation public virtual CloseInstancePublicPortsResponse CloseInstancePublicPorts(CloseInstancePublicPortsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CloseInstancePublicPortsRequestMarshaller.Instance; options.ResponseUnmarshaller = CloseInstancePublicPortsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CloseInstancePublicPorts operation. ///

/// /// Container for the necessary parameters to execute the CloseInstancePublicPorts operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCloseInstancePublicPorts /// operation. /// REST API Reference for CloseInstancePublicPorts Operation public virtual IAsyncResult BeginCloseInstancePublicPorts(CloseInstancePublicPortsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CloseInstancePublicPortsRequestMarshaller.Instance; options.ResponseUnmarshaller = CloseInstancePublicPortsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CloseInstancePublicPorts operation. ///

/// /// The IAsyncResult returned by the call to BeginCloseInstancePublicPorts. /// /// Returns a CloseInstancePublicPortsResult from Lightsail. /// REST API Reference for CloseInstancePublicPorts Operation public virtual CloseInstancePublicPortsResponse EndCloseInstancePublicPorts(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CopySnapshot ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CopySnapshot service method. /// /// The response from the CopySnapshot service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CopySnapshot Operation public virtual CopySnapshotResponse CopySnapshot(CopySnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CopySnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CopySnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CopySnapshot operation. ///

/// /// Container for the necessary parameters to execute the CopySnapshot operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCopySnapshot /// operation. /// REST API Reference for CopySnapshot Operation public virtual IAsyncResult BeginCopySnapshot(CopySnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CopySnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CopySnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CopySnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginCopySnapshot. /// /// Returns a CopySnapshotResult from Lightsail. /// REST API Reference for CopySnapshot Operation public virtual CopySnapshotResponse EndCopySnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateBucket ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateBucket service method. /// /// The response from the CreateBucket service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateBucket Operation public virtual CreateBucketResponse CreateBucket(CreateBucketRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateBucketRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateBucketResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateBucket operation. ///

/// /// Container for the necessary parameters to execute the CreateBucket operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateBucket /// operation. /// REST API Reference for CreateBucket Operation public virtual IAsyncResult BeginCreateBucket(CreateBucketRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateBucketRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateBucketResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateBucket operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateBucket. /// /// Returns a CreateBucketResult from Lightsail. /// REST API Reference for CreateBucket Operation public virtual CreateBucketResponse EndCreateBucket(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateBucketAccessKey ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the CreateBucketAccessKey service method. /// /// The response from the CreateBucketAccessKey service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateBucketAccessKey Operation public virtual CreateBucketAccessKeyResponse CreateBucketAccessKey(CreateBucketAccessKeyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateBucketAccessKeyRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateBucketAccessKeyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateBucketAccessKey operation. ///

/// /// Container for the necessary parameters to execute the CreateBucketAccessKey operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateBucketAccessKey /// operation. /// REST API Reference for CreateBucketAccessKey Operation public virtual IAsyncResult BeginCreateBucketAccessKey(CreateBucketAccessKeyRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateBucketAccessKeyRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateBucketAccessKeyResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateBucketAccessKey operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateBucketAccessKey. /// /// Returns a CreateBucketAccessKeyResult from Lightsail. /// REST API Reference for CreateBucketAccessKey Operation public virtual CreateBucketAccessKeyResponse EndCreateBucketAccessKey(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateCertificate ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the CreateCertificate service method. /// /// The response from the CreateCertificate service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateCertificate Operation public virtual CreateCertificateResponse CreateCertificate(CreateCertificateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCertificateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateCertificate operation. ///

/// /// Container for the necessary parameters to execute the CreateCertificate operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateCertificate /// operation. /// REST API Reference for CreateCertificate Operation public virtual IAsyncResult BeginCreateCertificate(CreateCertificateRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCertificateResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateCertificate operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateCertificate. /// /// Returns a CreateCertificateResult from Lightsail. /// REST API Reference for CreateCertificate Operation public virtual CreateCertificateResponse EndCreateCertificate(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateCloudFormationStack ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the CreateCloudFormationStack service method. /// /// The response from the CreateCloudFormationStack service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateCloudFormationStack Operation public virtual CreateCloudFormationStackResponse CreateCloudFormationStack(CreateCloudFormationStackRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCloudFormationStackRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCloudFormationStackResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateCloudFormationStack operation. ///

/// /// Container for the necessary parameters to execute the CreateCloudFormationStack operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateCloudFormationStack /// operation. /// REST API Reference for CreateCloudFormationStack Operation public virtual IAsyncResult BeginCreateCloudFormationStack(CreateCloudFormationStackRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCloudFormationStackRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCloudFormationStackResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateCloudFormationStack operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateCloudFormationStack. /// /// Returns a CreateCloudFormationStackResult from Lightsail. /// REST API Reference for CreateCloudFormationStack Operation public virtual CreateCloudFormationStackResponse EndCreateCloudFormationStack(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateContactMethod ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateContactMethod service method. /// /// The response from the CreateContactMethod service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateContactMethod Operation public virtual CreateContactMethodResponse CreateContactMethod(CreateContactMethodRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateContactMethodRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateContactMethodResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateContactMethod operation. ///

/// /// Container for the necessary parameters to execute the CreateContactMethod operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateContactMethod /// operation. /// REST API Reference for CreateContactMethod Operation public virtual IAsyncResult BeginCreateContactMethod(CreateContactMethodRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateContactMethodRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateContactMethodResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateContactMethod operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateContactMethod. /// /// Returns a CreateContactMethodResult from Lightsail. /// REST API Reference for CreateContactMethod Operation public virtual CreateContactMethodResponse EndCreateContactMethod(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateContainerService ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateContainerService service method. /// /// The response from the CreateContainerService service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateContainerService Operation public virtual CreateContainerServiceResponse CreateContainerService(CreateContainerServiceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateContainerServiceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateContainerServiceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateContainerService operation. ///

/// /// Container for the necessary parameters to execute the CreateContainerService operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateContainerService /// operation. /// REST API Reference for CreateContainerService Operation public virtual IAsyncResult BeginCreateContainerService(CreateContainerServiceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateContainerServiceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateContainerServiceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateContainerService operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateContainerService. /// /// Returns a CreateContainerServiceResult from Lightsail. /// REST API Reference for CreateContainerService Operation public virtual CreateContainerServiceResponse EndCreateContainerService(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateContainerServiceDeployment ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateContainerServiceDeployment service method. /// /// The response from the CreateContainerServiceDeployment service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateContainerServiceDeployment Operation public virtual CreateContainerServiceDeploymentResponse CreateContainerServiceDeployment(CreateContainerServiceDeploymentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateContainerServiceDeploymentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateContainerServiceDeploymentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateContainerServiceDeployment operation. ///

/// /// Container for the necessary parameters to execute the CreateContainerServiceDeployment operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateContainerServiceDeployment /// operation. /// REST API Reference for CreateContainerServiceDeployment Operation public virtual IAsyncResult BeginCreateContainerServiceDeployment(CreateContainerServiceDeploymentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateContainerServiceDeploymentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateContainerServiceDeploymentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateContainerServiceDeployment operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateContainerServiceDeployment. /// /// Returns a CreateContainerServiceDeploymentResult from Lightsail. /// REST API Reference for CreateContainerServiceDeployment Operation public virtual CreateContainerServiceDeploymentResponse EndCreateContainerServiceDeployment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateContainerServiceRegistryLogin ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the CreateContainerServiceRegistryLogin service method. /// /// The response from the CreateContainerServiceRegistryLogin service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateContainerServiceRegistryLogin Operation public virtual CreateContainerServiceRegistryLoginResponse CreateContainerServiceRegistryLogin(CreateContainerServiceRegistryLoginRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateContainerServiceRegistryLoginRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateContainerServiceRegistryLoginResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateContainerServiceRegistryLogin operation. ///

/// /// Container for the necessary parameters to execute the CreateContainerServiceRegistryLogin operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateContainerServiceRegistryLogin /// operation. /// REST API Reference for CreateContainerServiceRegistryLogin Operation public virtual IAsyncResult BeginCreateContainerServiceRegistryLogin(CreateContainerServiceRegistryLoginRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateContainerServiceRegistryLoginRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateContainerServiceRegistryLoginResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateContainerServiceRegistryLogin operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateContainerServiceRegistryLogin. /// /// Returns a CreateContainerServiceRegistryLoginResult from Lightsail. /// REST API Reference for CreateContainerServiceRegistryLogin Operation public virtual CreateContainerServiceRegistryLoginResponse EndCreateContainerServiceRegistryLogin(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateDisk ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateDisk service method. /// /// The response from the CreateDisk service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateDisk Operation public virtual CreateDiskResponse CreateDisk(CreateDiskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDiskRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDiskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateDisk operation. ///

/// /// Container for the necessary parameters to execute the CreateDisk operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateDisk /// operation. /// REST API Reference for CreateDisk Operation public virtual IAsyncResult BeginCreateDisk(CreateDiskRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDiskRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDiskResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateDisk operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateDisk. /// /// Returns a CreateDiskResult from Lightsail. /// REST API Reference for CreateDisk Operation public virtual CreateDiskResponse EndCreateDisk(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateDiskFromSnapshot ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateDiskFromSnapshot service method. /// /// The response from the CreateDiskFromSnapshot service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateDiskFromSnapshot Operation public virtual CreateDiskFromSnapshotResponse CreateDiskFromSnapshot(CreateDiskFromSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDiskFromSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDiskFromSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateDiskFromSnapshot operation. ///

/// /// Container for the necessary parameters to execute the CreateDiskFromSnapshot operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateDiskFromSnapshot /// operation. /// REST API Reference for CreateDiskFromSnapshot Operation public virtual IAsyncResult BeginCreateDiskFromSnapshot(CreateDiskFromSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDiskFromSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDiskFromSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateDiskFromSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateDiskFromSnapshot. /// /// Returns a CreateDiskFromSnapshotResult from Lightsail. /// REST API Reference for CreateDiskFromSnapshot Operation public virtual CreateDiskFromSnapshotResponse EndCreateDiskFromSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateDiskSnapshot ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateDiskSnapshot service method. /// /// The response from the CreateDiskSnapshot service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateDiskSnapshot Operation public virtual CreateDiskSnapshotResponse CreateDiskSnapshot(CreateDiskSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDiskSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDiskSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateDiskSnapshot operation. ///

/// /// Container for the necessary parameters to execute the CreateDiskSnapshot operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateDiskSnapshot /// operation. /// REST API Reference for CreateDiskSnapshot Operation public virtual IAsyncResult BeginCreateDiskSnapshot(CreateDiskSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDiskSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDiskSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateDiskSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateDiskSnapshot. /// /// Returns a CreateDiskSnapshotResult from Lightsail. /// REST API Reference for CreateDiskSnapshot Operation public virtual CreateDiskSnapshotResponse EndCreateDiskSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateDistribution ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateDistribution service method. /// /// The response from the CreateDistribution service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateDistribution Operation public virtual CreateDistributionResponse CreateDistribution(CreateDistributionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDistributionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDistributionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateDistribution operation. ///

/// /// Container for the necessary parameters to execute the CreateDistribution operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateDistribution /// operation. /// REST API Reference for CreateDistribution Operation public virtual IAsyncResult BeginCreateDistribution(CreateDistributionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDistributionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDistributionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateDistribution operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateDistribution. /// /// Returns a CreateDistributionResult from Lightsail. /// REST API Reference for CreateDistribution Operation public virtual CreateDistributionResponse EndCreateDistribution(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateDomain ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateDomain service method. /// /// The response from the CreateDomain service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateDomain Operation public virtual CreateDomainResponse CreateDomain(CreateDomainRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDomainRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDomainResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateDomain operation. ///

/// /// Container for the necessary parameters to execute the CreateDomain operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateDomain /// operation. /// REST API Reference for CreateDomain Operation public virtual IAsyncResult BeginCreateDomain(CreateDomainRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDomainRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDomainResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateDomain operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateDomain. /// /// Returns a CreateDomainResult from Lightsail. /// REST API Reference for CreateDomain Operation public virtual CreateDomainResponse EndCreateDomain(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateDomainEntry ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateDomainEntry service method. /// /// The response from the CreateDomainEntry service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateDomainEntry Operation public virtual CreateDomainEntryResponse CreateDomainEntry(CreateDomainEntryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDomainEntryRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDomainEntryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateDomainEntry operation. ///

/// /// Container for the necessary parameters to execute the CreateDomainEntry operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateDomainEntry /// operation. /// REST API Reference for CreateDomainEntry Operation public virtual IAsyncResult BeginCreateDomainEntry(CreateDomainEntryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDomainEntryRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDomainEntryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateDomainEntry operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateDomainEntry. /// /// Returns a CreateDomainEntryResult from Lightsail. /// REST API Reference for CreateDomainEntry Operation public virtual CreateDomainEntryResponse EndCreateDomainEntry(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateGUISessionAccessDetails ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateGUISessionAccessDetails service method. /// /// The response from the CreateGUISessionAccessDetails service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateGUISessionAccessDetails Operation public virtual CreateGUISessionAccessDetailsResponse CreateGUISessionAccessDetails(CreateGUISessionAccessDetailsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateGUISessionAccessDetailsRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateGUISessionAccessDetailsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateGUISessionAccessDetails operation. ///

/// /// Container for the necessary parameters to execute the CreateGUISessionAccessDetails operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateGUISessionAccessDetails /// operation. /// REST API Reference for CreateGUISessionAccessDetails Operation public virtual IAsyncResult BeginCreateGUISessionAccessDetails(CreateGUISessionAccessDetailsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateGUISessionAccessDetailsRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateGUISessionAccessDetailsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateGUISessionAccessDetails operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateGUISessionAccessDetails. /// /// Returns a CreateGUISessionAccessDetailsResult from Lightsail. /// REST API Reference for CreateGUISessionAccessDetails Operation public virtual CreateGUISessionAccessDetailsResponse EndCreateGUISessionAccessDetails(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateInstances ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateInstances service method. /// /// The response from the CreateInstances service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateInstances Operation public virtual CreateInstancesResponse CreateInstances(CreateInstancesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateInstancesRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateInstancesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateInstances operation. ///

/// /// Container for the necessary parameters to execute the CreateInstances operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateInstances /// operation. /// REST API Reference for CreateInstances Operation public virtual IAsyncResult BeginCreateInstances(CreateInstancesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateInstancesRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateInstancesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateInstances operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateInstances. /// /// Returns a CreateInstancesResult from Lightsail. /// REST API Reference for CreateInstances Operation public virtual CreateInstancesResponse EndCreateInstances(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateInstancesFromSnapshot ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateInstancesFromSnapshot service method. /// /// The response from the CreateInstancesFromSnapshot service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateInstancesFromSnapshot Operation public virtual CreateInstancesFromSnapshotResponse CreateInstancesFromSnapshot(CreateInstancesFromSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateInstancesFromSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateInstancesFromSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateInstancesFromSnapshot operation. ///

/// /// Container for the necessary parameters to execute the CreateInstancesFromSnapshot operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateInstancesFromSnapshot /// operation. /// REST API Reference for CreateInstancesFromSnapshot Operation public virtual IAsyncResult BeginCreateInstancesFromSnapshot(CreateInstancesFromSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateInstancesFromSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateInstancesFromSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateInstancesFromSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateInstancesFromSnapshot. /// /// Returns a CreateInstancesFromSnapshotResult from Lightsail. /// REST API Reference for CreateInstancesFromSnapshot Operation public virtual CreateInstancesFromSnapshotResponse EndCreateInstancesFromSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateInstanceSnapshot ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateInstanceSnapshot service method. /// /// The response from the CreateInstanceSnapshot service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateInstanceSnapshot Operation public virtual CreateInstanceSnapshotResponse CreateInstanceSnapshot(CreateInstanceSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateInstanceSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateInstanceSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateInstanceSnapshot operation. ///

/// /// Container for the necessary parameters to execute the CreateInstanceSnapshot operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateInstanceSnapshot /// operation. /// REST API Reference for CreateInstanceSnapshot Operation public virtual IAsyncResult BeginCreateInstanceSnapshot(CreateInstanceSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateInstanceSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateInstanceSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateInstanceSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateInstanceSnapshot. /// /// Returns a CreateInstanceSnapshotResult from Lightsail. /// REST API Reference for CreateInstanceSnapshot Operation public virtual CreateInstanceSnapshotResponse EndCreateInstanceSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateKeyPair ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateKeyPair service method. /// /// The response from the CreateKeyPair service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateKeyPair Operation public virtual CreateKeyPairResponse CreateKeyPair(CreateKeyPairRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateKeyPairRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateKeyPairResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateKeyPair operation. ///

/// /// Container for the necessary parameters to execute the CreateKeyPair operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateKeyPair /// operation. /// REST API Reference for CreateKeyPair Operation public virtual IAsyncResult BeginCreateKeyPair(CreateKeyPairRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateKeyPairRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateKeyPairResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateKeyPair operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateKeyPair. /// /// Returns a CreateKeyPairResult from Lightsail. /// REST API Reference for CreateKeyPair Operation public virtual CreateKeyPairResponse EndCreateKeyPair(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateLoadBalancer ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateLoadBalancer service method. /// /// The response from the CreateLoadBalancer service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateLoadBalancer Operation public virtual CreateLoadBalancerResponse CreateLoadBalancer(CreateLoadBalancerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLoadBalancerRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLoadBalancerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateLoadBalancer operation. ///

/// /// Container for the necessary parameters to execute the CreateLoadBalancer operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateLoadBalancer /// operation. /// REST API Reference for CreateLoadBalancer Operation public virtual IAsyncResult BeginCreateLoadBalancer(CreateLoadBalancerRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLoadBalancerRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLoadBalancerResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateLoadBalancer operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateLoadBalancer. /// /// Returns a CreateLoadBalancerResult from Lightsail. /// REST API Reference for CreateLoadBalancer Operation public virtual CreateLoadBalancerResponse EndCreateLoadBalancer(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateLoadBalancerTlsCertificate ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateLoadBalancerTlsCertificate service method. /// /// The response from the CreateLoadBalancerTlsCertificate service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateLoadBalancerTlsCertificate Operation public virtual CreateLoadBalancerTlsCertificateResponse CreateLoadBalancerTlsCertificate(CreateLoadBalancerTlsCertificateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLoadBalancerTlsCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLoadBalancerTlsCertificateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateLoadBalancerTlsCertificate operation. ///

/// /// Container for the necessary parameters to execute the CreateLoadBalancerTlsCertificate operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateLoadBalancerTlsCertificate /// operation. /// REST API Reference for CreateLoadBalancerTlsCertificate Operation public virtual IAsyncResult BeginCreateLoadBalancerTlsCertificate(CreateLoadBalancerTlsCertificateRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLoadBalancerTlsCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLoadBalancerTlsCertificateResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateLoadBalancerTlsCertificate operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateLoadBalancerTlsCertificate. /// /// Returns a CreateLoadBalancerTlsCertificateResult from Lightsail. /// REST API Reference for CreateLoadBalancerTlsCertificate Operation public virtual CreateLoadBalancerTlsCertificateResponse EndCreateLoadBalancerTlsCertificate(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateRelationalDatabase ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateRelationalDatabase service method. /// /// The response from the CreateRelationalDatabase service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateRelationalDatabase Operation public virtual CreateRelationalDatabaseResponse CreateRelationalDatabase(CreateRelationalDatabaseRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateRelationalDatabaseRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateRelationalDatabaseResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateRelationalDatabase operation. ///

/// /// Container for the necessary parameters to execute the CreateRelationalDatabase operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateRelationalDatabase /// operation. /// REST API Reference for CreateRelationalDatabase Operation public virtual IAsyncResult BeginCreateRelationalDatabase(CreateRelationalDatabaseRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateRelationalDatabaseRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateRelationalDatabaseResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateRelationalDatabase operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateRelationalDatabase. /// /// Returns a CreateRelationalDatabaseResult from Lightsail. /// REST API Reference for CreateRelationalDatabase Operation public virtual CreateRelationalDatabaseResponse EndCreateRelationalDatabase(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateRelationalDatabaseFromSnapshot ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateRelationalDatabaseFromSnapshot service method. /// /// The response from the CreateRelationalDatabaseFromSnapshot service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateRelationalDatabaseFromSnapshot Operation public virtual CreateRelationalDatabaseFromSnapshotResponse CreateRelationalDatabaseFromSnapshot(CreateRelationalDatabaseFromSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateRelationalDatabaseFromSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateRelationalDatabaseFromSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateRelationalDatabaseFromSnapshot operation. ///

/// /// Container for the necessary parameters to execute the CreateRelationalDatabaseFromSnapshot operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateRelationalDatabaseFromSnapshot /// operation. /// REST API Reference for CreateRelationalDatabaseFromSnapshot Operation public virtual IAsyncResult BeginCreateRelationalDatabaseFromSnapshot(CreateRelationalDatabaseFromSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateRelationalDatabaseFromSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateRelationalDatabaseFromSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateRelationalDatabaseFromSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateRelationalDatabaseFromSnapshot. /// /// Returns a CreateRelationalDatabaseFromSnapshotResult from Lightsail. /// REST API Reference for CreateRelationalDatabaseFromSnapshot Operation public virtual CreateRelationalDatabaseFromSnapshotResponse EndCreateRelationalDatabaseFromSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateRelationalDatabaseSnapshot ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateRelationalDatabaseSnapshot service method. /// /// The response from the CreateRelationalDatabaseSnapshot service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for CreateRelationalDatabaseSnapshot Operation public virtual CreateRelationalDatabaseSnapshotResponse CreateRelationalDatabaseSnapshot(CreateRelationalDatabaseSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateRelationalDatabaseSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateRelationalDatabaseSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateRelationalDatabaseSnapshot operation. ///

/// /// Container for the necessary parameters to execute the CreateRelationalDatabaseSnapshot operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateRelationalDatabaseSnapshot /// operation. /// REST API Reference for CreateRelationalDatabaseSnapshot Operation public virtual IAsyncResult BeginCreateRelationalDatabaseSnapshot(CreateRelationalDatabaseSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateRelationalDatabaseSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateRelationalDatabaseSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateRelationalDatabaseSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateRelationalDatabaseSnapshot. /// /// Returns a CreateRelationalDatabaseSnapshotResult from Lightsail. /// REST API Reference for CreateRelationalDatabaseSnapshot Operation public virtual CreateRelationalDatabaseSnapshotResponse EndCreateRelationalDatabaseSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteAlarm ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteAlarm service method. /// /// The response from the DeleteAlarm service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteAlarm Operation public virtual DeleteAlarmResponse DeleteAlarm(DeleteAlarmRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAlarmRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAlarmResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteAlarm operation. ///

/// /// Container for the necessary parameters to execute the DeleteAlarm operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteAlarm /// operation. /// REST API Reference for DeleteAlarm Operation public virtual IAsyncResult BeginDeleteAlarm(DeleteAlarmRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAlarmRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAlarmResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteAlarm operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteAlarm. /// /// Returns a DeleteAlarmResult from Lightsail. /// REST API Reference for DeleteAlarm Operation public virtual DeleteAlarmResponse EndDeleteAlarm(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteAutoSnapshot ///

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

/// Container for the necessary parameters to execute the DeleteAutoSnapshot service method. /// /// The response from the DeleteAutoSnapshot service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteAutoSnapshot Operation public virtual DeleteAutoSnapshotResponse DeleteAutoSnapshot(DeleteAutoSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAutoSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAutoSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteAutoSnapshot operation. ///

/// /// Container for the necessary parameters to execute the DeleteAutoSnapshot operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteAutoSnapshot /// operation. /// REST API Reference for DeleteAutoSnapshot Operation public virtual IAsyncResult BeginDeleteAutoSnapshot(DeleteAutoSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAutoSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAutoSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteAutoSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteAutoSnapshot. /// /// Returns a DeleteAutoSnapshotResult from Lightsail. /// REST API Reference for DeleteAutoSnapshot Operation public virtual DeleteAutoSnapshotResponse EndDeleteAutoSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteBucket ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the DeleteBucket service method. /// /// The response from the DeleteBucket service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteBucket Operation public virtual DeleteBucketResponse DeleteBucket(DeleteBucketRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteBucketRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteBucketResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteBucket operation. ///

/// /// Container for the necessary parameters to execute the DeleteBucket operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteBucket /// operation. /// REST API Reference for DeleteBucket Operation public virtual IAsyncResult BeginDeleteBucket(DeleteBucketRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteBucketRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteBucketResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteBucket operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteBucket. /// /// Returns a DeleteBucketResult from Lightsail. /// REST API Reference for DeleteBucket Operation public virtual DeleteBucketResponse EndDeleteBucket(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteBucketAccessKey ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteBucketAccessKey service method. /// /// The response from the DeleteBucketAccessKey service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteBucketAccessKey Operation public virtual DeleteBucketAccessKeyResponse DeleteBucketAccessKey(DeleteBucketAccessKeyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteBucketAccessKeyRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteBucketAccessKeyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteBucketAccessKey operation. ///

/// /// Container for the necessary parameters to execute the DeleteBucketAccessKey operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteBucketAccessKey /// operation. /// REST API Reference for DeleteBucketAccessKey Operation public virtual IAsyncResult BeginDeleteBucketAccessKey(DeleteBucketAccessKeyRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteBucketAccessKeyRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteBucketAccessKeyResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteBucketAccessKey operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteBucketAccessKey. /// /// Returns a DeleteBucketAccessKeyResult from Lightsail. /// REST API Reference for DeleteBucketAccessKey Operation public virtual DeleteBucketAccessKeyResponse EndDeleteBucketAccessKey(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteCertificate ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteCertificate service method. /// /// The response from the DeleteCertificate service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteCertificate Operation public virtual DeleteCertificateResponse DeleteCertificate(DeleteCertificateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteCertificateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteCertificate operation. ///

/// /// Container for the necessary parameters to execute the DeleteCertificate operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteCertificate /// operation. /// REST API Reference for DeleteCertificate Operation public virtual IAsyncResult BeginDeleteCertificate(DeleteCertificateRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteCertificateResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteCertificate operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteCertificate. /// /// Returns a DeleteCertificateResult from Lightsail. /// REST API Reference for DeleteCertificate Operation public virtual DeleteCertificateResponse EndDeleteCertificate(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteContactMethod ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteContactMethod service method. /// /// The response from the DeleteContactMethod service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteContactMethod Operation public virtual DeleteContactMethodResponse DeleteContactMethod(DeleteContactMethodRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteContactMethodRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteContactMethodResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteContactMethod operation. ///

/// /// Container for the necessary parameters to execute the DeleteContactMethod operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteContactMethod /// operation. /// REST API Reference for DeleteContactMethod Operation public virtual IAsyncResult BeginDeleteContactMethod(DeleteContactMethodRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteContactMethodRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteContactMethodResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteContactMethod operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteContactMethod. /// /// Returns a DeleteContactMethodResult from Lightsail. /// REST API Reference for DeleteContactMethod Operation public virtual DeleteContactMethodResponse EndDeleteContactMethod(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteContainerImage ///

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

/// Container for the necessary parameters to execute the DeleteContainerImage service method. /// /// The response from the DeleteContainerImage service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteContainerImage Operation public virtual DeleteContainerImageResponse DeleteContainerImage(DeleteContainerImageRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteContainerImageRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteContainerImageResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteContainerImage operation. ///

/// /// Container for the necessary parameters to execute the DeleteContainerImage operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteContainerImage /// operation. /// REST API Reference for DeleteContainerImage Operation public virtual IAsyncResult BeginDeleteContainerImage(DeleteContainerImageRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteContainerImageRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteContainerImageResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteContainerImage operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteContainerImage. /// /// Returns a DeleteContainerImageResult from Lightsail. /// REST API Reference for DeleteContainerImage Operation public virtual DeleteContainerImageResponse EndDeleteContainerImage(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteContainerService ///

/// Deletes your Amazon Lightsail container service. ///

/// Container for the necessary parameters to execute the DeleteContainerService service method. /// /// The response from the DeleteContainerService service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteContainerService Operation public virtual DeleteContainerServiceResponse DeleteContainerService(DeleteContainerServiceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteContainerServiceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteContainerServiceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteContainerService operation. ///

/// /// Container for the necessary parameters to execute the DeleteContainerService operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteContainerService /// operation. /// REST API Reference for DeleteContainerService Operation public virtual IAsyncResult BeginDeleteContainerService(DeleteContainerServiceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteContainerServiceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteContainerServiceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteContainerService operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteContainerService. /// /// Returns a DeleteContainerServiceResult from Lightsail. /// REST API Reference for DeleteContainerService Operation public virtual DeleteContainerServiceResponse EndDeleteContainerService(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteDisk ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteDisk service method. /// /// The response from the DeleteDisk service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteDisk Operation public virtual DeleteDiskResponse DeleteDisk(DeleteDiskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDiskRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDiskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteDisk operation. ///

/// /// Container for the necessary parameters to execute the DeleteDisk operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteDisk /// operation. /// REST API Reference for DeleteDisk Operation public virtual IAsyncResult BeginDeleteDisk(DeleteDiskRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDiskRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDiskResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteDisk operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteDisk. /// /// Returns a DeleteDiskResult from Lightsail. /// REST API Reference for DeleteDisk Operation public virtual DeleteDiskResponse EndDeleteDisk(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteDiskSnapshot ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteDiskSnapshot service method. /// /// The response from the DeleteDiskSnapshot service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteDiskSnapshot Operation public virtual DeleteDiskSnapshotResponse DeleteDiskSnapshot(DeleteDiskSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDiskSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDiskSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteDiskSnapshot operation. ///

/// /// Container for the necessary parameters to execute the DeleteDiskSnapshot operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteDiskSnapshot /// operation. /// REST API Reference for DeleteDiskSnapshot Operation public virtual IAsyncResult BeginDeleteDiskSnapshot(DeleteDiskSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDiskSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDiskSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteDiskSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteDiskSnapshot. /// /// Returns a DeleteDiskSnapshotResult from Lightsail. /// REST API Reference for DeleteDiskSnapshot Operation public virtual DeleteDiskSnapshotResponse EndDeleteDiskSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteDistribution ///

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

/// Container for the necessary parameters to execute the DeleteDistribution service method. /// /// The response from the DeleteDistribution service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteDistribution Operation public virtual DeleteDistributionResponse DeleteDistribution(DeleteDistributionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDistributionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDistributionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteDistribution operation. ///

/// /// Container for the necessary parameters to execute the DeleteDistribution operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteDistribution /// operation. /// REST API Reference for DeleteDistribution Operation public virtual IAsyncResult BeginDeleteDistribution(DeleteDistributionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDistributionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDistributionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteDistribution operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteDistribution. /// /// Returns a DeleteDistributionResult from Lightsail. /// REST API Reference for DeleteDistribution Operation public virtual DeleteDistributionResponse EndDeleteDistribution(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteDomain ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteDomain service method. /// /// The response from the DeleteDomain service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteDomain Operation public virtual DeleteDomainResponse DeleteDomain(DeleteDomainRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDomainRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDomainResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteDomain operation. ///

/// /// Container for the necessary parameters to execute the DeleteDomain operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteDomain /// operation. /// REST API Reference for DeleteDomain Operation public virtual IAsyncResult BeginDeleteDomain(DeleteDomainRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDomainRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDomainResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteDomain operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteDomain. /// /// Returns a DeleteDomainResult from Lightsail. /// REST API Reference for DeleteDomain Operation public virtual DeleteDomainResponse EndDeleteDomain(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteDomainEntry ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteDomainEntry service method. /// /// The response from the DeleteDomainEntry service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteDomainEntry Operation public virtual DeleteDomainEntryResponse DeleteDomainEntry(DeleteDomainEntryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDomainEntryRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDomainEntryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteDomainEntry operation. ///

/// /// Container for the necessary parameters to execute the DeleteDomainEntry operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteDomainEntry /// operation. /// REST API Reference for DeleteDomainEntry Operation public virtual IAsyncResult BeginDeleteDomainEntry(DeleteDomainEntryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDomainEntryRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDomainEntryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteDomainEntry operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteDomainEntry. /// /// Returns a DeleteDomainEntryResult from Lightsail. /// REST API Reference for DeleteDomainEntry Operation public virtual DeleteDomainEntryResponse EndDeleteDomainEntry(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteInstance ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteInstance service method. /// /// The response from the DeleteInstance service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteInstance Operation public virtual DeleteInstanceResponse DeleteInstance(DeleteInstanceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteInstanceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteInstance operation. ///

/// /// Container for the necessary parameters to execute the DeleteInstance operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteInstance /// operation. /// REST API Reference for DeleteInstance Operation public virtual IAsyncResult BeginDeleteInstance(DeleteInstanceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteInstanceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteInstance operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteInstance. /// /// Returns a DeleteInstanceResult from Lightsail. /// REST API Reference for DeleteInstance Operation public virtual DeleteInstanceResponse EndDeleteInstance(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteInstanceSnapshot ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteInstanceSnapshot service method. /// /// The response from the DeleteInstanceSnapshot service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteInstanceSnapshot Operation public virtual DeleteInstanceSnapshotResponse DeleteInstanceSnapshot(DeleteInstanceSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteInstanceSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteInstanceSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteInstanceSnapshot operation. ///

/// /// Container for the necessary parameters to execute the DeleteInstanceSnapshot operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteInstanceSnapshot /// operation. /// REST API Reference for DeleteInstanceSnapshot Operation public virtual IAsyncResult BeginDeleteInstanceSnapshot(DeleteInstanceSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteInstanceSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteInstanceSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteInstanceSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteInstanceSnapshot. /// /// Returns a DeleteInstanceSnapshotResult from Lightsail. /// REST API Reference for DeleteInstanceSnapshot Operation public virtual DeleteInstanceSnapshotResponse EndDeleteInstanceSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteKeyPair ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteKeyPair service method. /// /// The response from the DeleteKeyPair service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteKeyPair Operation public virtual DeleteKeyPairResponse DeleteKeyPair(DeleteKeyPairRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteKeyPairRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteKeyPairResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteKeyPair operation. ///

/// /// Container for the necessary parameters to execute the DeleteKeyPair operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteKeyPair /// operation. /// REST API Reference for DeleteKeyPair Operation public virtual IAsyncResult BeginDeleteKeyPair(DeleteKeyPairRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteKeyPairRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteKeyPairResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteKeyPair operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteKeyPair. /// /// Returns a DeleteKeyPairResult from Lightsail. /// REST API Reference for DeleteKeyPair Operation public virtual DeleteKeyPairResponse EndDeleteKeyPair(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteKnownHostKeys ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the DeleteKnownHostKeys service method. /// /// The response from the DeleteKnownHostKeys service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteKnownHostKeys Operation public virtual DeleteKnownHostKeysResponse DeleteKnownHostKeys(DeleteKnownHostKeysRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteKnownHostKeysRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteKnownHostKeysResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteKnownHostKeys operation. ///

/// /// Container for the necessary parameters to execute the DeleteKnownHostKeys operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteKnownHostKeys /// operation. /// REST API Reference for DeleteKnownHostKeys Operation public virtual IAsyncResult BeginDeleteKnownHostKeys(DeleteKnownHostKeysRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteKnownHostKeysRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteKnownHostKeysResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteKnownHostKeys operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteKnownHostKeys. /// /// Returns a DeleteKnownHostKeysResult from Lightsail. /// REST API Reference for DeleteKnownHostKeys Operation public virtual DeleteKnownHostKeysResponse EndDeleteKnownHostKeys(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteLoadBalancer ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteLoadBalancer service method. /// /// The response from the DeleteLoadBalancer service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteLoadBalancer Operation public virtual DeleteLoadBalancerResponse DeleteLoadBalancer(DeleteLoadBalancerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLoadBalancerRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLoadBalancerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteLoadBalancer operation. ///

/// /// Container for the necessary parameters to execute the DeleteLoadBalancer operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteLoadBalancer /// operation. /// REST API Reference for DeleteLoadBalancer Operation public virtual IAsyncResult BeginDeleteLoadBalancer(DeleteLoadBalancerRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLoadBalancerRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLoadBalancerResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteLoadBalancer operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteLoadBalancer. /// /// Returns a DeleteLoadBalancerResult from Lightsail. /// REST API Reference for DeleteLoadBalancer Operation public virtual DeleteLoadBalancerResponse EndDeleteLoadBalancer(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteLoadBalancerTlsCertificate ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteLoadBalancerTlsCertificate service method. /// /// The response from the DeleteLoadBalancerTlsCertificate service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteLoadBalancerTlsCertificate Operation public virtual DeleteLoadBalancerTlsCertificateResponse DeleteLoadBalancerTlsCertificate(DeleteLoadBalancerTlsCertificateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLoadBalancerTlsCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLoadBalancerTlsCertificateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteLoadBalancerTlsCertificate operation. ///

/// /// Container for the necessary parameters to execute the DeleteLoadBalancerTlsCertificate operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteLoadBalancerTlsCertificate /// operation. /// REST API Reference for DeleteLoadBalancerTlsCertificate Operation public virtual IAsyncResult BeginDeleteLoadBalancerTlsCertificate(DeleteLoadBalancerTlsCertificateRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLoadBalancerTlsCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLoadBalancerTlsCertificateResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteLoadBalancerTlsCertificate operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteLoadBalancerTlsCertificate. /// /// Returns a DeleteLoadBalancerTlsCertificateResult from Lightsail. /// REST API Reference for DeleteLoadBalancerTlsCertificate Operation public virtual DeleteLoadBalancerTlsCertificateResponse EndDeleteLoadBalancerTlsCertificate(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteRelationalDatabase ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteRelationalDatabase service method. /// /// The response from the DeleteRelationalDatabase service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteRelationalDatabase Operation public virtual DeleteRelationalDatabaseResponse DeleteRelationalDatabase(DeleteRelationalDatabaseRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteRelationalDatabaseRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteRelationalDatabaseResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteRelationalDatabase operation. ///

/// /// Container for the necessary parameters to execute the DeleteRelationalDatabase operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteRelationalDatabase /// operation. /// REST API Reference for DeleteRelationalDatabase Operation public virtual IAsyncResult BeginDeleteRelationalDatabase(DeleteRelationalDatabaseRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteRelationalDatabaseRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteRelationalDatabaseResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteRelationalDatabase operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteRelationalDatabase. /// /// Returns a DeleteRelationalDatabaseResult from Lightsail. /// REST API Reference for DeleteRelationalDatabase Operation public virtual DeleteRelationalDatabaseResponse EndDeleteRelationalDatabase(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteRelationalDatabaseSnapshot ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteRelationalDatabaseSnapshot service method. /// /// The response from the DeleteRelationalDatabaseSnapshot service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DeleteRelationalDatabaseSnapshot Operation public virtual DeleteRelationalDatabaseSnapshotResponse DeleteRelationalDatabaseSnapshot(DeleteRelationalDatabaseSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteRelationalDatabaseSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteRelationalDatabaseSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteRelationalDatabaseSnapshot operation. ///

/// /// Container for the necessary parameters to execute the DeleteRelationalDatabaseSnapshot operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteRelationalDatabaseSnapshot /// operation. /// REST API Reference for DeleteRelationalDatabaseSnapshot Operation public virtual IAsyncResult BeginDeleteRelationalDatabaseSnapshot(DeleteRelationalDatabaseSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteRelationalDatabaseSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteRelationalDatabaseSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteRelationalDatabaseSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteRelationalDatabaseSnapshot. /// /// Returns a DeleteRelationalDatabaseSnapshotResult from Lightsail. /// REST API Reference for DeleteRelationalDatabaseSnapshot Operation public virtual DeleteRelationalDatabaseSnapshotResponse EndDeleteRelationalDatabaseSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DetachCertificateFromDistribution ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DetachCertificateFromDistribution service method. /// /// The response from the DetachCertificateFromDistribution service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DetachCertificateFromDistribution Operation public virtual DetachCertificateFromDistributionResponse DetachCertificateFromDistribution(DetachCertificateFromDistributionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DetachCertificateFromDistributionRequestMarshaller.Instance; options.ResponseUnmarshaller = DetachCertificateFromDistributionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DetachCertificateFromDistribution operation. ///

/// /// Container for the necessary parameters to execute the DetachCertificateFromDistribution operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDetachCertificateFromDistribution /// operation. /// REST API Reference for DetachCertificateFromDistribution Operation public virtual IAsyncResult BeginDetachCertificateFromDistribution(DetachCertificateFromDistributionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DetachCertificateFromDistributionRequestMarshaller.Instance; options.ResponseUnmarshaller = DetachCertificateFromDistributionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DetachCertificateFromDistribution operation. ///

/// /// The IAsyncResult returned by the call to BeginDetachCertificateFromDistribution. /// /// Returns a DetachCertificateFromDistributionResult from Lightsail. /// REST API Reference for DetachCertificateFromDistribution Operation public virtual DetachCertificateFromDistributionResponse EndDetachCertificateFromDistribution(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DetachDisk ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DetachDisk service method. /// /// The response from the DetachDisk service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DetachDisk Operation public virtual DetachDiskResponse DetachDisk(DetachDiskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DetachDiskRequestMarshaller.Instance; options.ResponseUnmarshaller = DetachDiskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DetachDisk operation. ///

/// /// Container for the necessary parameters to execute the DetachDisk operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDetachDisk /// operation. /// REST API Reference for DetachDisk Operation public virtual IAsyncResult BeginDetachDisk(DetachDiskRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DetachDiskRequestMarshaller.Instance; options.ResponseUnmarshaller = DetachDiskResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DetachDisk operation. ///

/// /// The IAsyncResult returned by the call to BeginDetachDisk. /// /// Returns a DetachDiskResult from Lightsail. /// REST API Reference for DetachDisk Operation public virtual DetachDiskResponse EndDetachDisk(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DetachInstancesFromLoadBalancer ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DetachInstancesFromLoadBalancer service method. /// /// The response from the DetachInstancesFromLoadBalancer service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DetachInstancesFromLoadBalancer Operation public virtual DetachInstancesFromLoadBalancerResponse DetachInstancesFromLoadBalancer(DetachInstancesFromLoadBalancerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DetachInstancesFromLoadBalancerRequestMarshaller.Instance; options.ResponseUnmarshaller = DetachInstancesFromLoadBalancerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DetachInstancesFromLoadBalancer operation. ///

/// /// Container for the necessary parameters to execute the DetachInstancesFromLoadBalancer operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDetachInstancesFromLoadBalancer /// operation. /// REST API Reference for DetachInstancesFromLoadBalancer Operation public virtual IAsyncResult BeginDetachInstancesFromLoadBalancer(DetachInstancesFromLoadBalancerRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DetachInstancesFromLoadBalancerRequestMarshaller.Instance; options.ResponseUnmarshaller = DetachInstancesFromLoadBalancerResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DetachInstancesFromLoadBalancer operation. ///

/// /// The IAsyncResult returned by the call to BeginDetachInstancesFromLoadBalancer. /// /// Returns a DetachInstancesFromLoadBalancerResult from Lightsail. /// REST API Reference for DetachInstancesFromLoadBalancer Operation public virtual DetachInstancesFromLoadBalancerResponse EndDetachInstancesFromLoadBalancer(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DetachStaticIp ///

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

/// Container for the necessary parameters to execute the DetachStaticIp service method. /// /// The response from the DetachStaticIp service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DetachStaticIp Operation public virtual DetachStaticIpResponse DetachStaticIp(DetachStaticIpRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DetachStaticIpRequestMarshaller.Instance; options.ResponseUnmarshaller = DetachStaticIpResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DetachStaticIp operation. ///

/// /// Container for the necessary parameters to execute the DetachStaticIp operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDetachStaticIp /// operation. /// REST API Reference for DetachStaticIp Operation public virtual IAsyncResult BeginDetachStaticIp(DetachStaticIpRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DetachStaticIpRequestMarshaller.Instance; options.ResponseUnmarshaller = DetachStaticIpResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DetachStaticIp operation. ///

/// /// The IAsyncResult returned by the call to BeginDetachStaticIp. /// /// Returns a DetachStaticIpResult from Lightsail. /// REST API Reference for DetachStaticIp Operation public virtual DetachStaticIpResponse EndDetachStaticIp(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DisableAddOn ///

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

/// Container for the necessary parameters to execute the DisableAddOn service method. /// /// The response from the DisableAddOn service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DisableAddOn Operation public virtual DisableAddOnResponse DisableAddOn(DisableAddOnRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisableAddOnRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableAddOnResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DisableAddOn operation. ///

/// /// Container for the necessary parameters to execute the DisableAddOn operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisableAddOn /// operation. /// REST API Reference for DisableAddOn Operation public virtual IAsyncResult BeginDisableAddOn(DisableAddOnRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DisableAddOnRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableAddOnResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DisableAddOn operation. ///

/// /// The IAsyncResult returned by the call to BeginDisableAddOn. /// /// Returns a DisableAddOnResult from Lightsail. /// REST API Reference for DisableAddOn Operation public virtual DisableAddOnResponse EndDisableAddOn(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DownloadDefaultKeyPair ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DownloadDefaultKeyPair service method. /// /// The response from the DownloadDefaultKeyPair service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for DownloadDefaultKeyPair Operation public virtual DownloadDefaultKeyPairResponse DownloadDefaultKeyPair(DownloadDefaultKeyPairRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DownloadDefaultKeyPairRequestMarshaller.Instance; options.ResponseUnmarshaller = DownloadDefaultKeyPairResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DownloadDefaultKeyPair operation. ///

/// /// Container for the necessary parameters to execute the DownloadDefaultKeyPair operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDownloadDefaultKeyPair /// operation. /// REST API Reference for DownloadDefaultKeyPair Operation public virtual IAsyncResult BeginDownloadDefaultKeyPair(DownloadDefaultKeyPairRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DownloadDefaultKeyPairRequestMarshaller.Instance; options.ResponseUnmarshaller = DownloadDefaultKeyPairResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DownloadDefaultKeyPair operation. ///

/// /// The IAsyncResult returned by the call to BeginDownloadDefaultKeyPair. /// /// Returns a DownloadDefaultKeyPairResult from Lightsail. /// REST API Reference for DownloadDefaultKeyPair Operation public virtual DownloadDefaultKeyPairResponse EndDownloadDefaultKeyPair(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region EnableAddOn ///

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

/// Container for the necessary parameters to execute the EnableAddOn service method. /// /// The response from the EnableAddOn service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for EnableAddOn Operation public virtual EnableAddOnResponse EnableAddOn(EnableAddOnRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = EnableAddOnRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableAddOnResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the EnableAddOn operation. ///

/// /// Container for the necessary parameters to execute the EnableAddOn operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEnableAddOn /// operation. /// REST API Reference for EnableAddOn Operation public virtual IAsyncResult BeginEnableAddOn(EnableAddOnRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = EnableAddOnRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableAddOnResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the EnableAddOn operation. ///

/// /// The IAsyncResult returned by the call to BeginEnableAddOn. /// /// Returns a EnableAddOnResult from Lightsail. /// REST API Reference for EnableAddOn Operation public virtual EnableAddOnResponse EndEnableAddOn(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ExportSnapshot ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the ExportSnapshot service method. /// /// The response from the ExportSnapshot service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for ExportSnapshot Operation public virtual ExportSnapshotResponse ExportSnapshot(ExportSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ExportSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = ExportSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ExportSnapshot operation. ///

/// /// Container for the necessary parameters to execute the ExportSnapshot operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndExportSnapshot /// operation. /// REST API Reference for ExportSnapshot Operation public virtual IAsyncResult BeginExportSnapshot(ExportSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ExportSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = ExportSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ExportSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginExportSnapshot. /// /// Returns a ExportSnapshotResult from Lightsail. /// REST API Reference for ExportSnapshot Operation public virtual ExportSnapshotResponse EndExportSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetActiveNames ///

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

/// Container for the necessary parameters to execute the GetActiveNames service method. /// /// The response from the GetActiveNames service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetActiveNames Operation public virtual GetActiveNamesResponse GetActiveNames(GetActiveNamesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetActiveNamesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetActiveNamesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetActiveNames operation. ///

/// /// Container for the necessary parameters to execute the GetActiveNames operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetActiveNames /// operation. /// REST API Reference for GetActiveNames Operation public virtual IAsyncResult BeginGetActiveNames(GetActiveNamesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetActiveNamesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetActiveNamesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetActiveNames operation. ///

/// /// The IAsyncResult returned by the call to BeginGetActiveNames. /// /// Returns a GetActiveNamesResult from Lightsail. /// REST API Reference for GetActiveNames Operation public virtual GetActiveNamesResponse EndGetActiveNames(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetAlarms ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetAlarms service method. /// /// The response from the GetAlarms service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetAlarms Operation public virtual GetAlarmsResponse GetAlarms(GetAlarmsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetAlarmsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAlarmsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetAlarms operation. ///

/// /// Container for the necessary parameters to execute the GetAlarms operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetAlarms /// operation. /// REST API Reference for GetAlarms Operation public virtual IAsyncResult BeginGetAlarms(GetAlarmsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetAlarmsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAlarmsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetAlarms operation. ///

/// /// The IAsyncResult returned by the call to BeginGetAlarms. /// /// Returns a GetAlarmsResult from Lightsail. /// REST API Reference for GetAlarms Operation public virtual GetAlarmsResponse EndGetAlarms(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetAutoSnapshots ///

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

/// Container for the necessary parameters to execute the GetAutoSnapshots service method. /// /// The response from the GetAutoSnapshots service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetAutoSnapshots Operation public virtual GetAutoSnapshotsResponse GetAutoSnapshots(GetAutoSnapshotsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetAutoSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAutoSnapshotsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetAutoSnapshots operation. ///

/// /// Container for the necessary parameters to execute the GetAutoSnapshots operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetAutoSnapshots /// operation. /// REST API Reference for GetAutoSnapshots Operation public virtual IAsyncResult BeginGetAutoSnapshots(GetAutoSnapshotsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetAutoSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAutoSnapshotsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetAutoSnapshots operation. ///

/// /// The IAsyncResult returned by the call to BeginGetAutoSnapshots. /// /// Returns a GetAutoSnapshotsResult from Lightsail. /// REST API Reference for GetAutoSnapshots Operation public virtual GetAutoSnapshotsResponse EndGetAutoSnapshots(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetBlueprints ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the GetBlueprints service method. /// /// The response from the GetBlueprints service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetBlueprints Operation public virtual GetBlueprintsResponse GetBlueprints(GetBlueprintsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetBlueprintsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetBlueprintsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetBlueprints operation. ///

/// /// Container for the necessary parameters to execute the GetBlueprints operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetBlueprints /// operation. /// REST API Reference for GetBlueprints Operation public virtual IAsyncResult BeginGetBlueprints(GetBlueprintsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetBlueprintsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetBlueprintsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetBlueprints operation. ///

/// /// The IAsyncResult returned by the call to BeginGetBlueprints. /// /// Returns a GetBlueprintsResult from Lightsail. /// REST API Reference for GetBlueprints Operation public virtual GetBlueprintsResponse EndGetBlueprints(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetBucketAccessKeys ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the GetBucketAccessKeys service method. /// /// The response from the GetBucketAccessKeys service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetBucketAccessKeys Operation public virtual GetBucketAccessKeysResponse GetBucketAccessKeys(GetBucketAccessKeysRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetBucketAccessKeysRequestMarshaller.Instance; options.ResponseUnmarshaller = GetBucketAccessKeysResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetBucketAccessKeys operation. ///

/// /// Container for the necessary parameters to execute the GetBucketAccessKeys operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetBucketAccessKeys /// operation. /// REST API Reference for GetBucketAccessKeys Operation public virtual IAsyncResult BeginGetBucketAccessKeys(GetBucketAccessKeysRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetBucketAccessKeysRequestMarshaller.Instance; options.ResponseUnmarshaller = GetBucketAccessKeysResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetBucketAccessKeys operation. ///

/// /// The IAsyncResult returned by the call to BeginGetBucketAccessKeys. /// /// Returns a GetBucketAccessKeysResult from Lightsail. /// REST API Reference for GetBucketAccessKeys Operation public virtual GetBucketAccessKeysResponse EndGetBucketAccessKeys(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetBucketBundles ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetBucketBundles service method. /// /// The response from the GetBucketBundles service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetBucketBundles Operation public virtual GetBucketBundlesResponse GetBucketBundles(GetBucketBundlesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetBucketBundlesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetBucketBundlesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetBucketBundles operation. ///

/// /// Container for the necessary parameters to execute the GetBucketBundles operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetBucketBundles /// operation. /// REST API Reference for GetBucketBundles Operation public virtual IAsyncResult BeginGetBucketBundles(GetBucketBundlesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetBucketBundlesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetBucketBundlesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetBucketBundles operation. ///

/// /// The IAsyncResult returned by the call to BeginGetBucketBundles. /// /// Returns a GetBucketBundlesResult from Lightsail. /// REST API Reference for GetBucketBundles Operation public virtual GetBucketBundlesResponse EndGetBucketBundles(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetBucketMetricData ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetBucketMetricData service method. /// /// The response from the GetBucketMetricData service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetBucketMetricData Operation public virtual GetBucketMetricDataResponse GetBucketMetricData(GetBucketMetricDataRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetBucketMetricDataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetBucketMetricDataResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetBucketMetricData operation. ///

/// /// Container for the necessary parameters to execute the GetBucketMetricData operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetBucketMetricData /// operation. /// REST API Reference for GetBucketMetricData Operation public virtual IAsyncResult BeginGetBucketMetricData(GetBucketMetricDataRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetBucketMetricDataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetBucketMetricDataResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetBucketMetricData operation. ///

/// /// The IAsyncResult returned by the call to BeginGetBucketMetricData. /// /// Returns a GetBucketMetricDataResult from Lightsail. /// REST API Reference for GetBucketMetricData Operation public virtual GetBucketMetricDataResponse EndGetBucketMetricData(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetBuckets ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetBuckets service method. /// /// The response from the GetBuckets service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetBuckets Operation public virtual GetBucketsResponse GetBuckets(GetBucketsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetBucketsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetBucketsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetBuckets operation. ///

/// /// Container for the necessary parameters to execute the GetBuckets operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetBuckets /// operation. /// REST API Reference for GetBuckets Operation public virtual IAsyncResult BeginGetBuckets(GetBucketsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetBucketsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetBucketsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetBuckets operation. ///

/// /// The IAsyncResult returned by the call to BeginGetBuckets. /// /// Returns a GetBucketsResult from Lightsail. /// REST API Reference for GetBuckets Operation public virtual GetBucketsResponse EndGetBuckets(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetBundles ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the GetBundles service method. /// /// The response from the GetBundles service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetBundles Operation public virtual GetBundlesResponse GetBundles(GetBundlesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetBundlesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetBundlesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetBundles operation. ///

/// /// Container for the necessary parameters to execute the GetBundles operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetBundles /// operation. /// REST API Reference for GetBundles Operation public virtual IAsyncResult BeginGetBundles(GetBundlesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetBundlesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetBundlesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetBundles operation. ///

/// /// The IAsyncResult returned by the call to BeginGetBundles. /// /// Returns a GetBundlesResult from Lightsail. /// REST API Reference for GetBundles Operation public virtual GetBundlesResponse EndGetBundles(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetCertificates ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the GetCertificates service method. /// /// The response from the GetCertificates service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetCertificates Operation public virtual GetCertificatesResponse GetCertificates(GetCertificatesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetCertificatesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCertificatesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetCertificates operation. ///

/// /// Container for the necessary parameters to execute the GetCertificates operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetCertificates /// operation. /// REST API Reference for GetCertificates Operation public virtual IAsyncResult BeginGetCertificates(GetCertificatesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetCertificatesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCertificatesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetCertificates operation. ///

/// /// The IAsyncResult returned by the call to BeginGetCertificates. /// /// Returns a GetCertificatesResult from Lightsail. /// REST API Reference for GetCertificates Operation public virtual GetCertificatesResponse EndGetCertificates(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetCloudFormationStackRecords ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetCloudFormationStackRecords service method. /// /// The response from the GetCloudFormationStackRecords service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetCloudFormationStackRecords Operation public virtual GetCloudFormationStackRecordsResponse GetCloudFormationStackRecords(GetCloudFormationStackRecordsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetCloudFormationStackRecordsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCloudFormationStackRecordsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetCloudFormationStackRecords operation. ///

/// /// Container for the necessary parameters to execute the GetCloudFormationStackRecords operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetCloudFormationStackRecords /// operation. /// REST API Reference for GetCloudFormationStackRecords Operation public virtual IAsyncResult BeginGetCloudFormationStackRecords(GetCloudFormationStackRecordsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetCloudFormationStackRecordsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCloudFormationStackRecordsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetCloudFormationStackRecords operation. ///

/// /// The IAsyncResult returned by the call to BeginGetCloudFormationStackRecords. /// /// Returns a GetCloudFormationStackRecordsResult from Lightsail. /// REST API Reference for GetCloudFormationStackRecords Operation public virtual GetCloudFormationStackRecordsResponse EndGetCloudFormationStackRecords(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetContactMethods ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetContactMethods service method. /// /// The response from the GetContactMethods service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetContactMethods Operation public virtual GetContactMethodsResponse GetContactMethods(GetContactMethodsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetContactMethodsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetContactMethodsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetContactMethods operation. ///

/// /// Container for the necessary parameters to execute the GetContactMethods operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetContactMethods /// operation. /// REST API Reference for GetContactMethods Operation public virtual IAsyncResult BeginGetContactMethods(GetContactMethodsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetContactMethodsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetContactMethodsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetContactMethods operation. ///

/// /// The IAsyncResult returned by the call to BeginGetContactMethods. /// /// Returns a GetContactMethodsResult from Lightsail. /// REST API Reference for GetContactMethods Operation public virtual GetContactMethodsResponse EndGetContactMethods(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetContainerAPIMetadata ///

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

/// Container for the necessary parameters to execute the GetContainerAPIMetadata service method. /// /// The response from the GetContainerAPIMetadata service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetContainerAPIMetadata Operation public virtual GetContainerAPIMetadataResponse GetContainerAPIMetadata(GetContainerAPIMetadataRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetContainerAPIMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetContainerAPIMetadataResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetContainerAPIMetadata operation. ///

/// /// Container for the necessary parameters to execute the GetContainerAPIMetadata operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetContainerAPIMetadata /// operation. /// REST API Reference for GetContainerAPIMetadata Operation public virtual IAsyncResult BeginGetContainerAPIMetadata(GetContainerAPIMetadataRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetContainerAPIMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetContainerAPIMetadataResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetContainerAPIMetadata operation. ///

/// /// The IAsyncResult returned by the call to BeginGetContainerAPIMetadata. /// /// Returns a GetContainerAPIMetadataResult from Lightsail. /// REST API Reference for GetContainerAPIMetadata Operation public virtual GetContainerAPIMetadataResponse EndGetContainerAPIMetadata(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetContainerImages ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the GetContainerImages service method. /// /// The response from the GetContainerImages service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetContainerImages Operation public virtual GetContainerImagesResponse GetContainerImages(GetContainerImagesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetContainerImagesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetContainerImagesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetContainerImages operation. ///

/// /// Container for the necessary parameters to execute the GetContainerImages operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetContainerImages /// operation. /// REST API Reference for GetContainerImages Operation public virtual IAsyncResult BeginGetContainerImages(GetContainerImagesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetContainerImagesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetContainerImagesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetContainerImages operation. ///

/// /// The IAsyncResult returned by the call to BeginGetContainerImages. /// /// Returns a GetContainerImagesResult from Lightsail. /// REST API Reference for GetContainerImages Operation public virtual GetContainerImagesResponse EndGetContainerImages(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetContainerLog ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the GetContainerLog service method. /// /// The response from the GetContainerLog service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetContainerLog Operation public virtual GetContainerLogResponse GetContainerLog(GetContainerLogRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetContainerLogRequestMarshaller.Instance; options.ResponseUnmarshaller = GetContainerLogResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetContainerLog operation. ///

/// /// Container for the necessary parameters to execute the GetContainerLog operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetContainerLog /// operation. /// REST API Reference for GetContainerLog Operation public virtual IAsyncResult BeginGetContainerLog(GetContainerLogRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetContainerLogRequestMarshaller.Instance; options.ResponseUnmarshaller = GetContainerLogResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetContainerLog operation. ///

/// /// The IAsyncResult returned by the call to BeginGetContainerLog. /// /// Returns a GetContainerLogResult from Lightsail. /// REST API Reference for GetContainerLog Operation public virtual GetContainerLogResponse EndGetContainerLog(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetContainerServiceDeployments ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the GetContainerServiceDeployments service method. /// /// The response from the GetContainerServiceDeployments service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetContainerServiceDeployments Operation public virtual GetContainerServiceDeploymentsResponse GetContainerServiceDeployments(GetContainerServiceDeploymentsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetContainerServiceDeploymentsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetContainerServiceDeploymentsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetContainerServiceDeployments operation. ///

/// /// Container for the necessary parameters to execute the GetContainerServiceDeployments operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetContainerServiceDeployments /// operation. /// REST API Reference for GetContainerServiceDeployments Operation public virtual IAsyncResult BeginGetContainerServiceDeployments(GetContainerServiceDeploymentsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetContainerServiceDeploymentsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetContainerServiceDeploymentsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetContainerServiceDeployments operation. ///

/// /// The IAsyncResult returned by the call to BeginGetContainerServiceDeployments. /// /// Returns a GetContainerServiceDeploymentsResult from Lightsail. /// REST API Reference for GetContainerServiceDeployments Operation public virtual GetContainerServiceDeploymentsResponse EndGetContainerServiceDeployments(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetContainerServiceMetricData ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetContainerServiceMetricData service method. /// /// The response from the GetContainerServiceMetricData service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetContainerServiceMetricData Operation public virtual GetContainerServiceMetricDataResponse GetContainerServiceMetricData(GetContainerServiceMetricDataRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetContainerServiceMetricDataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetContainerServiceMetricDataResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetContainerServiceMetricData operation. ///

/// /// Container for the necessary parameters to execute the GetContainerServiceMetricData operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetContainerServiceMetricData /// operation. /// REST API Reference for GetContainerServiceMetricData Operation public virtual IAsyncResult BeginGetContainerServiceMetricData(GetContainerServiceMetricDataRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetContainerServiceMetricDataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetContainerServiceMetricDataResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetContainerServiceMetricData operation. ///

/// /// The IAsyncResult returned by the call to BeginGetContainerServiceMetricData. /// /// Returns a GetContainerServiceMetricDataResult from Lightsail. /// REST API Reference for GetContainerServiceMetricData Operation public virtual GetContainerServiceMetricDataResponse EndGetContainerServiceMetricData(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetContainerServicePowers ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetContainerServicePowers service method. /// /// The response from the GetContainerServicePowers service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetContainerServicePowers Operation public virtual GetContainerServicePowersResponse GetContainerServicePowers(GetContainerServicePowersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetContainerServicePowersRequestMarshaller.Instance; options.ResponseUnmarshaller = GetContainerServicePowersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetContainerServicePowers operation. ///

/// /// Container for the necessary parameters to execute the GetContainerServicePowers operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetContainerServicePowers /// operation. /// REST API Reference for GetContainerServicePowers Operation public virtual IAsyncResult BeginGetContainerServicePowers(GetContainerServicePowersRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetContainerServicePowersRequestMarshaller.Instance; options.ResponseUnmarshaller = GetContainerServicePowersResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetContainerServicePowers operation. ///

/// /// The IAsyncResult returned by the call to BeginGetContainerServicePowers. /// /// Returns a GetContainerServicePowersResult from Lightsail. /// REST API Reference for GetContainerServicePowers Operation public virtual GetContainerServicePowersResponse EndGetContainerServicePowers(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetContainerServices ///

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

/// Container for the necessary parameters to execute the GetContainerServices service method. /// /// The response from the GetContainerServices service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetContainerServices Operation public virtual GetContainerServicesResponse GetContainerServices(GetContainerServicesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetContainerServicesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetContainerServicesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetContainerServices operation. ///

/// /// Container for the necessary parameters to execute the GetContainerServices operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetContainerServices /// operation. /// REST API Reference for GetContainerServices Operation public virtual IAsyncResult BeginGetContainerServices(GetContainerServicesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetContainerServicesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetContainerServicesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetContainerServices operation. ///

/// /// The IAsyncResult returned by the call to BeginGetContainerServices. /// /// Returns a GetContainerServicesResult from Lightsail. /// REST API Reference for GetContainerServices Operation public virtual GetContainerServicesResponse EndGetContainerServices(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetCostEstimate ///

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

/// Container for the necessary parameters to execute the GetCostEstimate service method. /// /// The response from the GetCostEstimate service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetCostEstimate Operation public virtual GetCostEstimateResponse GetCostEstimate(GetCostEstimateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetCostEstimateRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCostEstimateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetCostEstimate operation. ///

/// /// Container for the necessary parameters to execute the GetCostEstimate operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetCostEstimate /// operation. /// REST API Reference for GetCostEstimate Operation public virtual IAsyncResult BeginGetCostEstimate(GetCostEstimateRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetCostEstimateRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCostEstimateResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetCostEstimate operation. ///

/// /// The IAsyncResult returned by the call to BeginGetCostEstimate. /// /// Returns a GetCostEstimateResult from Lightsail. /// REST API Reference for GetCostEstimate Operation public virtual GetCostEstimateResponse EndGetCostEstimate(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetDisk ///

/// Returns information about a specific block storage disk. ///

/// Container for the necessary parameters to execute the GetDisk service method. /// /// The response from the GetDisk service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetDisk Operation public virtual GetDiskResponse GetDisk(GetDiskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDiskRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDiskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetDisk operation. ///

/// /// Container for the necessary parameters to execute the GetDisk operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDisk /// operation. /// REST API Reference for GetDisk Operation public virtual IAsyncResult BeginGetDisk(GetDiskRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetDiskRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDiskResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetDisk operation. ///

/// /// The IAsyncResult returned by the call to BeginGetDisk. /// /// Returns a GetDiskResult from Lightsail. /// REST API Reference for GetDisk Operation public virtual GetDiskResponse EndGetDisk(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetDisks ///

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

/// Container for the necessary parameters to execute the GetDisks service method. /// /// The response from the GetDisks service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetDisks Operation public virtual GetDisksResponse GetDisks(GetDisksRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDisksRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDisksResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetDisks operation. ///

/// /// Container for the necessary parameters to execute the GetDisks operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDisks /// operation. /// REST API Reference for GetDisks Operation public virtual IAsyncResult BeginGetDisks(GetDisksRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetDisksRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDisksResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetDisks operation. ///

/// /// The IAsyncResult returned by the call to BeginGetDisks. /// /// Returns a GetDisksResult from Lightsail. /// REST API Reference for GetDisks Operation public virtual GetDisksResponse EndGetDisks(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetDiskSnapshot ///

/// Returns information about a specific block storage disk snapshot. ///

/// Container for the necessary parameters to execute the GetDiskSnapshot service method. /// /// The response from the GetDiskSnapshot service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetDiskSnapshot Operation public virtual GetDiskSnapshotResponse GetDiskSnapshot(GetDiskSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDiskSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDiskSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetDiskSnapshot operation. ///

/// /// Container for the necessary parameters to execute the GetDiskSnapshot operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDiskSnapshot /// operation. /// REST API Reference for GetDiskSnapshot Operation public virtual IAsyncResult BeginGetDiskSnapshot(GetDiskSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetDiskSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDiskSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetDiskSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginGetDiskSnapshot. /// /// Returns a GetDiskSnapshotResult from Lightsail. /// REST API Reference for GetDiskSnapshot Operation public virtual GetDiskSnapshotResponse EndGetDiskSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetDiskSnapshots ///

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

/// Container for the necessary parameters to execute the GetDiskSnapshots service method. /// /// The response from the GetDiskSnapshots service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetDiskSnapshots Operation public virtual GetDiskSnapshotsResponse GetDiskSnapshots(GetDiskSnapshotsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDiskSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDiskSnapshotsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetDiskSnapshots operation. ///

/// /// Container for the necessary parameters to execute the GetDiskSnapshots operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDiskSnapshots /// operation. /// REST API Reference for GetDiskSnapshots Operation public virtual IAsyncResult BeginGetDiskSnapshots(GetDiskSnapshotsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetDiskSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDiskSnapshotsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetDiskSnapshots operation. ///

/// /// The IAsyncResult returned by the call to BeginGetDiskSnapshots. /// /// Returns a GetDiskSnapshotsResult from Lightsail. /// REST API Reference for GetDiskSnapshots Operation public virtual GetDiskSnapshotsResponse EndGetDiskSnapshots(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetDistributionBundles ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetDistributionBundles service method. /// /// The response from the GetDistributionBundles service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetDistributionBundles Operation public virtual GetDistributionBundlesResponse GetDistributionBundles(GetDistributionBundlesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDistributionBundlesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDistributionBundlesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetDistributionBundles operation. ///

/// /// Container for the necessary parameters to execute the GetDistributionBundles operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDistributionBundles /// operation. /// REST API Reference for GetDistributionBundles Operation public virtual IAsyncResult BeginGetDistributionBundles(GetDistributionBundlesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetDistributionBundlesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDistributionBundlesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetDistributionBundles operation. ///

/// /// The IAsyncResult returned by the call to BeginGetDistributionBundles. /// /// Returns a GetDistributionBundlesResult from Lightsail. /// REST API Reference for GetDistributionBundles Operation public virtual GetDistributionBundlesResponse EndGetDistributionBundles(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetDistributionLatestCacheReset ///

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

/// Container for the necessary parameters to execute the GetDistributionLatestCacheReset service method. /// /// The response from the GetDistributionLatestCacheReset service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetDistributionLatestCacheReset Operation public virtual GetDistributionLatestCacheResetResponse GetDistributionLatestCacheReset(GetDistributionLatestCacheResetRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDistributionLatestCacheResetRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDistributionLatestCacheResetResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetDistributionLatestCacheReset operation. ///

/// /// Container for the necessary parameters to execute the GetDistributionLatestCacheReset operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDistributionLatestCacheReset /// operation. /// REST API Reference for GetDistributionLatestCacheReset Operation public virtual IAsyncResult BeginGetDistributionLatestCacheReset(GetDistributionLatestCacheResetRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetDistributionLatestCacheResetRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDistributionLatestCacheResetResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetDistributionLatestCacheReset operation. ///

/// /// The IAsyncResult returned by the call to BeginGetDistributionLatestCacheReset. /// /// Returns a GetDistributionLatestCacheResetResult from Lightsail. /// REST API Reference for GetDistributionLatestCacheReset Operation public virtual GetDistributionLatestCacheResetResponse EndGetDistributionLatestCacheReset(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetDistributionMetricData ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetDistributionMetricData service method. /// /// The response from the GetDistributionMetricData service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetDistributionMetricData Operation public virtual GetDistributionMetricDataResponse GetDistributionMetricData(GetDistributionMetricDataRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDistributionMetricDataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDistributionMetricDataResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetDistributionMetricData operation. ///

/// /// Container for the necessary parameters to execute the GetDistributionMetricData operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDistributionMetricData /// operation. /// REST API Reference for GetDistributionMetricData Operation public virtual IAsyncResult BeginGetDistributionMetricData(GetDistributionMetricDataRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetDistributionMetricDataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDistributionMetricDataResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetDistributionMetricData operation. ///

/// /// The IAsyncResult returned by the call to BeginGetDistributionMetricData. /// /// Returns a GetDistributionMetricDataResult from Lightsail. /// REST API Reference for GetDistributionMetricData Operation public virtual GetDistributionMetricDataResponse EndGetDistributionMetricData(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetDistributions ///

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

/// Container for the necessary parameters to execute the GetDistributions service method. /// /// The response from the GetDistributions service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetDistributions Operation public virtual GetDistributionsResponse GetDistributions(GetDistributionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDistributionsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDistributionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetDistributions operation. ///

/// /// Container for the necessary parameters to execute the GetDistributions operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDistributions /// operation. /// REST API Reference for GetDistributions Operation public virtual IAsyncResult BeginGetDistributions(GetDistributionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetDistributionsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDistributionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetDistributions operation. ///

/// /// The IAsyncResult returned by the call to BeginGetDistributions. /// /// Returns a GetDistributionsResult from Lightsail. /// REST API Reference for GetDistributions Operation public virtual GetDistributionsResponse EndGetDistributions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetDomain ///

/// Returns information about a specific domain recordset. ///

/// Container for the necessary parameters to execute the GetDomain service method. /// /// The response from the GetDomain service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetDomain Operation public virtual GetDomainResponse GetDomain(GetDomainRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDomainRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDomainResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetDomain operation. ///

/// /// Container for the necessary parameters to execute the GetDomain operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDomain /// operation. /// REST API Reference for GetDomain Operation public virtual IAsyncResult BeginGetDomain(GetDomainRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetDomainRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDomainResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetDomain operation. ///

/// /// The IAsyncResult returned by the call to BeginGetDomain. /// /// Returns a GetDomainResult from Lightsail. /// REST API Reference for GetDomain Operation public virtual GetDomainResponse EndGetDomain(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetDomains ///

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

/// Container for the necessary parameters to execute the GetDomains service method. /// /// The response from the GetDomains service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetDomains Operation public virtual GetDomainsResponse GetDomains(GetDomainsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDomainsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDomainsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetDomains operation. ///

/// /// Container for the necessary parameters to execute the GetDomains operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDomains /// operation. /// REST API Reference for GetDomains Operation public virtual IAsyncResult BeginGetDomains(GetDomainsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetDomainsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDomainsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetDomains operation. ///

/// /// The IAsyncResult returned by the call to BeginGetDomains. /// /// Returns a GetDomainsResult from Lightsail. /// REST API Reference for GetDomains Operation public virtual GetDomainsResponse EndGetDomains(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetExportSnapshotRecords ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetExportSnapshotRecords service method. /// /// The response from the GetExportSnapshotRecords service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetExportSnapshotRecords Operation public virtual GetExportSnapshotRecordsResponse GetExportSnapshotRecords(GetExportSnapshotRecordsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetExportSnapshotRecordsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetExportSnapshotRecordsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetExportSnapshotRecords operation. ///

/// /// Container for the necessary parameters to execute the GetExportSnapshotRecords operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetExportSnapshotRecords /// operation. /// REST API Reference for GetExportSnapshotRecords Operation public virtual IAsyncResult BeginGetExportSnapshotRecords(GetExportSnapshotRecordsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetExportSnapshotRecordsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetExportSnapshotRecordsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetExportSnapshotRecords operation. ///

/// /// The IAsyncResult returned by the call to BeginGetExportSnapshotRecords. /// /// Returns a GetExportSnapshotRecordsResult from Lightsail. /// REST API Reference for GetExportSnapshotRecords Operation public virtual GetExportSnapshotRecordsResponse EndGetExportSnapshotRecords(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetInstance ///

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

/// Container for the necessary parameters to execute the GetInstance service method. /// /// The response from the GetInstance service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetInstance Operation public virtual GetInstanceResponse GetInstance(GetInstanceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInstanceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetInstance operation. ///

/// /// Container for the necessary parameters to execute the GetInstance operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetInstance /// operation. /// REST API Reference for GetInstance Operation public virtual IAsyncResult BeginGetInstance(GetInstanceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInstanceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetInstance operation. ///

/// /// The IAsyncResult returned by the call to BeginGetInstance. /// /// Returns a GetInstanceResult from Lightsail. /// REST API Reference for GetInstance Operation public virtual GetInstanceResponse EndGetInstance(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetInstanceAccessDetails ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetInstanceAccessDetails service method. /// /// The response from the GetInstanceAccessDetails service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetInstanceAccessDetails Operation public virtual GetInstanceAccessDetailsResponse GetInstanceAccessDetails(GetInstanceAccessDetailsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetInstanceAccessDetailsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInstanceAccessDetailsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetInstanceAccessDetails operation. ///

/// /// Container for the necessary parameters to execute the GetInstanceAccessDetails operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetInstanceAccessDetails /// operation. /// REST API Reference for GetInstanceAccessDetails Operation public virtual IAsyncResult BeginGetInstanceAccessDetails(GetInstanceAccessDetailsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetInstanceAccessDetailsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInstanceAccessDetailsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetInstanceAccessDetails operation. ///

/// /// The IAsyncResult returned by the call to BeginGetInstanceAccessDetails. /// /// Returns a GetInstanceAccessDetailsResult from Lightsail. /// REST API Reference for GetInstanceAccessDetails Operation public virtual GetInstanceAccessDetailsResponse EndGetInstanceAccessDetails(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetInstanceMetricData ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetInstanceMetricData service method. /// /// The response from the GetInstanceMetricData service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetInstanceMetricData Operation public virtual GetInstanceMetricDataResponse GetInstanceMetricData(GetInstanceMetricDataRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetInstanceMetricDataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInstanceMetricDataResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetInstanceMetricData operation. ///

/// /// Container for the necessary parameters to execute the GetInstanceMetricData operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetInstanceMetricData /// operation. /// REST API Reference for GetInstanceMetricData Operation public virtual IAsyncResult BeginGetInstanceMetricData(GetInstanceMetricDataRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetInstanceMetricDataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInstanceMetricDataResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetInstanceMetricData operation. ///

/// /// The IAsyncResult returned by the call to BeginGetInstanceMetricData. /// /// Returns a GetInstanceMetricDataResult from Lightsail. /// REST API Reference for GetInstanceMetricData Operation public virtual GetInstanceMetricDataResponse EndGetInstanceMetricData(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetInstancePortStates ///

/// 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. ///

/// Container for the necessary parameters to execute the GetInstancePortStates service method. /// /// The response from the GetInstancePortStates service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetInstancePortStates Operation public virtual GetInstancePortStatesResponse GetInstancePortStates(GetInstancePortStatesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetInstancePortStatesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInstancePortStatesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetInstancePortStates operation. ///

/// /// Container for the necessary parameters to execute the GetInstancePortStates operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetInstancePortStates /// operation. /// REST API Reference for GetInstancePortStates Operation public virtual IAsyncResult BeginGetInstancePortStates(GetInstancePortStatesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetInstancePortStatesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInstancePortStatesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetInstancePortStates operation. ///

/// /// The IAsyncResult returned by the call to BeginGetInstancePortStates. /// /// Returns a GetInstancePortStatesResult from Lightsail. /// REST API Reference for GetInstancePortStates Operation public virtual GetInstancePortStatesResponse EndGetInstancePortStates(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetInstances ///

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

/// Container for the necessary parameters to execute the GetInstances service method. /// /// The response from the GetInstances service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetInstances Operation public virtual GetInstancesResponse GetInstances(GetInstancesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetInstancesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInstancesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetInstances operation. ///

/// /// Container for the necessary parameters to execute the GetInstances operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetInstances /// operation. /// REST API Reference for GetInstances Operation public virtual IAsyncResult BeginGetInstances(GetInstancesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetInstancesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInstancesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetInstances operation. ///

/// /// The IAsyncResult returned by the call to BeginGetInstances. /// /// Returns a GetInstancesResult from Lightsail. /// REST API Reference for GetInstances Operation public virtual GetInstancesResponse EndGetInstances(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetInstanceSnapshot ///

/// Returns information about a specific instance snapshot. ///

/// Container for the necessary parameters to execute the GetInstanceSnapshot service method. /// /// The response from the GetInstanceSnapshot service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetInstanceSnapshot Operation public virtual GetInstanceSnapshotResponse GetInstanceSnapshot(GetInstanceSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetInstanceSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInstanceSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetInstanceSnapshot operation. ///

/// /// Container for the necessary parameters to execute the GetInstanceSnapshot operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetInstanceSnapshot /// operation. /// REST API Reference for GetInstanceSnapshot Operation public virtual IAsyncResult BeginGetInstanceSnapshot(GetInstanceSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetInstanceSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInstanceSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetInstanceSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginGetInstanceSnapshot. /// /// Returns a GetInstanceSnapshotResult from Lightsail. /// REST API Reference for GetInstanceSnapshot Operation public virtual GetInstanceSnapshotResponse EndGetInstanceSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetInstanceSnapshots ///

/// Returns all instance snapshots for the user's account. ///

/// Container for the necessary parameters to execute the GetInstanceSnapshots service method. /// /// The response from the GetInstanceSnapshots service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetInstanceSnapshots Operation public virtual GetInstanceSnapshotsResponse GetInstanceSnapshots(GetInstanceSnapshotsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetInstanceSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInstanceSnapshotsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetInstanceSnapshots operation. ///

/// /// Container for the necessary parameters to execute the GetInstanceSnapshots operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetInstanceSnapshots /// operation. /// REST API Reference for GetInstanceSnapshots Operation public virtual IAsyncResult BeginGetInstanceSnapshots(GetInstanceSnapshotsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetInstanceSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInstanceSnapshotsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetInstanceSnapshots operation. ///

/// /// The IAsyncResult returned by the call to BeginGetInstanceSnapshots. /// /// Returns a GetInstanceSnapshotsResult from Lightsail. /// REST API Reference for GetInstanceSnapshots Operation public virtual GetInstanceSnapshotsResponse EndGetInstanceSnapshots(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetInstanceState ///

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

/// Container for the necessary parameters to execute the GetInstanceState service method. /// /// The response from the GetInstanceState service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetInstanceState Operation public virtual GetInstanceStateResponse GetInstanceState(GetInstanceStateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetInstanceStateRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInstanceStateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetInstanceState operation. ///

/// /// Container for the necessary parameters to execute the GetInstanceState operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetInstanceState /// operation. /// REST API Reference for GetInstanceState Operation public virtual IAsyncResult BeginGetInstanceState(GetInstanceStateRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetInstanceStateRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInstanceStateResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetInstanceState operation. ///

/// /// The IAsyncResult returned by the call to BeginGetInstanceState. /// /// Returns a GetInstanceStateResult from Lightsail. /// REST API Reference for GetInstanceState Operation public virtual GetInstanceStateResponse EndGetInstanceState(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetKeyPair ///

/// Returns information about a specific key pair. ///

/// Container for the necessary parameters to execute the GetKeyPair service method. /// /// The response from the GetKeyPair service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetKeyPair Operation public virtual GetKeyPairResponse GetKeyPair(GetKeyPairRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetKeyPairRequestMarshaller.Instance; options.ResponseUnmarshaller = GetKeyPairResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetKeyPair operation. ///

/// /// Container for the necessary parameters to execute the GetKeyPair operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetKeyPair /// operation. /// REST API Reference for GetKeyPair Operation public virtual IAsyncResult BeginGetKeyPair(GetKeyPairRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetKeyPairRequestMarshaller.Instance; options.ResponseUnmarshaller = GetKeyPairResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetKeyPair operation. ///

/// /// The IAsyncResult returned by the call to BeginGetKeyPair. /// /// Returns a GetKeyPairResult from Lightsail. /// REST API Reference for GetKeyPair Operation public virtual GetKeyPairResponse EndGetKeyPair(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetKeyPairs ///

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

/// Container for the necessary parameters to execute the GetKeyPairs service method. /// /// The response from the GetKeyPairs service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetKeyPairs Operation public virtual GetKeyPairsResponse GetKeyPairs(GetKeyPairsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetKeyPairsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetKeyPairsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetKeyPairs operation. ///

/// /// Container for the necessary parameters to execute the GetKeyPairs operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetKeyPairs /// operation. /// REST API Reference for GetKeyPairs Operation public virtual IAsyncResult BeginGetKeyPairs(GetKeyPairsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetKeyPairsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetKeyPairsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetKeyPairs operation. ///

/// /// The IAsyncResult returned by the call to BeginGetKeyPairs. /// /// Returns a GetKeyPairsResult from Lightsail. /// REST API Reference for GetKeyPairs Operation public virtual GetKeyPairsResponse EndGetKeyPairs(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetLoadBalancer ///

/// Returns information about the specified Lightsail load balancer. ///

/// Container for the necessary parameters to execute the GetLoadBalancer service method. /// /// The response from the GetLoadBalancer service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetLoadBalancer Operation public virtual GetLoadBalancerResponse GetLoadBalancer(GetLoadBalancerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetLoadBalancerRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLoadBalancerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetLoadBalancer operation. ///

/// /// Container for the necessary parameters to execute the GetLoadBalancer operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetLoadBalancer /// operation. /// REST API Reference for GetLoadBalancer Operation public virtual IAsyncResult BeginGetLoadBalancer(GetLoadBalancerRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetLoadBalancerRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLoadBalancerResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetLoadBalancer operation. ///

/// /// The IAsyncResult returned by the call to BeginGetLoadBalancer. /// /// Returns a GetLoadBalancerResult from Lightsail. /// REST API Reference for GetLoadBalancer Operation public virtual GetLoadBalancerResponse EndGetLoadBalancer(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetLoadBalancerMetricData ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetLoadBalancerMetricData service method. /// /// The response from the GetLoadBalancerMetricData service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetLoadBalancerMetricData Operation public virtual GetLoadBalancerMetricDataResponse GetLoadBalancerMetricData(GetLoadBalancerMetricDataRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetLoadBalancerMetricDataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLoadBalancerMetricDataResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetLoadBalancerMetricData operation. ///

/// /// Container for the necessary parameters to execute the GetLoadBalancerMetricData operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetLoadBalancerMetricData /// operation. /// REST API Reference for GetLoadBalancerMetricData Operation public virtual IAsyncResult BeginGetLoadBalancerMetricData(GetLoadBalancerMetricDataRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetLoadBalancerMetricDataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLoadBalancerMetricDataResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetLoadBalancerMetricData operation. ///

/// /// The IAsyncResult returned by the call to BeginGetLoadBalancerMetricData. /// /// Returns a GetLoadBalancerMetricDataResult from Lightsail. /// REST API Reference for GetLoadBalancerMetricData Operation public virtual GetLoadBalancerMetricDataResponse EndGetLoadBalancerMetricData(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetLoadBalancers ///

/// Returns information about all load balancers in an account. ///

/// Container for the necessary parameters to execute the GetLoadBalancers service method. /// /// The response from the GetLoadBalancers service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetLoadBalancers Operation public virtual GetLoadBalancersResponse GetLoadBalancers(GetLoadBalancersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetLoadBalancersRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLoadBalancersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetLoadBalancers operation. ///

/// /// Container for the necessary parameters to execute the GetLoadBalancers operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetLoadBalancers /// operation. /// REST API Reference for GetLoadBalancers Operation public virtual IAsyncResult BeginGetLoadBalancers(GetLoadBalancersRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetLoadBalancersRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLoadBalancersResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetLoadBalancers operation. ///

/// /// The IAsyncResult returned by the call to BeginGetLoadBalancers. /// /// Returns a GetLoadBalancersResult from Lightsail. /// REST API Reference for GetLoadBalancers Operation public virtual GetLoadBalancersResponse EndGetLoadBalancers(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetLoadBalancerTlsCertificates ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetLoadBalancerTlsCertificates service method. /// /// The response from the GetLoadBalancerTlsCertificates service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetLoadBalancerTlsCertificates Operation public virtual GetLoadBalancerTlsCertificatesResponse GetLoadBalancerTlsCertificates(GetLoadBalancerTlsCertificatesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetLoadBalancerTlsCertificatesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLoadBalancerTlsCertificatesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetLoadBalancerTlsCertificates operation. ///

/// /// Container for the necessary parameters to execute the GetLoadBalancerTlsCertificates operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetLoadBalancerTlsCertificates /// operation. /// REST API Reference for GetLoadBalancerTlsCertificates Operation public virtual IAsyncResult BeginGetLoadBalancerTlsCertificates(GetLoadBalancerTlsCertificatesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetLoadBalancerTlsCertificatesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLoadBalancerTlsCertificatesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetLoadBalancerTlsCertificates operation. ///

/// /// The IAsyncResult returned by the call to BeginGetLoadBalancerTlsCertificates. /// /// Returns a GetLoadBalancerTlsCertificatesResult from Lightsail. /// REST API Reference for GetLoadBalancerTlsCertificates Operation public virtual GetLoadBalancerTlsCertificatesResponse EndGetLoadBalancerTlsCertificates(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetLoadBalancerTlsPolicies ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetLoadBalancerTlsPolicies service method. /// /// The response from the GetLoadBalancerTlsPolicies service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetLoadBalancerTlsPolicies Operation public virtual GetLoadBalancerTlsPoliciesResponse GetLoadBalancerTlsPolicies(GetLoadBalancerTlsPoliciesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetLoadBalancerTlsPoliciesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLoadBalancerTlsPoliciesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetLoadBalancerTlsPolicies operation. ///

/// /// Container for the necessary parameters to execute the GetLoadBalancerTlsPolicies operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetLoadBalancerTlsPolicies /// operation. /// REST API Reference for GetLoadBalancerTlsPolicies Operation public virtual IAsyncResult BeginGetLoadBalancerTlsPolicies(GetLoadBalancerTlsPoliciesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetLoadBalancerTlsPoliciesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLoadBalancerTlsPoliciesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetLoadBalancerTlsPolicies operation. ///

/// /// The IAsyncResult returned by the call to BeginGetLoadBalancerTlsPolicies. /// /// Returns a GetLoadBalancerTlsPoliciesResult from Lightsail. /// REST API Reference for GetLoadBalancerTlsPolicies Operation public virtual GetLoadBalancerTlsPoliciesResponse EndGetLoadBalancerTlsPolicies(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetOperation ///

/// 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. ///

/// Container for the necessary parameters to execute the GetOperation service method. /// /// The response from the GetOperation service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetOperation Operation public virtual GetOperationResponse GetOperation(GetOperationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetOperationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetOperationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetOperation operation. ///

/// /// Container for the necessary parameters to execute the GetOperation operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetOperation /// operation. /// REST API Reference for GetOperation Operation public virtual IAsyncResult BeginGetOperation(GetOperationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetOperationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetOperationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetOperation operation. ///

/// /// The IAsyncResult returned by the call to BeginGetOperation. /// /// Returns a GetOperationResult from Lightsail. /// REST API Reference for GetOperation Operation public virtual GetOperationResponse EndGetOperation(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetOperations ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetOperations service method. /// /// The response from the GetOperations service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetOperations Operation public virtual GetOperationsResponse GetOperations(GetOperationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetOperationsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetOperationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetOperations operation. ///

/// /// Container for the necessary parameters to execute the GetOperations operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetOperations /// operation. /// REST API Reference for GetOperations Operation public virtual IAsyncResult BeginGetOperations(GetOperationsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetOperationsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetOperationsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetOperations operation. ///

/// /// The IAsyncResult returned by the call to BeginGetOperations. /// /// Returns a GetOperationsResult from Lightsail. /// REST API Reference for GetOperations Operation public virtual GetOperationsResponse EndGetOperations(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetOperationsForResource ///

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

/// Container for the necessary parameters to execute the GetOperationsForResource service method. /// /// The response from the GetOperationsForResource service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetOperationsForResource Operation public virtual GetOperationsForResourceResponse GetOperationsForResource(GetOperationsForResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetOperationsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = GetOperationsForResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetOperationsForResource operation. ///

/// /// Container for the necessary parameters to execute the GetOperationsForResource operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetOperationsForResource /// operation. /// REST API Reference for GetOperationsForResource Operation public virtual IAsyncResult BeginGetOperationsForResource(GetOperationsForResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetOperationsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = GetOperationsForResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetOperationsForResource operation. ///

/// /// The IAsyncResult returned by the call to BeginGetOperationsForResource. /// /// Returns a GetOperationsForResourceResult from Lightsail. /// REST API Reference for GetOperationsForResource Operation public virtual GetOperationsForResourceResponse EndGetOperationsForResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetRegions ///

/// 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. ///

/// Container for the necessary parameters to execute the GetRegions service method. /// /// The response from the GetRegions service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetRegions Operation public virtual GetRegionsResponse GetRegions(GetRegionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetRegionsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRegionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetRegions operation. ///

/// /// Container for the necessary parameters to execute the GetRegions operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetRegions /// operation. /// REST API Reference for GetRegions Operation public virtual IAsyncResult BeginGetRegions(GetRegionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetRegionsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRegionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetRegions operation. ///

/// /// The IAsyncResult returned by the call to BeginGetRegions. /// /// Returns a GetRegionsResult from Lightsail. /// REST API Reference for GetRegions Operation public virtual GetRegionsResponse EndGetRegions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetRelationalDatabase ///

/// Returns information about a specific database in Amazon Lightsail. ///

/// Container for the necessary parameters to execute the GetRelationalDatabase service method. /// /// The response from the GetRelationalDatabase service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetRelationalDatabase Operation public virtual GetRelationalDatabaseResponse GetRelationalDatabase(GetRelationalDatabaseRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetRelationalDatabase operation. ///

/// /// Container for the necessary parameters to execute the GetRelationalDatabase operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetRelationalDatabase /// operation. /// REST API Reference for GetRelationalDatabase Operation public virtual IAsyncResult BeginGetRelationalDatabase(GetRelationalDatabaseRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetRelationalDatabase operation. ///

/// /// The IAsyncResult returned by the call to BeginGetRelationalDatabase. /// /// Returns a GetRelationalDatabaseResult from Lightsail. /// REST API Reference for GetRelationalDatabase Operation public virtual GetRelationalDatabaseResponse EndGetRelationalDatabase(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetRelationalDatabaseBlueprints ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetRelationalDatabaseBlueprints service method. /// /// The response from the GetRelationalDatabaseBlueprints service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetRelationalDatabaseBlueprints Operation public virtual GetRelationalDatabaseBlueprintsResponse GetRelationalDatabaseBlueprints(GetRelationalDatabaseBlueprintsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseBlueprintsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseBlueprintsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetRelationalDatabaseBlueprints operation. ///

/// /// Container for the necessary parameters to execute the GetRelationalDatabaseBlueprints operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetRelationalDatabaseBlueprints /// operation. /// REST API Reference for GetRelationalDatabaseBlueprints Operation public virtual IAsyncResult BeginGetRelationalDatabaseBlueprints(GetRelationalDatabaseBlueprintsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseBlueprintsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseBlueprintsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetRelationalDatabaseBlueprints operation. ///

/// /// The IAsyncResult returned by the call to BeginGetRelationalDatabaseBlueprints. /// /// Returns a GetRelationalDatabaseBlueprintsResult from Lightsail. /// REST API Reference for GetRelationalDatabaseBlueprints Operation public virtual GetRelationalDatabaseBlueprintsResponse EndGetRelationalDatabaseBlueprints(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetRelationalDatabaseBundles ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetRelationalDatabaseBundles service method. /// /// The response from the GetRelationalDatabaseBundles service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetRelationalDatabaseBundles Operation public virtual GetRelationalDatabaseBundlesResponse GetRelationalDatabaseBundles(GetRelationalDatabaseBundlesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseBundlesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseBundlesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetRelationalDatabaseBundles operation. ///

/// /// Container for the necessary parameters to execute the GetRelationalDatabaseBundles operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetRelationalDatabaseBundles /// operation. /// REST API Reference for GetRelationalDatabaseBundles Operation public virtual IAsyncResult BeginGetRelationalDatabaseBundles(GetRelationalDatabaseBundlesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseBundlesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseBundlesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetRelationalDatabaseBundles operation. ///

/// /// The IAsyncResult returned by the call to BeginGetRelationalDatabaseBundles. /// /// Returns a GetRelationalDatabaseBundlesResult from Lightsail. /// REST API Reference for GetRelationalDatabaseBundles Operation public virtual GetRelationalDatabaseBundlesResponse EndGetRelationalDatabaseBundles(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetRelationalDatabaseEvents ///

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

/// Container for the necessary parameters to execute the GetRelationalDatabaseEvents service method. /// /// The response from the GetRelationalDatabaseEvents service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetRelationalDatabaseEvents Operation public virtual GetRelationalDatabaseEventsResponse GetRelationalDatabaseEvents(GetRelationalDatabaseEventsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseEventsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseEventsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetRelationalDatabaseEvents operation. ///

/// /// Container for the necessary parameters to execute the GetRelationalDatabaseEvents operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetRelationalDatabaseEvents /// operation. /// REST API Reference for GetRelationalDatabaseEvents Operation public virtual IAsyncResult BeginGetRelationalDatabaseEvents(GetRelationalDatabaseEventsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseEventsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseEventsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetRelationalDatabaseEvents operation. ///

/// /// The IAsyncResult returned by the call to BeginGetRelationalDatabaseEvents. /// /// Returns a GetRelationalDatabaseEventsResult from Lightsail. /// REST API Reference for GetRelationalDatabaseEvents Operation public virtual GetRelationalDatabaseEventsResponse EndGetRelationalDatabaseEvents(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetRelationalDatabaseLogEvents ///

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

/// Container for the necessary parameters to execute the GetRelationalDatabaseLogEvents service method. /// /// The response from the GetRelationalDatabaseLogEvents service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetRelationalDatabaseLogEvents Operation public virtual GetRelationalDatabaseLogEventsResponse GetRelationalDatabaseLogEvents(GetRelationalDatabaseLogEventsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseLogEventsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseLogEventsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetRelationalDatabaseLogEvents operation. ///

/// /// Container for the necessary parameters to execute the GetRelationalDatabaseLogEvents operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetRelationalDatabaseLogEvents /// operation. /// REST API Reference for GetRelationalDatabaseLogEvents Operation public virtual IAsyncResult BeginGetRelationalDatabaseLogEvents(GetRelationalDatabaseLogEventsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseLogEventsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseLogEventsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetRelationalDatabaseLogEvents operation. ///

/// /// The IAsyncResult returned by the call to BeginGetRelationalDatabaseLogEvents. /// /// Returns a GetRelationalDatabaseLogEventsResult from Lightsail. /// REST API Reference for GetRelationalDatabaseLogEvents Operation public virtual GetRelationalDatabaseLogEventsResponse EndGetRelationalDatabaseLogEvents(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetRelationalDatabaseLogStreams ///

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

/// Container for the necessary parameters to execute the GetRelationalDatabaseLogStreams service method. /// /// The response from the GetRelationalDatabaseLogStreams service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetRelationalDatabaseLogStreams Operation public virtual GetRelationalDatabaseLogStreamsResponse GetRelationalDatabaseLogStreams(GetRelationalDatabaseLogStreamsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseLogStreamsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseLogStreamsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetRelationalDatabaseLogStreams operation. ///

/// /// Container for the necessary parameters to execute the GetRelationalDatabaseLogStreams operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetRelationalDatabaseLogStreams /// operation. /// REST API Reference for GetRelationalDatabaseLogStreams Operation public virtual IAsyncResult BeginGetRelationalDatabaseLogStreams(GetRelationalDatabaseLogStreamsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseLogStreamsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseLogStreamsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetRelationalDatabaseLogStreams operation. ///

/// /// The IAsyncResult returned by the call to BeginGetRelationalDatabaseLogStreams. /// /// Returns a GetRelationalDatabaseLogStreamsResult from Lightsail. /// REST API Reference for GetRelationalDatabaseLogStreams Operation public virtual GetRelationalDatabaseLogStreamsResponse EndGetRelationalDatabaseLogStreams(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetRelationalDatabaseMasterUserPassword ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetRelationalDatabaseMasterUserPassword service method. /// /// The response from the GetRelationalDatabaseMasterUserPassword service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetRelationalDatabaseMasterUserPassword Operation public virtual GetRelationalDatabaseMasterUserPasswordResponse GetRelationalDatabaseMasterUserPassword(GetRelationalDatabaseMasterUserPasswordRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseMasterUserPasswordRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseMasterUserPasswordResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetRelationalDatabaseMasterUserPassword operation. ///

/// /// Container for the necessary parameters to execute the GetRelationalDatabaseMasterUserPassword operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetRelationalDatabaseMasterUserPassword /// operation. /// REST API Reference for GetRelationalDatabaseMasterUserPassword Operation public virtual IAsyncResult BeginGetRelationalDatabaseMasterUserPassword(GetRelationalDatabaseMasterUserPasswordRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseMasterUserPasswordRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseMasterUserPasswordResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetRelationalDatabaseMasterUserPassword operation. ///

/// /// The IAsyncResult returned by the call to BeginGetRelationalDatabaseMasterUserPassword. /// /// Returns a GetRelationalDatabaseMasterUserPasswordResult from Lightsail. /// REST API Reference for GetRelationalDatabaseMasterUserPassword Operation public virtual GetRelationalDatabaseMasterUserPasswordResponse EndGetRelationalDatabaseMasterUserPassword(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetRelationalDatabaseMetricData ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetRelationalDatabaseMetricData service method. /// /// The response from the GetRelationalDatabaseMetricData service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetRelationalDatabaseMetricData Operation public virtual GetRelationalDatabaseMetricDataResponse GetRelationalDatabaseMetricData(GetRelationalDatabaseMetricDataRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseMetricDataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseMetricDataResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetRelationalDatabaseMetricData operation. ///

/// /// Container for the necessary parameters to execute the GetRelationalDatabaseMetricData operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetRelationalDatabaseMetricData /// operation. /// REST API Reference for GetRelationalDatabaseMetricData Operation public virtual IAsyncResult BeginGetRelationalDatabaseMetricData(GetRelationalDatabaseMetricDataRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseMetricDataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseMetricDataResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetRelationalDatabaseMetricData operation. ///

/// /// The IAsyncResult returned by the call to BeginGetRelationalDatabaseMetricData. /// /// Returns a GetRelationalDatabaseMetricDataResult from Lightsail. /// REST API Reference for GetRelationalDatabaseMetricData Operation public virtual GetRelationalDatabaseMetricDataResponse EndGetRelationalDatabaseMetricData(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetRelationalDatabaseParameters ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetRelationalDatabaseParameters service method. /// /// The response from the GetRelationalDatabaseParameters service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetRelationalDatabaseParameters Operation public virtual GetRelationalDatabaseParametersResponse GetRelationalDatabaseParameters(GetRelationalDatabaseParametersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseParametersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetRelationalDatabaseParameters operation. ///

/// /// Container for the necessary parameters to execute the GetRelationalDatabaseParameters operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetRelationalDatabaseParameters /// operation. /// REST API Reference for GetRelationalDatabaseParameters Operation public virtual IAsyncResult BeginGetRelationalDatabaseParameters(GetRelationalDatabaseParametersRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseParametersResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetRelationalDatabaseParameters operation. ///

/// /// The IAsyncResult returned by the call to BeginGetRelationalDatabaseParameters. /// /// Returns a GetRelationalDatabaseParametersResult from Lightsail. /// REST API Reference for GetRelationalDatabaseParameters Operation public virtual GetRelationalDatabaseParametersResponse EndGetRelationalDatabaseParameters(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetRelationalDatabases ///

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

/// Container for the necessary parameters to execute the GetRelationalDatabases service method. /// /// The response from the GetRelationalDatabases service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetRelationalDatabases Operation public virtual GetRelationalDatabasesResponse GetRelationalDatabases(GetRelationalDatabasesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabasesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabasesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetRelationalDatabases operation. ///

/// /// Container for the necessary parameters to execute the GetRelationalDatabases operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetRelationalDatabases /// operation. /// REST API Reference for GetRelationalDatabases Operation public virtual IAsyncResult BeginGetRelationalDatabases(GetRelationalDatabasesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabasesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabasesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetRelationalDatabases operation. ///

/// /// The IAsyncResult returned by the call to BeginGetRelationalDatabases. /// /// Returns a GetRelationalDatabasesResult from Lightsail. /// REST API Reference for GetRelationalDatabases Operation public virtual GetRelationalDatabasesResponse EndGetRelationalDatabases(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetRelationalDatabaseSnapshot ///

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

/// Container for the necessary parameters to execute the GetRelationalDatabaseSnapshot service method. /// /// The response from the GetRelationalDatabaseSnapshot service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetRelationalDatabaseSnapshot Operation public virtual GetRelationalDatabaseSnapshotResponse GetRelationalDatabaseSnapshot(GetRelationalDatabaseSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetRelationalDatabaseSnapshot operation. ///

/// /// Container for the necessary parameters to execute the GetRelationalDatabaseSnapshot operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetRelationalDatabaseSnapshot /// operation. /// REST API Reference for GetRelationalDatabaseSnapshot Operation public virtual IAsyncResult BeginGetRelationalDatabaseSnapshot(GetRelationalDatabaseSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetRelationalDatabaseSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginGetRelationalDatabaseSnapshot. /// /// Returns a GetRelationalDatabaseSnapshotResult from Lightsail. /// REST API Reference for GetRelationalDatabaseSnapshot Operation public virtual GetRelationalDatabaseSnapshotResponse EndGetRelationalDatabaseSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetRelationalDatabaseSnapshots ///

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

/// Container for the necessary parameters to execute the GetRelationalDatabaseSnapshots service method. /// /// The response from the GetRelationalDatabaseSnapshots service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetRelationalDatabaseSnapshots Operation public virtual GetRelationalDatabaseSnapshotsResponse GetRelationalDatabaseSnapshots(GetRelationalDatabaseSnapshotsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseSnapshotsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetRelationalDatabaseSnapshots operation. ///

/// /// Container for the necessary parameters to execute the GetRelationalDatabaseSnapshots operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetRelationalDatabaseSnapshots /// operation. /// REST API Reference for GetRelationalDatabaseSnapshots Operation public virtual IAsyncResult BeginGetRelationalDatabaseSnapshots(GetRelationalDatabaseSnapshotsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetRelationalDatabaseSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRelationalDatabaseSnapshotsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetRelationalDatabaseSnapshots operation. ///

/// /// The IAsyncResult returned by the call to BeginGetRelationalDatabaseSnapshots. /// /// Returns a GetRelationalDatabaseSnapshotsResult from Lightsail. /// REST API Reference for GetRelationalDatabaseSnapshots Operation public virtual GetRelationalDatabaseSnapshotsResponse EndGetRelationalDatabaseSnapshots(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetStaticIp ///

/// Returns information about an Amazon Lightsail static IP. ///

/// Container for the necessary parameters to execute the GetStaticIp service method. /// /// The response from the GetStaticIp service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetStaticIp Operation public virtual GetStaticIpResponse GetStaticIp(GetStaticIpRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetStaticIpRequestMarshaller.Instance; options.ResponseUnmarshaller = GetStaticIpResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetStaticIp operation. ///

/// /// Container for the necessary parameters to execute the GetStaticIp operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetStaticIp /// operation. /// REST API Reference for GetStaticIp Operation public virtual IAsyncResult BeginGetStaticIp(GetStaticIpRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetStaticIpRequestMarshaller.Instance; options.ResponseUnmarshaller = GetStaticIpResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetStaticIp operation. ///

/// /// The IAsyncResult returned by the call to BeginGetStaticIp. /// /// Returns a GetStaticIpResult from Lightsail. /// REST API Reference for GetStaticIp Operation public virtual GetStaticIpResponse EndGetStaticIp(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetStaticIps ///

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

/// Container for the necessary parameters to execute the GetStaticIps service method. /// /// The response from the GetStaticIps service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for GetStaticIps Operation public virtual GetStaticIpsResponse GetStaticIps(GetStaticIpsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetStaticIpsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetStaticIpsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetStaticIps operation. ///

/// /// Container for the necessary parameters to execute the GetStaticIps operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetStaticIps /// operation. /// REST API Reference for GetStaticIps Operation public virtual IAsyncResult BeginGetStaticIps(GetStaticIpsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetStaticIpsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetStaticIpsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetStaticIps operation. ///

/// /// The IAsyncResult returned by the call to BeginGetStaticIps. /// /// Returns a GetStaticIpsResult from Lightsail. /// REST API Reference for GetStaticIps Operation public virtual GetStaticIpsResponse EndGetStaticIps(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ImportKeyPair ///

/// Imports a public SSH key from a specific key pair. ///

/// Container for the necessary parameters to execute the ImportKeyPair service method. /// /// The response from the ImportKeyPair service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for ImportKeyPair Operation public virtual ImportKeyPairResponse ImportKeyPair(ImportKeyPairRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ImportKeyPairRequestMarshaller.Instance; options.ResponseUnmarshaller = ImportKeyPairResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ImportKeyPair operation. ///

/// /// Container for the necessary parameters to execute the ImportKeyPair operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndImportKeyPair /// operation. /// REST API Reference for ImportKeyPair Operation public virtual IAsyncResult BeginImportKeyPair(ImportKeyPairRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ImportKeyPairRequestMarshaller.Instance; options.ResponseUnmarshaller = ImportKeyPairResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ImportKeyPair operation. ///

/// /// The IAsyncResult returned by the call to BeginImportKeyPair. /// /// Returns a ImportKeyPairResult from Lightsail. /// REST API Reference for ImportKeyPair Operation public virtual ImportKeyPairResponse EndImportKeyPair(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region IsVpcPeered ///

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

/// Container for the necessary parameters to execute the IsVpcPeered service method. /// /// The response from the IsVpcPeered service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for IsVpcPeered Operation public virtual IsVpcPeeredResponse IsVpcPeered(IsVpcPeeredRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = IsVpcPeeredRequestMarshaller.Instance; options.ResponseUnmarshaller = IsVpcPeeredResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the IsVpcPeered operation. ///

/// /// Container for the necessary parameters to execute the IsVpcPeered operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndIsVpcPeered /// operation. /// REST API Reference for IsVpcPeered Operation public virtual IAsyncResult BeginIsVpcPeered(IsVpcPeeredRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = IsVpcPeeredRequestMarshaller.Instance; options.ResponseUnmarshaller = IsVpcPeeredResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the IsVpcPeered operation. ///

/// /// The IAsyncResult returned by the call to BeginIsVpcPeered. /// /// Returns a IsVpcPeeredResult from Lightsail. /// REST API Reference for IsVpcPeered Operation public virtual IsVpcPeeredResponse EndIsVpcPeered(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region OpenInstancePublicPorts ///

/// 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. /// ///

/// Container for the necessary parameters to execute the OpenInstancePublicPorts service method. /// /// The response from the OpenInstancePublicPorts service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for OpenInstancePublicPorts Operation public virtual OpenInstancePublicPortsResponse OpenInstancePublicPorts(OpenInstancePublicPortsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = OpenInstancePublicPortsRequestMarshaller.Instance; options.ResponseUnmarshaller = OpenInstancePublicPortsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the OpenInstancePublicPorts operation. ///

/// /// Container for the necessary parameters to execute the OpenInstancePublicPorts operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndOpenInstancePublicPorts /// operation. /// REST API Reference for OpenInstancePublicPorts Operation public virtual IAsyncResult BeginOpenInstancePublicPorts(OpenInstancePublicPortsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = OpenInstancePublicPortsRequestMarshaller.Instance; options.ResponseUnmarshaller = OpenInstancePublicPortsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the OpenInstancePublicPorts operation. ///

/// /// The IAsyncResult returned by the call to BeginOpenInstancePublicPorts. /// /// Returns a OpenInstancePublicPortsResult from Lightsail. /// REST API Reference for OpenInstancePublicPorts Operation public virtual OpenInstancePublicPortsResponse EndOpenInstancePublicPorts(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region PeerVpc ///

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

/// Container for the necessary parameters to execute the PeerVpc service method. /// /// The response from the PeerVpc service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for PeerVpc Operation public virtual PeerVpcResponse PeerVpc(PeerVpcRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PeerVpcRequestMarshaller.Instance; options.ResponseUnmarshaller = PeerVpcResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the PeerVpc operation. ///

/// /// Container for the necessary parameters to execute the PeerVpc operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPeerVpc /// operation. /// REST API Reference for PeerVpc Operation public virtual IAsyncResult BeginPeerVpc(PeerVpcRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = PeerVpcRequestMarshaller.Instance; options.ResponseUnmarshaller = PeerVpcResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the PeerVpc operation. ///

/// /// The IAsyncResult returned by the call to BeginPeerVpc. /// /// Returns a PeerVpcResult from Lightsail. /// REST API Reference for PeerVpc Operation public virtual PeerVpcResponse EndPeerVpc(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region PutAlarm ///

/// 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. /// ///

/// Container for the necessary parameters to execute the PutAlarm service method. /// /// The response from the PutAlarm service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for PutAlarm Operation public virtual PutAlarmResponse PutAlarm(PutAlarmRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PutAlarmRequestMarshaller.Instance; options.ResponseUnmarshaller = PutAlarmResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the PutAlarm operation. ///

/// /// Container for the necessary parameters to execute the PutAlarm operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPutAlarm /// operation. /// REST API Reference for PutAlarm Operation public virtual IAsyncResult BeginPutAlarm(PutAlarmRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = PutAlarmRequestMarshaller.Instance; options.ResponseUnmarshaller = PutAlarmResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the PutAlarm operation. ///

/// /// The IAsyncResult returned by the call to BeginPutAlarm. /// /// Returns a PutAlarmResult from Lightsail. /// REST API Reference for PutAlarm Operation public virtual PutAlarmResponse EndPutAlarm(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region PutInstancePublicPorts ///

/// 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. /// ///

/// Container for the necessary parameters to execute the PutInstancePublicPorts service method. /// /// The response from the PutInstancePublicPorts service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for PutInstancePublicPorts Operation public virtual PutInstancePublicPortsResponse PutInstancePublicPorts(PutInstancePublicPortsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PutInstancePublicPortsRequestMarshaller.Instance; options.ResponseUnmarshaller = PutInstancePublicPortsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the PutInstancePublicPorts operation. ///

/// /// Container for the necessary parameters to execute the PutInstancePublicPorts operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPutInstancePublicPorts /// operation. /// REST API Reference for PutInstancePublicPorts Operation public virtual IAsyncResult BeginPutInstancePublicPorts(PutInstancePublicPortsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = PutInstancePublicPortsRequestMarshaller.Instance; options.ResponseUnmarshaller = PutInstancePublicPortsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the PutInstancePublicPorts operation. ///

/// /// The IAsyncResult returned by the call to BeginPutInstancePublicPorts. /// /// Returns a PutInstancePublicPortsResult from Lightsail. /// REST API Reference for PutInstancePublicPorts Operation public virtual PutInstancePublicPortsResponse EndPutInstancePublicPorts(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RebootInstance ///

/// 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. /// ///

/// Container for the necessary parameters to execute the RebootInstance service method. /// /// The response from the RebootInstance service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for RebootInstance Operation public virtual RebootInstanceResponse RebootInstance(RebootInstanceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RebootInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = RebootInstanceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RebootInstance operation. ///

/// /// Container for the necessary parameters to execute the RebootInstance operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRebootInstance /// operation. /// REST API Reference for RebootInstance Operation public virtual IAsyncResult BeginRebootInstance(RebootInstanceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RebootInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = RebootInstanceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RebootInstance operation. ///

/// /// The IAsyncResult returned by the call to BeginRebootInstance. /// /// Returns a RebootInstanceResult from Lightsail. /// REST API Reference for RebootInstance Operation public virtual RebootInstanceResponse EndRebootInstance(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RebootRelationalDatabase ///

/// 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. /// ///

/// Container for the necessary parameters to execute the RebootRelationalDatabase service method. /// /// The response from the RebootRelationalDatabase service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for RebootRelationalDatabase Operation public virtual RebootRelationalDatabaseResponse RebootRelationalDatabase(RebootRelationalDatabaseRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RebootRelationalDatabaseRequestMarshaller.Instance; options.ResponseUnmarshaller = RebootRelationalDatabaseResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RebootRelationalDatabase operation. ///

/// /// Container for the necessary parameters to execute the RebootRelationalDatabase operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRebootRelationalDatabase /// operation. /// REST API Reference for RebootRelationalDatabase Operation public virtual IAsyncResult BeginRebootRelationalDatabase(RebootRelationalDatabaseRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RebootRelationalDatabaseRequestMarshaller.Instance; options.ResponseUnmarshaller = RebootRelationalDatabaseResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RebootRelationalDatabase operation. ///

/// /// The IAsyncResult returned by the call to BeginRebootRelationalDatabase. /// /// Returns a RebootRelationalDatabaseResult from Lightsail. /// REST API Reference for RebootRelationalDatabase Operation public virtual RebootRelationalDatabaseResponse EndRebootRelationalDatabase(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RegisterContainerImage ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the RegisterContainerImage service method. /// /// The response from the RegisterContainerImage service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for RegisterContainerImage Operation public virtual RegisterContainerImageResponse RegisterContainerImage(RegisterContainerImageRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterContainerImageRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterContainerImageResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RegisterContainerImage operation. ///

/// /// Container for the necessary parameters to execute the RegisterContainerImage operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRegisterContainerImage /// operation. /// REST API Reference for RegisterContainerImage Operation public virtual IAsyncResult BeginRegisterContainerImage(RegisterContainerImageRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterContainerImageRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterContainerImageResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RegisterContainerImage operation. ///

/// /// The IAsyncResult returned by the call to BeginRegisterContainerImage. /// /// Returns a RegisterContainerImageResult from Lightsail. /// REST API Reference for RegisterContainerImage Operation public virtual RegisterContainerImageResponse EndRegisterContainerImage(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ReleaseStaticIp ///

/// Deletes a specific static IP from your account. ///

/// Container for the necessary parameters to execute the ReleaseStaticIp service method. /// /// The response from the ReleaseStaticIp service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for ReleaseStaticIp Operation public virtual ReleaseStaticIpResponse ReleaseStaticIp(ReleaseStaticIpRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ReleaseStaticIpRequestMarshaller.Instance; options.ResponseUnmarshaller = ReleaseStaticIpResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ReleaseStaticIp operation. ///

/// /// Container for the necessary parameters to execute the ReleaseStaticIp operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndReleaseStaticIp /// operation. /// REST API Reference for ReleaseStaticIp Operation public virtual IAsyncResult BeginReleaseStaticIp(ReleaseStaticIpRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ReleaseStaticIpRequestMarshaller.Instance; options.ResponseUnmarshaller = ReleaseStaticIpResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ReleaseStaticIp operation. ///

/// /// The IAsyncResult returned by the call to BeginReleaseStaticIp. /// /// Returns a ReleaseStaticIpResult from Lightsail. /// REST API Reference for ReleaseStaticIp Operation public virtual ReleaseStaticIpResponse EndReleaseStaticIp(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ResetDistributionCache ///

/// 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. /// ///

/// Container for the necessary parameters to execute the ResetDistributionCache service method. /// /// The response from the ResetDistributionCache service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for ResetDistributionCache Operation public virtual ResetDistributionCacheResponse ResetDistributionCache(ResetDistributionCacheRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ResetDistributionCacheRequestMarshaller.Instance; options.ResponseUnmarshaller = ResetDistributionCacheResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ResetDistributionCache operation. ///

/// /// Container for the necessary parameters to execute the ResetDistributionCache operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndResetDistributionCache /// operation. /// REST API Reference for ResetDistributionCache Operation public virtual IAsyncResult BeginResetDistributionCache(ResetDistributionCacheRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ResetDistributionCacheRequestMarshaller.Instance; options.ResponseUnmarshaller = ResetDistributionCacheResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ResetDistributionCache operation. ///

/// /// The IAsyncResult returned by the call to BeginResetDistributionCache. /// /// Returns a ResetDistributionCacheResult from Lightsail. /// REST API Reference for ResetDistributionCache Operation public virtual ResetDistributionCacheResponse EndResetDistributionCache(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region SendContactMethodVerification ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the SendContactMethodVerification service method. /// /// The response from the SendContactMethodVerification service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for SendContactMethodVerification Operation public virtual SendContactMethodVerificationResponse SendContactMethodVerification(SendContactMethodVerificationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = SendContactMethodVerificationRequestMarshaller.Instance; options.ResponseUnmarshaller = SendContactMethodVerificationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the SendContactMethodVerification operation. ///

/// /// Container for the necessary parameters to execute the SendContactMethodVerification operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSendContactMethodVerification /// operation. /// REST API Reference for SendContactMethodVerification Operation public virtual IAsyncResult BeginSendContactMethodVerification(SendContactMethodVerificationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = SendContactMethodVerificationRequestMarshaller.Instance; options.ResponseUnmarshaller = SendContactMethodVerificationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the SendContactMethodVerification operation. ///

/// /// The IAsyncResult returned by the call to BeginSendContactMethodVerification. /// /// Returns a SendContactMethodVerificationResult from Lightsail. /// REST API Reference for SendContactMethodVerification Operation public virtual SendContactMethodVerificationResponse EndSendContactMethodVerification(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region SetIpAddressType ///

/// 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. /// ///

/// Container for the necessary parameters to execute the SetIpAddressType service method. /// /// The response from the SetIpAddressType service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for SetIpAddressType Operation public virtual SetIpAddressTypeResponse SetIpAddressType(SetIpAddressTypeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = SetIpAddressTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = SetIpAddressTypeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the SetIpAddressType operation. ///

/// /// Container for the necessary parameters to execute the SetIpAddressType operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSetIpAddressType /// operation. /// REST API Reference for SetIpAddressType Operation public virtual IAsyncResult BeginSetIpAddressType(SetIpAddressTypeRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = SetIpAddressTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = SetIpAddressTypeResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the SetIpAddressType operation. ///

/// /// The IAsyncResult returned by the call to BeginSetIpAddressType. /// /// Returns a SetIpAddressTypeResult from Lightsail. /// REST API Reference for SetIpAddressType Operation public virtual SetIpAddressTypeResponse EndSetIpAddressType(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region SetResourceAccessForBucket ///

/// 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. /// ///

/// Container for the necessary parameters to execute the SetResourceAccessForBucket service method. /// /// The response from the SetResourceAccessForBucket service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for SetResourceAccessForBucket Operation public virtual SetResourceAccessForBucketResponse SetResourceAccessForBucket(SetResourceAccessForBucketRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = SetResourceAccessForBucketRequestMarshaller.Instance; options.ResponseUnmarshaller = SetResourceAccessForBucketResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the SetResourceAccessForBucket operation. ///

/// /// Container for the necessary parameters to execute the SetResourceAccessForBucket operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSetResourceAccessForBucket /// operation. /// REST API Reference for SetResourceAccessForBucket Operation public virtual IAsyncResult BeginSetResourceAccessForBucket(SetResourceAccessForBucketRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = SetResourceAccessForBucketRequestMarshaller.Instance; options.ResponseUnmarshaller = SetResourceAccessForBucketResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the SetResourceAccessForBucket operation. ///

/// /// The IAsyncResult returned by the call to BeginSetResourceAccessForBucket. /// /// Returns a SetResourceAccessForBucketResult from Lightsail. /// REST API Reference for SetResourceAccessForBucket Operation public virtual SetResourceAccessForBucketResponse EndSetResourceAccessForBucket(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartGUISession ///

/// 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. ///

/// Container for the necessary parameters to execute the StartGUISession service method. /// /// The response from the StartGUISession service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for StartGUISession Operation public virtual StartGUISessionResponse StartGUISession(StartGUISessionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartGUISessionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartGUISessionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartGUISession operation. ///

/// /// Container for the necessary parameters to execute the StartGUISession operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartGUISession /// operation. /// REST API Reference for StartGUISession Operation public virtual IAsyncResult BeginStartGUISession(StartGUISessionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartGUISessionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartGUISessionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartGUISession operation. ///

/// /// The IAsyncResult returned by the call to BeginStartGUISession. /// /// Returns a StartGUISessionResult from Lightsail. /// REST API Reference for StartGUISession Operation public virtual StartGUISessionResponse EndStartGUISession(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartInstance ///

/// 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. /// ///

/// Container for the necessary parameters to execute the StartInstance service method. /// /// The response from the StartInstance service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for StartInstance Operation public virtual StartInstanceResponse StartInstance(StartInstanceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = StartInstanceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartInstance operation. ///

/// /// Container for the necessary parameters to execute the StartInstance operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartInstance /// operation. /// REST API Reference for StartInstance Operation public virtual IAsyncResult BeginStartInstance(StartInstanceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = StartInstanceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartInstance operation. ///

/// /// The IAsyncResult returned by the call to BeginStartInstance. /// /// Returns a StartInstanceResult from Lightsail. /// REST API Reference for StartInstance Operation public virtual StartInstanceResponse EndStartInstance(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartRelationalDatabase ///

/// 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. /// ///

/// Container for the necessary parameters to execute the StartRelationalDatabase service method. /// /// The response from the StartRelationalDatabase service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for StartRelationalDatabase Operation public virtual StartRelationalDatabaseResponse StartRelationalDatabase(StartRelationalDatabaseRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartRelationalDatabaseRequestMarshaller.Instance; options.ResponseUnmarshaller = StartRelationalDatabaseResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartRelationalDatabase operation. ///

/// /// Container for the necessary parameters to execute the StartRelationalDatabase operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartRelationalDatabase /// operation. /// REST API Reference for StartRelationalDatabase Operation public virtual IAsyncResult BeginStartRelationalDatabase(StartRelationalDatabaseRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartRelationalDatabaseRequestMarshaller.Instance; options.ResponseUnmarshaller = StartRelationalDatabaseResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartRelationalDatabase operation. ///

/// /// The IAsyncResult returned by the call to BeginStartRelationalDatabase. /// /// Returns a StartRelationalDatabaseResult from Lightsail. /// REST API Reference for StartRelationalDatabase Operation public virtual StartRelationalDatabaseResponse EndStartRelationalDatabase(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StopGUISession ///

/// 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. ///

/// Container for the necessary parameters to execute the StopGUISession service method. /// /// The response from the StopGUISession service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for StopGUISession Operation public virtual StopGUISessionResponse StopGUISession(StopGUISessionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StopGUISessionRequestMarshaller.Instance; options.ResponseUnmarshaller = StopGUISessionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StopGUISession operation. ///

/// /// Container for the necessary parameters to execute the StopGUISession operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStopGUISession /// operation. /// REST API Reference for StopGUISession Operation public virtual IAsyncResult BeginStopGUISession(StopGUISessionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StopGUISessionRequestMarshaller.Instance; options.ResponseUnmarshaller = StopGUISessionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StopGUISession operation. ///

/// /// The IAsyncResult returned by the call to BeginStopGUISession. /// /// Returns a StopGUISessionResult from Lightsail. /// REST API Reference for StopGUISession Operation public virtual StopGUISessionResponse EndStopGUISession(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StopInstance ///

/// 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. /// ///

/// Container for the necessary parameters to execute the StopInstance service method. /// /// The response from the StopInstance service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for StopInstance Operation public virtual StopInstanceResponse StopInstance(StopInstanceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StopInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = StopInstanceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StopInstance operation. ///

/// /// Container for the necessary parameters to execute the StopInstance operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStopInstance /// operation. /// REST API Reference for StopInstance Operation public virtual IAsyncResult BeginStopInstance(StopInstanceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StopInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = StopInstanceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StopInstance operation. ///

/// /// The IAsyncResult returned by the call to BeginStopInstance. /// /// Returns a StopInstanceResult from Lightsail. /// REST API Reference for StopInstance Operation public virtual StopInstanceResponse EndStopInstance(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StopRelationalDatabase ///

/// 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. /// ///

/// Container for the necessary parameters to execute the StopRelationalDatabase service method. /// /// The response from the StopRelationalDatabase service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for StopRelationalDatabase Operation public virtual StopRelationalDatabaseResponse StopRelationalDatabase(StopRelationalDatabaseRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StopRelationalDatabaseRequestMarshaller.Instance; options.ResponseUnmarshaller = StopRelationalDatabaseResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StopRelationalDatabase operation. ///

/// /// Container for the necessary parameters to execute the StopRelationalDatabase operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStopRelationalDatabase /// operation. /// REST API Reference for StopRelationalDatabase Operation public virtual IAsyncResult BeginStopRelationalDatabase(StopRelationalDatabaseRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StopRelationalDatabaseRequestMarshaller.Instance; options.ResponseUnmarshaller = StopRelationalDatabaseResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StopRelationalDatabase operation. ///

/// /// The IAsyncResult returned by the call to BeginStopRelationalDatabase. /// /// Returns a StopRelationalDatabaseResult from Lightsail. /// REST API Reference for StopRelationalDatabase Operation public virtual StopRelationalDatabaseResponse EndStopRelationalDatabase(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region TagResource ///

/// 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. /// ///

/// Container for the necessary parameters to execute the TagResource service method. /// /// The response from the TagResource service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for TagResource Operation public virtual TagResourceResponse TagResource(TagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = TagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the TagResource operation. ///

/// /// Container for the necessary parameters to execute the TagResource operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndTagResource /// operation. /// REST API Reference for TagResource Operation public virtual IAsyncResult BeginTagResource(TagResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = TagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the TagResource operation. ///

/// /// The IAsyncResult returned by the call to BeginTagResource. /// /// Returns a TagResourceResult from Lightsail. /// REST API Reference for TagResource Operation public virtual TagResourceResponse EndTagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region TestAlarm ///

/// 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. /// ///

/// Container for the necessary parameters to execute the TestAlarm service method. /// /// The response from the TestAlarm service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for TestAlarm Operation public virtual TestAlarmResponse TestAlarm(TestAlarmRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = TestAlarmRequestMarshaller.Instance; options.ResponseUnmarshaller = TestAlarmResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the TestAlarm operation. ///

/// /// Container for the necessary parameters to execute the TestAlarm operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndTestAlarm /// operation. /// REST API Reference for TestAlarm Operation public virtual IAsyncResult BeginTestAlarm(TestAlarmRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = TestAlarmRequestMarshaller.Instance; options.ResponseUnmarshaller = TestAlarmResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the TestAlarm operation. ///

/// /// The IAsyncResult returned by the call to BeginTestAlarm. /// /// Returns a TestAlarmResult from Lightsail. /// REST API Reference for TestAlarm Operation public virtual TestAlarmResponse EndTestAlarm(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UnpeerVpc ///

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

/// Container for the necessary parameters to execute the UnpeerVpc service method. /// /// The response from the UnpeerVpc service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for UnpeerVpc Operation public virtual UnpeerVpcResponse UnpeerVpc(UnpeerVpcRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UnpeerVpcRequestMarshaller.Instance; options.ResponseUnmarshaller = UnpeerVpcResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UnpeerVpc operation. ///

/// /// Container for the necessary parameters to execute the UnpeerVpc operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUnpeerVpc /// operation. /// REST API Reference for UnpeerVpc Operation public virtual IAsyncResult BeginUnpeerVpc(UnpeerVpcRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UnpeerVpcRequestMarshaller.Instance; options.ResponseUnmarshaller = UnpeerVpcResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UnpeerVpc operation. ///

/// /// The IAsyncResult returned by the call to BeginUnpeerVpc. /// /// Returns a UnpeerVpcResult from Lightsail. /// REST API Reference for UnpeerVpc Operation public virtual UnpeerVpcResponse EndUnpeerVpc(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UntagResource ///

/// 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. /// ///

/// Container for the necessary parameters to execute the UntagResource service method. /// /// The response from the UntagResource service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for UntagResource Operation public virtual UntagResourceResponse UntagResource(UntagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UntagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UntagResource operation. ///

/// /// Container for the necessary parameters to execute the UntagResource operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUntagResource /// operation. /// REST API Reference for UntagResource Operation public virtual IAsyncResult BeginUntagResource(UntagResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UntagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UntagResource operation. ///

/// /// The IAsyncResult returned by the call to BeginUntagResource. /// /// Returns a UntagResourceResult from Lightsail. /// REST API Reference for UntagResource Operation public virtual UntagResourceResponse EndUntagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateBucket ///

/// 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. /// ///

/// Container for the necessary parameters to execute the UpdateBucket service method. /// /// The response from the UpdateBucket service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for UpdateBucket Operation public virtual UpdateBucketResponse UpdateBucket(UpdateBucketRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateBucketRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateBucketResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateBucket operation. ///

/// /// Container for the necessary parameters to execute the UpdateBucket operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateBucket /// operation. /// REST API Reference for UpdateBucket Operation public virtual IAsyncResult BeginUpdateBucket(UpdateBucketRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateBucketRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateBucketResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateBucket operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateBucket. /// /// Returns a UpdateBucketResult from Lightsail. /// REST API Reference for UpdateBucket Operation public virtual UpdateBucketResponse EndUpdateBucket(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateBucketBundle ///

/// 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. /// ///

/// Container for the necessary parameters to execute the UpdateBucketBundle service method. /// /// The response from the UpdateBucketBundle service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for UpdateBucketBundle Operation public virtual UpdateBucketBundleResponse UpdateBucketBundle(UpdateBucketBundleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateBucketBundleRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateBucketBundleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateBucketBundle operation. ///

/// /// Container for the necessary parameters to execute the UpdateBucketBundle operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateBucketBundle /// operation. /// REST API Reference for UpdateBucketBundle Operation public virtual IAsyncResult BeginUpdateBucketBundle(UpdateBucketBundleRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateBucketBundleRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateBucketBundleResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateBucketBundle operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateBucketBundle. /// /// Returns a UpdateBucketBundleResult from Lightsail. /// REST API Reference for UpdateBucketBundle Operation public virtual UpdateBucketBundleResponse EndUpdateBucketBundle(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateContainerService ///

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

/// Container for the necessary parameters to execute the UpdateContainerService service method. /// /// The response from the UpdateContainerService service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for UpdateContainerService Operation public virtual UpdateContainerServiceResponse UpdateContainerService(UpdateContainerServiceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateContainerServiceRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateContainerServiceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateContainerService operation. ///

/// /// Container for the necessary parameters to execute the UpdateContainerService operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateContainerService /// operation. /// REST API Reference for UpdateContainerService Operation public virtual IAsyncResult BeginUpdateContainerService(UpdateContainerServiceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateContainerServiceRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateContainerServiceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateContainerService operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateContainerService. /// /// Returns a UpdateContainerServiceResult from Lightsail. /// REST API Reference for UpdateContainerService Operation public virtual UpdateContainerServiceResponse EndUpdateContainerService(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateDistribution ///

/// Updates an existing Amazon Lightsail content delivery network (CDN) distribution. /// /// /// /// Use this action to update the configuration of your existing distribution. /// ///

/// Container for the necessary parameters to execute the UpdateDistribution service method. /// /// The response from the UpdateDistribution service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for UpdateDistribution Operation public virtual UpdateDistributionResponse UpdateDistribution(UpdateDistributionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDistributionRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDistributionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateDistribution operation. ///

/// /// Container for the necessary parameters to execute the UpdateDistribution operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateDistribution /// operation. /// REST API Reference for UpdateDistribution Operation public virtual IAsyncResult BeginUpdateDistribution(UpdateDistributionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDistributionRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDistributionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateDistribution operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateDistribution. /// /// Returns a UpdateDistributionResult from Lightsail. /// REST API Reference for UpdateDistribution Operation public virtual UpdateDistributionResponse EndUpdateDistribution(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateDistributionBundle ///

/// 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. /// ///

/// Container for the necessary parameters to execute the UpdateDistributionBundle service method. /// /// The response from the UpdateDistributionBundle service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for UpdateDistributionBundle Operation public virtual UpdateDistributionBundleResponse UpdateDistributionBundle(UpdateDistributionBundleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDistributionBundleRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDistributionBundleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateDistributionBundle operation. ///

/// /// Container for the necessary parameters to execute the UpdateDistributionBundle operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateDistributionBundle /// operation. /// REST API Reference for UpdateDistributionBundle Operation public virtual IAsyncResult BeginUpdateDistributionBundle(UpdateDistributionBundleRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDistributionBundleRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDistributionBundleResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateDistributionBundle operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateDistributionBundle. /// /// Returns a UpdateDistributionBundleResult from Lightsail. /// REST API Reference for UpdateDistributionBundle Operation public virtual UpdateDistributionBundleResponse EndUpdateDistributionBundle(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateDomainEntry ///

/// 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. /// ///

/// Container for the necessary parameters to execute the UpdateDomainEntry service method. /// /// The response from the UpdateDomainEntry service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for UpdateDomainEntry Operation public virtual UpdateDomainEntryResponse UpdateDomainEntry(UpdateDomainEntryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDomainEntryRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDomainEntryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateDomainEntry operation. ///

/// /// Container for the necessary parameters to execute the UpdateDomainEntry operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateDomainEntry /// operation. /// REST API Reference for UpdateDomainEntry Operation public virtual IAsyncResult BeginUpdateDomainEntry(UpdateDomainEntryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDomainEntryRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDomainEntryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateDomainEntry operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateDomainEntry. /// /// Returns a UpdateDomainEntryResult from Lightsail. /// REST API Reference for UpdateDomainEntry Operation public virtual UpdateDomainEntryResponse EndUpdateDomainEntry(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateInstanceMetadataOptions ///

/// 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. ///

/// Container for the necessary parameters to execute the UpdateInstanceMetadataOptions service method. /// /// The response from the UpdateInstanceMetadataOptions service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for UpdateInstanceMetadataOptions Operation public virtual UpdateInstanceMetadataOptionsResponse UpdateInstanceMetadataOptions(UpdateInstanceMetadataOptionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateInstanceMetadataOptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateInstanceMetadataOptionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateInstanceMetadataOptions operation. ///

/// /// Container for the necessary parameters to execute the UpdateInstanceMetadataOptions operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateInstanceMetadataOptions /// operation. /// REST API Reference for UpdateInstanceMetadataOptions Operation public virtual IAsyncResult BeginUpdateInstanceMetadataOptions(UpdateInstanceMetadataOptionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateInstanceMetadataOptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateInstanceMetadataOptionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateInstanceMetadataOptions operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateInstanceMetadataOptions. /// /// Returns a UpdateInstanceMetadataOptionsResult from Lightsail. /// REST API Reference for UpdateInstanceMetadataOptions Operation public virtual UpdateInstanceMetadataOptionsResponse EndUpdateInstanceMetadataOptions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateLoadBalancerAttribute ///

/// 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. /// ///

/// Container for the necessary parameters to execute the UpdateLoadBalancerAttribute service method. /// /// The response from the UpdateLoadBalancerAttribute service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for UpdateLoadBalancerAttribute Operation public virtual UpdateLoadBalancerAttributeResponse UpdateLoadBalancerAttribute(UpdateLoadBalancerAttributeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateLoadBalancerAttributeRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateLoadBalancerAttributeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateLoadBalancerAttribute operation. ///

/// /// Container for the necessary parameters to execute the UpdateLoadBalancerAttribute operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateLoadBalancerAttribute /// operation. /// REST API Reference for UpdateLoadBalancerAttribute Operation public virtual IAsyncResult BeginUpdateLoadBalancerAttribute(UpdateLoadBalancerAttributeRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateLoadBalancerAttributeRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateLoadBalancerAttributeResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateLoadBalancerAttribute operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateLoadBalancerAttribute. /// /// Returns a UpdateLoadBalancerAttributeResult from Lightsail. /// REST API Reference for UpdateLoadBalancerAttribute Operation public virtual UpdateLoadBalancerAttributeResponse EndUpdateLoadBalancerAttribute(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateRelationalDatabase ///

/// 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. /// ///

/// Container for the necessary parameters to execute the UpdateRelationalDatabase service method. /// /// The response from the UpdateRelationalDatabase service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for UpdateRelationalDatabase Operation public virtual UpdateRelationalDatabaseResponse UpdateRelationalDatabase(UpdateRelationalDatabaseRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateRelationalDatabaseRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateRelationalDatabaseResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateRelationalDatabase operation. ///

/// /// Container for the necessary parameters to execute the UpdateRelationalDatabase operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateRelationalDatabase /// operation. /// REST API Reference for UpdateRelationalDatabase Operation public virtual IAsyncResult BeginUpdateRelationalDatabase(UpdateRelationalDatabaseRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateRelationalDatabaseRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateRelationalDatabaseResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateRelationalDatabase operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateRelationalDatabase. /// /// Returns a UpdateRelationalDatabaseResult from Lightsail. /// REST API Reference for UpdateRelationalDatabase Operation public virtual UpdateRelationalDatabaseResponse EndUpdateRelationalDatabase(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateRelationalDatabaseParameters ///

/// 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. /// ///

/// Container for the necessary parameters to execute the UpdateRelationalDatabaseParameters service method. /// /// The response from the UpdateRelationalDatabaseParameters service method, as returned by Lightsail. /// /// Lightsail throws this exception when the user cannot be authenticated or uses invalid /// credentials to access a resource. /// /// /// Lightsail throws this exception when an account is still in the setup in progress /// state. /// /// /// Lightsail throws this exception when user input does not conform to the validation /// rules of an input field. /// /// /// /// Domain and distribution APIs are only available in the N. Virginia (us-east-1) /// Amazon Web Services Region. Please set your Amazon Web Services Region configuration /// to us-east-1 to create, view, or edit these resources. /// /// /// /// /// Lightsail throws this exception when it cannot find a resource. /// /// /// Lightsail throws this exception when an operation fails to execute. /// /// /// A general service exception. /// /// /// Lightsail throws this exception when the user has not been authenticated. /// /// REST API Reference for UpdateRelationalDatabaseParameters Operation public virtual UpdateRelationalDatabaseParametersResponse UpdateRelationalDatabaseParameters(UpdateRelationalDatabaseParametersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateRelationalDatabaseParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateRelationalDatabaseParametersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateRelationalDatabaseParameters operation. ///

/// /// Container for the necessary parameters to execute the UpdateRelationalDatabaseParameters operation on AmazonLightsailClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateRelationalDatabaseParameters /// operation. /// REST API Reference for UpdateRelationalDatabaseParameters Operation public virtual IAsyncResult BeginUpdateRelationalDatabaseParameters(UpdateRelationalDatabaseParametersRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateRelationalDatabaseParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateRelationalDatabaseParametersResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateRelationalDatabaseParameters operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateRelationalDatabaseParameters. /// /// Returns a UpdateRelationalDatabaseParametersResult from Lightsail. /// REST API Reference for UpdateRelationalDatabaseParameters Operation public virtual UpdateRelationalDatabaseParametersResponse EndUpdateRelationalDatabaseParameters(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion } }