/* * 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 elasticloadbalancing-2012-06-01.normal.json service model. */ using System; using System.Collections.Generic; using Amazon.Runtime; using Amazon.ElasticLoadBalancing.Model; namespace Amazon.ElasticLoadBalancing { ///

/// Interface for accessing ElasticLoadBalancing /// /// Elastic Load Balancing /// /// A load balancer can distribute incoming traffic across your EC2 instances. This enables /// you to increase the availability of your application. The load balancer also monitors /// the health of its registered instances and ensures that it routes traffic only to /// healthy instances. You configure your load balancer to accept incoming traffic by /// specifying one or more listeners, which are configured with a protocol and port number /// for connections from clients to the load balancer and a protocol and port number for /// connections from the load balancer to the instances. /// /// /// /// Elastic Load Balancing supports three types of load balancers: Application Load Balancers, /// Network Load Balancers, and Classic Load Balancers. You can select a load balancer /// based on your application needs. For more information, see the Elastic /// Load Balancing User Guide. /// /// /// /// This reference covers the 2012-06-01 API, which supports Classic Load Balancers. The /// 2015-12-01 API supports Application Load Balancers and Network Load Balancers. /// /// /// /// To get started, create a load balancer with one or more listeners using CreateLoadBalancer. /// Register your instances with the load balancer using RegisterInstancesWithLoadBalancer. /// /// /// /// All Elastic Load Balancing operations are idempotent, which means that they /// complete at most one time. If you repeat an operation, it succeeds with a 200 OK response /// code. /// ///

public partial interface IAmazonElasticLoadBalancing : IAmazonService, IDisposable { #if BCL45 || AWS_ASYNC_ENUMERABLES_API ///

/// Paginators for the service ///

IElasticLoadBalancingPaginatorFactory Paginators { get; } #endif #region AddTags ///

/// Adds the specified tags to the specified load balancer. Each load balancer can have /// a maximum of 10 tags. /// /// /// /// Each tag consists of a key and an optional value. If a tag with the same key is already /// associated with the load balancer, AddTags updates its value. /// /// /// /// For more information, see Tag /// Your Classic Load Balancer in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the AddTags service method. /// /// The response from the AddTags service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// A tag key was specified more than once. /// /// /// The quota for the number of tags that can be assigned to a load balancer has been /// reached. /// /// REST API Reference for AddTags Operation AddTagsResponse AddTags(AddTagsRequest request); ///

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

/// /// Container for the necessary parameters to execute the AddTags operation on AmazonElasticLoadBalancingClient. /// 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 EndAddTags /// operation. /// REST API Reference for AddTags Operation IAsyncResult BeginAddTags(AddTagsRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginAddTags. /// /// Returns a AddTagsResult from ElasticLoadBalancing. /// REST API Reference for AddTags Operation AddTagsResponse EndAddTags(IAsyncResult asyncResult); #endregion #region ApplySecurityGroupsToLoadBalancer ///

/// Associates one or more security groups with your load balancer in a virtual private /// cloud (VPC). The specified security groups override the previously associated security /// groups. /// /// /// /// For more information, see Security /// Groups for Load Balancers in a VPC in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the ApplySecurityGroupsToLoadBalancer service method. /// /// The response from the ApplySecurityGroupsToLoadBalancer service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The requested configuration change is not valid. /// /// /// One or more of the specified security groups do not exist. /// /// REST API Reference for ApplySecurityGroupsToLoadBalancer Operation ApplySecurityGroupsToLoadBalancerResponse ApplySecurityGroupsToLoadBalancer(ApplySecurityGroupsToLoadBalancerRequest request); ///

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

/// /// Container for the necessary parameters to execute the ApplySecurityGroupsToLoadBalancer operation on AmazonElasticLoadBalancingClient. /// 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 EndApplySecurityGroupsToLoadBalancer /// operation. /// REST API Reference for ApplySecurityGroupsToLoadBalancer Operation IAsyncResult BeginApplySecurityGroupsToLoadBalancer(ApplySecurityGroupsToLoadBalancerRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginApplySecurityGroupsToLoadBalancer. /// /// Returns a ApplySecurityGroupsToLoadBalancerResult from ElasticLoadBalancing. /// REST API Reference for ApplySecurityGroupsToLoadBalancer Operation ApplySecurityGroupsToLoadBalancerResponse EndApplySecurityGroupsToLoadBalancer(IAsyncResult asyncResult); #endregion #region AttachLoadBalancerToSubnets ///

/// Adds one or more subnets to the set of configured subnets for the specified load balancer. /// /// /// /// The load balancer evenly distributes requests across all registered subnets. For more /// information, see Add /// or Remove Subnets for Your Load Balancer in a VPC in the Classic Load Balancers /// Guide. /// ///

/// Container for the necessary parameters to execute the AttachLoadBalancerToSubnets service method. /// /// The response from the AttachLoadBalancerToSubnets service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The requested configuration change is not valid. /// /// /// The specified VPC has no associated Internet gateway. /// /// /// One or more of the specified subnets do not exist. /// /// REST API Reference for AttachLoadBalancerToSubnets Operation AttachLoadBalancerToSubnetsResponse AttachLoadBalancerToSubnets(AttachLoadBalancerToSubnetsRequest request); ///

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

/// /// Container for the necessary parameters to execute the AttachLoadBalancerToSubnets operation on AmazonElasticLoadBalancingClient. /// 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 EndAttachLoadBalancerToSubnets /// operation. /// REST API Reference for AttachLoadBalancerToSubnets Operation IAsyncResult BeginAttachLoadBalancerToSubnets(AttachLoadBalancerToSubnetsRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginAttachLoadBalancerToSubnets. /// /// Returns a AttachLoadBalancerToSubnetsResult from ElasticLoadBalancing. /// REST API Reference for AttachLoadBalancerToSubnets Operation AttachLoadBalancerToSubnetsResponse EndAttachLoadBalancerToSubnets(IAsyncResult asyncResult); #endregion #region ConfigureHealthCheck ///

/// Specifies the health check settings to use when evaluating the health state of your /// EC2 instances. /// /// /// /// For more information, see Configure /// Health Checks for Your Load Balancer in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the ConfigureHealthCheck service method. /// /// The response from the ConfigureHealthCheck service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// REST API Reference for ConfigureHealthCheck Operation ConfigureHealthCheckResponse ConfigureHealthCheck(ConfigureHealthCheckRequest request); ///

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

/// /// Container for the necessary parameters to execute the ConfigureHealthCheck operation on AmazonElasticLoadBalancingClient. /// 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 EndConfigureHealthCheck /// operation. /// REST API Reference for ConfigureHealthCheck Operation IAsyncResult BeginConfigureHealthCheck(ConfigureHealthCheckRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginConfigureHealthCheck. /// /// Returns a ConfigureHealthCheckResult from ElasticLoadBalancing. /// REST API Reference for ConfigureHealthCheck Operation ConfigureHealthCheckResponse EndConfigureHealthCheck(IAsyncResult asyncResult); #endregion #region CreateAppCookieStickinessPolicy ///

/// Generates a stickiness policy with sticky session lifetimes that follow that of an /// application-generated cookie. This policy can be associated only with HTTP/HTTPS listeners. /// /// /// /// This policy is similar to the policy created by CreateLBCookieStickinessPolicy, /// except that the lifetime of the special Elastic Load Balancing cookie, AWSELB, /// follows the lifetime of the application-generated cookie specified in the policy configuration. /// The load balancer only inserts a new stickiness cookie when the application response /// includes a new application cookie. /// /// /// /// If the application cookie is explicitly removed or expires, the session stops being /// sticky until a new application cookie is issued. /// /// /// /// For more information, see Application-Controlled /// Session Stickiness in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the CreateAppCookieStickinessPolicy service method. /// /// The response from the CreateAppCookieStickinessPolicy service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// A policy with the specified name already exists for this load balancer. /// /// /// The requested configuration change is not valid. /// /// /// The quota for the number of policies for this load balancer has been reached. /// /// REST API Reference for CreateAppCookieStickinessPolicy Operation CreateAppCookieStickinessPolicyResponse CreateAppCookieStickinessPolicy(CreateAppCookieStickinessPolicyRequest request); ///

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

/// /// Container for the necessary parameters to execute the CreateAppCookieStickinessPolicy operation on AmazonElasticLoadBalancingClient. /// 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 EndCreateAppCookieStickinessPolicy /// operation. /// REST API Reference for CreateAppCookieStickinessPolicy Operation IAsyncResult BeginCreateAppCookieStickinessPolicy(CreateAppCookieStickinessPolicyRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginCreateAppCookieStickinessPolicy. /// /// Returns a CreateAppCookieStickinessPolicyResult from ElasticLoadBalancing. /// REST API Reference for CreateAppCookieStickinessPolicy Operation CreateAppCookieStickinessPolicyResponse EndCreateAppCookieStickinessPolicy(IAsyncResult asyncResult); #endregion #region CreateLBCookieStickinessPolicy ///

/// Generates a stickiness policy with sticky session lifetimes controlled by the lifetime /// of the browser (user-agent) or a specified expiration period. This policy can be associated /// only with HTTP/HTTPS listeners. /// /// /// /// When a load balancer implements this policy, the load balancer uses a special cookie /// to track the instance for each request. When the load balancer receives a request, /// it first checks to see if this cookie is present in the request. If so, the load balancer /// sends the request to the application server specified in the cookie. If not, the load /// balancer sends the request to a server that is chosen based on the existing load-balancing /// algorithm. /// /// /// /// A cookie is inserted into the response for binding subsequent requests from the same /// user to that server. The validity of the cookie is based on the cookie expiration /// time, which is specified in the policy configuration. /// /// /// /// For more information, see Duration-Based /// Session Stickiness in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the CreateLBCookieStickinessPolicy service method. /// /// The response from the CreateLBCookieStickinessPolicy service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// A policy with the specified name already exists for this load balancer. /// /// /// The requested configuration change is not valid. /// /// /// The quota for the number of policies for this load balancer has been reached. /// /// REST API Reference for CreateLBCookieStickinessPolicy Operation CreateLBCookieStickinessPolicyResponse CreateLBCookieStickinessPolicy(CreateLBCookieStickinessPolicyRequest request); ///

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

/// /// Container for the necessary parameters to execute the CreateLBCookieStickinessPolicy operation on AmazonElasticLoadBalancingClient. /// 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 EndCreateLBCookieStickinessPolicy /// operation. /// REST API Reference for CreateLBCookieStickinessPolicy Operation IAsyncResult BeginCreateLBCookieStickinessPolicy(CreateLBCookieStickinessPolicyRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginCreateLBCookieStickinessPolicy. /// /// Returns a CreateLBCookieStickinessPolicyResult from ElasticLoadBalancing. /// REST API Reference for CreateLBCookieStickinessPolicy Operation CreateLBCookieStickinessPolicyResponse EndCreateLBCookieStickinessPolicy(IAsyncResult asyncResult); #endregion #region CreateLoadBalancer ///

/// Creates a Classic Load Balancer. /// /// /// /// You can add listeners, security groups, subnets, and tags when you create your load /// balancer, or you can add them later using CreateLoadBalancerListeners, ApplySecurityGroupsToLoadBalancer, /// AttachLoadBalancerToSubnets, and AddTags. /// /// /// /// To describe your current load balancers, see DescribeLoadBalancers. When you /// are finished with a load balancer, you can delete it using DeleteLoadBalancer. /// /// /// /// You can create up to 20 load balancers per region per account. You can request an /// increase for the number of load balancers for your account. For more information, /// see Limits /// for Your Classic Load Balancer in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the CreateLoadBalancer service method. /// /// The response from the CreateLoadBalancer service method, as returned by ElasticLoadBalancing. /// /// The specified ARN does not refer to a valid SSL certificate in AWS Identity and Access /// Management (IAM) or AWS Certificate Manager (ACM). Note that if you recently uploaded /// the certificate to IAM, this error might indicate that the certificate is not fully /// available yet. /// /// /// The specified load balancer name already exists for this account. /// /// /// A tag key was specified more than once. /// /// /// The requested configuration change is not valid. /// /// /// The specified value for the schema is not valid. You can only specify a scheme for /// load balancers in a VPC. /// /// /// One or more of the specified security groups do not exist. /// /// /// The specified VPC has no associated Internet gateway. /// /// /// This operation is not allowed. /// /// /// One or more of the specified subnets do not exist. /// /// /// The quota for the number of load balancers has been reached. /// /// /// The quota for the number of tags that can be assigned to a load balancer has been /// reached. /// /// /// The specified protocol or signature version is not supported. /// /// REST API Reference for CreateLoadBalancer Operation CreateLoadBalancerResponse CreateLoadBalancer(CreateLoadBalancerRequest request); ///

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

/// /// Container for the necessary parameters to execute the CreateLoadBalancer operation on AmazonElasticLoadBalancingClient. /// 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 IAsyncResult BeginCreateLoadBalancer(CreateLoadBalancerRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginCreateLoadBalancer. /// /// Returns a CreateLoadBalancerResult from ElasticLoadBalancing. /// REST API Reference for CreateLoadBalancer Operation CreateLoadBalancerResponse EndCreateLoadBalancer(IAsyncResult asyncResult); #endregion #region CreateLoadBalancerListeners ///

/// Creates one or more listeners for the specified load balancer. If a listener with /// the specified port does not already exist, it is created; otherwise, the properties /// of the new listener must match the properties of the existing listener. /// /// /// /// For more information, see Listeners /// for Your Classic Load Balancer in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the CreateLoadBalancerListeners service method. /// /// The response from the CreateLoadBalancerListeners service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The specified ARN does not refer to a valid SSL certificate in AWS Identity and Access /// Management (IAM) or AWS Certificate Manager (ACM). Note that if you recently uploaded /// the certificate to IAM, this error might indicate that the certificate is not fully /// available yet. /// /// /// A listener already exists for the specified load balancer name and port, but with /// a different instance port, protocol, or SSL certificate. /// /// /// The requested configuration change is not valid. /// /// /// The specified protocol or signature version is not supported. /// /// REST API Reference for CreateLoadBalancerListeners Operation CreateLoadBalancerListenersResponse CreateLoadBalancerListeners(CreateLoadBalancerListenersRequest request); ///

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

/// /// Container for the necessary parameters to execute the CreateLoadBalancerListeners operation on AmazonElasticLoadBalancingClient. /// 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 EndCreateLoadBalancerListeners /// operation. /// REST API Reference for CreateLoadBalancerListeners Operation IAsyncResult BeginCreateLoadBalancerListeners(CreateLoadBalancerListenersRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginCreateLoadBalancerListeners. /// /// Returns a CreateLoadBalancerListenersResult from ElasticLoadBalancing. /// REST API Reference for CreateLoadBalancerListeners Operation CreateLoadBalancerListenersResponse EndCreateLoadBalancerListeners(IAsyncResult asyncResult); #endregion #region CreateLoadBalancerPolicy ///

/// Creates a policy with the specified attributes for the specified load balancer. /// /// /// /// Policies are settings that are saved for your load balancer and that can be applied /// to the listener or the application server, depending on the policy type. /// ///

/// Container for the necessary parameters to execute the CreateLoadBalancerPolicy service method. /// /// The response from the CreateLoadBalancerPolicy service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// A policy with the specified name already exists for this load balancer. /// /// /// The requested configuration change is not valid. /// /// /// One or more of the specified policy types do not exist. /// /// /// The quota for the number of policies for this load balancer has been reached. /// /// REST API Reference for CreateLoadBalancerPolicy Operation CreateLoadBalancerPolicyResponse CreateLoadBalancerPolicy(CreateLoadBalancerPolicyRequest request); ///

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

/// /// Container for the necessary parameters to execute the CreateLoadBalancerPolicy operation on AmazonElasticLoadBalancingClient. /// 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 EndCreateLoadBalancerPolicy /// operation. /// REST API Reference for CreateLoadBalancerPolicy Operation IAsyncResult BeginCreateLoadBalancerPolicy(CreateLoadBalancerPolicyRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginCreateLoadBalancerPolicy. /// /// Returns a CreateLoadBalancerPolicyResult from ElasticLoadBalancing. /// REST API Reference for CreateLoadBalancerPolicy Operation CreateLoadBalancerPolicyResponse EndCreateLoadBalancerPolicy(IAsyncResult asyncResult); #endregion #region DeleteLoadBalancer ///

/// Deletes the specified load balancer. /// /// /// /// If you are attempting to recreate a load balancer, you must reconfigure all settings. /// The DNS name associated with a deleted load balancer are no longer usable. The name /// and associated DNS record of the deleted load balancer no longer exist and traffic /// sent to any of its IP addresses is no longer delivered to your instances. /// /// /// /// If the load balancer does not exist or has already been deleted, the call to DeleteLoadBalancer /// still succeeds. /// ///

/// Container for the necessary parameters to execute the DeleteLoadBalancer service method. /// /// The response from the DeleteLoadBalancer service method, as returned by ElasticLoadBalancing. /// REST API Reference for DeleteLoadBalancer Operation DeleteLoadBalancerResponse DeleteLoadBalancer(DeleteLoadBalancerRequest request); ///

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

/// /// Container for the necessary parameters to execute the DeleteLoadBalancer operation on AmazonElasticLoadBalancingClient. /// 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 IAsyncResult BeginDeleteLoadBalancer(DeleteLoadBalancerRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteLoadBalancer. /// /// Returns a DeleteLoadBalancerResult from ElasticLoadBalancing. /// REST API Reference for DeleteLoadBalancer Operation DeleteLoadBalancerResponse EndDeleteLoadBalancer(IAsyncResult asyncResult); #endregion #region DeleteLoadBalancerListeners ///

/// Deletes the specified listeners from the specified load balancer. ///

/// Container for the necessary parameters to execute the DeleteLoadBalancerListeners service method. /// /// The response from the DeleteLoadBalancerListeners service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// REST API Reference for DeleteLoadBalancerListeners Operation DeleteLoadBalancerListenersResponse DeleteLoadBalancerListeners(DeleteLoadBalancerListenersRequest request); ///

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

/// /// Container for the necessary parameters to execute the DeleteLoadBalancerListeners operation on AmazonElasticLoadBalancingClient. /// 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 EndDeleteLoadBalancerListeners /// operation. /// REST API Reference for DeleteLoadBalancerListeners Operation IAsyncResult BeginDeleteLoadBalancerListeners(DeleteLoadBalancerListenersRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteLoadBalancerListeners. /// /// Returns a DeleteLoadBalancerListenersResult from ElasticLoadBalancing. /// REST API Reference for DeleteLoadBalancerListeners Operation DeleteLoadBalancerListenersResponse EndDeleteLoadBalancerListeners(IAsyncResult asyncResult); #endregion #region DeleteLoadBalancerPolicy ///

/// Deletes the specified policy from the specified load balancer. This policy must not /// be enabled for any listeners. ///

/// Container for the necessary parameters to execute the DeleteLoadBalancerPolicy service method. /// /// The response from the DeleteLoadBalancerPolicy service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The requested configuration change is not valid. /// /// REST API Reference for DeleteLoadBalancerPolicy Operation DeleteLoadBalancerPolicyResponse DeleteLoadBalancerPolicy(DeleteLoadBalancerPolicyRequest request); ///

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

/// /// Container for the necessary parameters to execute the DeleteLoadBalancerPolicy operation on AmazonElasticLoadBalancingClient. /// 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 EndDeleteLoadBalancerPolicy /// operation. /// REST API Reference for DeleteLoadBalancerPolicy Operation IAsyncResult BeginDeleteLoadBalancerPolicy(DeleteLoadBalancerPolicyRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteLoadBalancerPolicy. /// /// Returns a DeleteLoadBalancerPolicyResult from ElasticLoadBalancing. /// REST API Reference for DeleteLoadBalancerPolicy Operation DeleteLoadBalancerPolicyResponse EndDeleteLoadBalancerPolicy(IAsyncResult asyncResult); #endregion #region DeregisterInstancesFromLoadBalancer ///

/// Deregisters the specified instances from the specified load balancer. After the instance /// is deregistered, it no longer receives traffic from the load balancer. /// /// /// /// You can use DescribeLoadBalancers to verify that the instance is deregistered /// from the load balancer. /// /// /// /// For more information, see Register /// or De-Register EC2 Instances in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the DeregisterInstancesFromLoadBalancer service method. /// /// The response from the DeregisterInstancesFromLoadBalancer service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The specified endpoint is not valid. /// /// REST API Reference for DeregisterInstancesFromLoadBalancer Operation DeregisterInstancesFromLoadBalancerResponse DeregisterInstancesFromLoadBalancer(DeregisterInstancesFromLoadBalancerRequest request); ///

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

/// /// Container for the necessary parameters to execute the DeregisterInstancesFromLoadBalancer operation on AmazonElasticLoadBalancingClient. /// 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 EndDeregisterInstancesFromLoadBalancer /// operation. /// REST API Reference for DeregisterInstancesFromLoadBalancer Operation IAsyncResult BeginDeregisterInstancesFromLoadBalancer(DeregisterInstancesFromLoadBalancerRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginDeregisterInstancesFromLoadBalancer. /// /// Returns a DeregisterInstancesFromLoadBalancerResult from ElasticLoadBalancing. /// REST API Reference for DeregisterInstancesFromLoadBalancer Operation DeregisterInstancesFromLoadBalancerResponse EndDeregisterInstancesFromLoadBalancer(IAsyncResult asyncResult); #endregion #region DescribeAccountLimits ///

/// Describes the current Elastic Load Balancing resource limits for your AWS account. /// /// /// /// For more information, see Limits /// for Your Classic Load Balancer in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the DescribeAccountLimits service method. /// /// The response from the DescribeAccountLimits service method, as returned by ElasticLoadBalancing. /// REST API Reference for DescribeAccountLimits Operation DescribeAccountLimitsResponse DescribeAccountLimits(DescribeAccountLimitsRequest request); ///

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

/// /// Container for the necessary parameters to execute the DescribeAccountLimits operation on AmazonElasticLoadBalancingClient. /// 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 EndDescribeAccountLimits /// operation. /// REST API Reference for DescribeAccountLimits Operation IAsyncResult BeginDescribeAccountLimits(DescribeAccountLimitsRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginDescribeAccountLimits. /// /// Returns a DescribeAccountLimitsResult from ElasticLoadBalancing. /// REST API Reference for DescribeAccountLimits Operation DescribeAccountLimitsResponse EndDescribeAccountLimits(IAsyncResult asyncResult); #endregion #region DescribeInstanceHealth ///

/// Describes the state of the specified instances with respect to the specified load /// balancer. If no instances are specified, the call describes the state of all instances /// that are currently registered with the load balancer. If instances are specified, /// their state is returned even if they are no longer registered with the load balancer. /// The state of terminated instances is not returned. ///

/// Container for the necessary parameters to execute the DescribeInstanceHealth service method. /// /// The response from the DescribeInstanceHealth service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The specified endpoint is not valid. /// /// REST API Reference for DescribeInstanceHealth Operation DescribeInstanceHealthResponse DescribeInstanceHealth(DescribeInstanceHealthRequest request); ///

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

/// /// Container for the necessary parameters to execute the DescribeInstanceHealth operation on AmazonElasticLoadBalancingClient. /// 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 EndDescribeInstanceHealth /// operation. /// REST API Reference for DescribeInstanceHealth Operation IAsyncResult BeginDescribeInstanceHealth(DescribeInstanceHealthRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginDescribeInstanceHealth. /// /// Returns a DescribeInstanceHealthResult from ElasticLoadBalancing. /// REST API Reference for DescribeInstanceHealth Operation DescribeInstanceHealthResponse EndDescribeInstanceHealth(IAsyncResult asyncResult); #endregion #region DescribeLoadBalancerAttributes ///

/// Describes the attributes for the specified load balancer. ///

/// Container for the necessary parameters to execute the DescribeLoadBalancerAttributes service method. /// /// The response from the DescribeLoadBalancerAttributes service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The specified load balancer attribute does not exist. /// /// REST API Reference for DescribeLoadBalancerAttributes Operation DescribeLoadBalancerAttributesResponse DescribeLoadBalancerAttributes(DescribeLoadBalancerAttributesRequest request); ///

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

/// /// Container for the necessary parameters to execute the DescribeLoadBalancerAttributes operation on AmazonElasticLoadBalancingClient. /// 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 EndDescribeLoadBalancerAttributes /// operation. /// REST API Reference for DescribeLoadBalancerAttributes Operation IAsyncResult BeginDescribeLoadBalancerAttributes(DescribeLoadBalancerAttributesRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginDescribeLoadBalancerAttributes. /// /// Returns a DescribeLoadBalancerAttributesResult from ElasticLoadBalancing. /// REST API Reference for DescribeLoadBalancerAttributes Operation DescribeLoadBalancerAttributesResponse EndDescribeLoadBalancerAttributes(IAsyncResult asyncResult); #endregion #region DescribeLoadBalancerPolicies ///

/// Describes the specified policies. /// /// /// /// If you specify a load balancer name, the action returns the descriptions of all policies /// created for the load balancer. If you specify a policy name associated with your load /// balancer, the action returns the description of that policy. If you don't specify /// a load balancer name, the action returns descriptions of the specified sample policies, /// or descriptions of all sample policies. The names of the sample policies have the /// ELBSample- prefix. /// ///

/// /// The response from the DescribeLoadBalancerPolicies service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// One or more of the specified policies do not exist. /// /// REST API Reference for DescribeLoadBalancerPolicies Operation DescribeLoadBalancerPoliciesResponse DescribeLoadBalancerPolicies(); ///

/// Container for the necessary parameters to execute the DescribeLoadBalancerPolicies service method. /// /// The response from the DescribeLoadBalancerPolicies service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// One or more of the specified policies do not exist. /// /// REST API Reference for DescribeLoadBalancerPolicies Operation DescribeLoadBalancerPoliciesResponse DescribeLoadBalancerPolicies(DescribeLoadBalancerPoliciesRequest request); ///

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

/// /// Container for the necessary parameters to execute the DescribeLoadBalancerPolicies operation on AmazonElasticLoadBalancingClient. /// 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 EndDescribeLoadBalancerPolicies /// operation. /// REST API Reference for DescribeLoadBalancerPolicies Operation IAsyncResult BeginDescribeLoadBalancerPolicies(DescribeLoadBalancerPoliciesRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginDescribeLoadBalancerPolicies. /// /// Returns a DescribeLoadBalancerPoliciesResult from ElasticLoadBalancing. /// REST API Reference for DescribeLoadBalancerPolicies Operation DescribeLoadBalancerPoliciesResponse EndDescribeLoadBalancerPolicies(IAsyncResult asyncResult); #endregion #region DescribeLoadBalancerPolicyTypes ///

/// Describes the specified load balancer policy types or all load balancer policy types. /// /// /// /// The description of each type indicates how it can be used. For example, some policies /// can be used only with layer 7 listeners, some policies can be used only with layer /// 4 listeners, and some policies can be used only with your EC2 instances. /// /// /// /// You can use CreateLoadBalancerPolicy to create a policy configuration for any /// of these policy types. Then, depending on the policy type, use either SetLoadBalancerPoliciesOfListener /// or SetLoadBalancerPoliciesForBackendServer to set the policy. /// ///

/// /// The response from the DescribeLoadBalancerPolicyTypes service method, as returned by ElasticLoadBalancing. /// /// One or more of the specified policy types do not exist. /// /// REST API Reference for DescribeLoadBalancerPolicyTypes Operation DescribeLoadBalancerPolicyTypesResponse DescribeLoadBalancerPolicyTypes(); ///

/// Container for the necessary parameters to execute the DescribeLoadBalancerPolicyTypes service method. /// /// The response from the DescribeLoadBalancerPolicyTypes service method, as returned by ElasticLoadBalancing. /// /// One or more of the specified policy types do not exist. /// /// REST API Reference for DescribeLoadBalancerPolicyTypes Operation DescribeLoadBalancerPolicyTypesResponse DescribeLoadBalancerPolicyTypes(DescribeLoadBalancerPolicyTypesRequest request); ///

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

/// /// Container for the necessary parameters to execute the DescribeLoadBalancerPolicyTypes operation on AmazonElasticLoadBalancingClient. /// 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 EndDescribeLoadBalancerPolicyTypes /// operation. /// REST API Reference for DescribeLoadBalancerPolicyTypes Operation IAsyncResult BeginDescribeLoadBalancerPolicyTypes(DescribeLoadBalancerPolicyTypesRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginDescribeLoadBalancerPolicyTypes. /// /// Returns a DescribeLoadBalancerPolicyTypesResult from ElasticLoadBalancing. /// REST API Reference for DescribeLoadBalancerPolicyTypes Operation DescribeLoadBalancerPolicyTypesResponse EndDescribeLoadBalancerPolicyTypes(IAsyncResult asyncResult); #endregion #region DescribeLoadBalancers ///

/// Describes the specified the load balancers. If no load balancers are specified, the /// call describes all of your load balancers. ///

/// /// The response from the DescribeLoadBalancers service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// A request made by Elastic Load Balancing to another service exceeds the maximum request /// rate permitted for your account. /// /// REST API Reference for DescribeLoadBalancers Operation DescribeLoadBalancersResponse DescribeLoadBalancers(); ///

/// Describes the specified the load balancers. If no load balancers are specified, the /// call describes all of your load balancers. ///

/// Container for the necessary parameters to execute the DescribeLoadBalancers service method. /// /// The response from the DescribeLoadBalancers service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// A request made by Elastic Load Balancing to another service exceeds the maximum request /// rate permitted for your account. /// /// REST API Reference for DescribeLoadBalancers Operation DescribeLoadBalancersResponse DescribeLoadBalancers(DescribeLoadBalancersRequest request); ///

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

/// /// Container for the necessary parameters to execute the DescribeLoadBalancers operation on AmazonElasticLoadBalancingClient. /// 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 EndDescribeLoadBalancers /// operation. /// REST API Reference for DescribeLoadBalancers Operation IAsyncResult BeginDescribeLoadBalancers(DescribeLoadBalancersRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginDescribeLoadBalancers. /// /// Returns a DescribeLoadBalancersResult from ElasticLoadBalancing. /// REST API Reference for DescribeLoadBalancers Operation DescribeLoadBalancersResponse EndDescribeLoadBalancers(IAsyncResult asyncResult); #endregion #region DescribeTags ///

/// Describes the tags associated with the specified load balancers. ///

/// Container for the necessary parameters to execute the DescribeTags service method. /// /// The response from the DescribeTags service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// REST API Reference for DescribeTags Operation DescribeTagsResponse DescribeTags(DescribeTagsRequest request); ///

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

/// /// Container for the necessary parameters to execute the DescribeTags operation on AmazonElasticLoadBalancingClient. /// 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 EndDescribeTags /// operation. /// REST API Reference for DescribeTags Operation IAsyncResult BeginDescribeTags(DescribeTagsRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginDescribeTags. /// /// Returns a DescribeTagsResult from ElasticLoadBalancing. /// REST API Reference for DescribeTags Operation DescribeTagsResponse EndDescribeTags(IAsyncResult asyncResult); #endregion #region DetachLoadBalancerFromSubnets ///

/// Removes the specified subnets from the set of configured subnets for the load balancer. /// /// /// /// After a subnet is removed, all EC2 instances registered with the load balancer in /// the removed subnet go into the OutOfService state. Then, the load balancer /// balances the traffic among the remaining routable subnets. /// ///

/// Container for the necessary parameters to execute the DetachLoadBalancerFromSubnets service method. /// /// The response from the DetachLoadBalancerFromSubnets service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The requested configuration change is not valid. /// /// REST API Reference for DetachLoadBalancerFromSubnets Operation DetachLoadBalancerFromSubnetsResponse DetachLoadBalancerFromSubnets(DetachLoadBalancerFromSubnetsRequest request); ///

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

/// /// Container for the necessary parameters to execute the DetachLoadBalancerFromSubnets operation on AmazonElasticLoadBalancingClient. /// 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 EndDetachLoadBalancerFromSubnets /// operation. /// REST API Reference for DetachLoadBalancerFromSubnets Operation IAsyncResult BeginDetachLoadBalancerFromSubnets(DetachLoadBalancerFromSubnetsRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginDetachLoadBalancerFromSubnets. /// /// Returns a DetachLoadBalancerFromSubnetsResult from ElasticLoadBalancing. /// REST API Reference for DetachLoadBalancerFromSubnets Operation DetachLoadBalancerFromSubnetsResponse EndDetachLoadBalancerFromSubnets(IAsyncResult asyncResult); #endregion #region DisableAvailabilityZonesForLoadBalancer ///

/// Removes the specified Availability Zones from the set of Availability Zones for the /// specified load balancer in EC2-Classic or a default VPC. /// /// /// /// For load balancers in a non-default VPC, use DetachLoadBalancerFromSubnets. /// /// /// /// There must be at least one Availability Zone registered with a load balancer at all /// times. After an Availability Zone is removed, all instances registered with the load /// balancer that are in the removed Availability Zone go into the OutOfService /// state. Then, the load balancer attempts to equally balance the traffic among its remaining /// Availability Zones. /// /// /// /// For more information, see Add /// or Remove Availability Zones in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the DisableAvailabilityZonesForLoadBalancer service method. /// /// The response from the DisableAvailabilityZonesForLoadBalancer service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The requested configuration change is not valid. /// /// REST API Reference for DisableAvailabilityZonesForLoadBalancer Operation DisableAvailabilityZonesForLoadBalancerResponse DisableAvailabilityZonesForLoadBalancer(DisableAvailabilityZonesForLoadBalancerRequest request); ///

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

/// /// Container for the necessary parameters to execute the DisableAvailabilityZonesForLoadBalancer operation on AmazonElasticLoadBalancingClient. /// 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 EndDisableAvailabilityZonesForLoadBalancer /// operation. /// REST API Reference for DisableAvailabilityZonesForLoadBalancer Operation IAsyncResult BeginDisableAvailabilityZonesForLoadBalancer(DisableAvailabilityZonesForLoadBalancerRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginDisableAvailabilityZonesForLoadBalancer. /// /// Returns a DisableAvailabilityZonesForLoadBalancerResult from ElasticLoadBalancing. /// REST API Reference for DisableAvailabilityZonesForLoadBalancer Operation DisableAvailabilityZonesForLoadBalancerResponse EndDisableAvailabilityZonesForLoadBalancer(IAsyncResult asyncResult); #endregion #region EnableAvailabilityZonesForLoadBalancer ///

/// Adds the specified Availability Zones to the set of Availability Zones for the specified /// load balancer in EC2-Classic or a default VPC. /// /// /// /// For load balancers in a non-default VPC, use AttachLoadBalancerToSubnets. /// /// /// /// The load balancer evenly distributes requests across all its registered Availability /// Zones that contain instances. For more information, see Add /// or Remove Availability Zones in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the EnableAvailabilityZonesForLoadBalancer service method. /// /// The response from the EnableAvailabilityZonesForLoadBalancer service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// REST API Reference for EnableAvailabilityZonesForLoadBalancer Operation EnableAvailabilityZonesForLoadBalancerResponse EnableAvailabilityZonesForLoadBalancer(EnableAvailabilityZonesForLoadBalancerRequest request); ///

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

/// /// Container for the necessary parameters to execute the EnableAvailabilityZonesForLoadBalancer operation on AmazonElasticLoadBalancingClient. /// 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 EndEnableAvailabilityZonesForLoadBalancer /// operation. /// REST API Reference for EnableAvailabilityZonesForLoadBalancer Operation IAsyncResult BeginEnableAvailabilityZonesForLoadBalancer(EnableAvailabilityZonesForLoadBalancerRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginEnableAvailabilityZonesForLoadBalancer. /// /// Returns a EnableAvailabilityZonesForLoadBalancerResult from ElasticLoadBalancing. /// REST API Reference for EnableAvailabilityZonesForLoadBalancer Operation EnableAvailabilityZonesForLoadBalancerResponse EndEnableAvailabilityZonesForLoadBalancer(IAsyncResult asyncResult); #endregion #region ModifyLoadBalancerAttributes ///

/// Modifies the attributes of the specified load balancer. /// /// /// /// You can modify the load balancer attributes, such as AccessLogs, ConnectionDraining, /// and CrossZoneLoadBalancing by either enabling or disabling them. Or, /// you can modify the load balancer attribute ConnectionSettings by specifying /// an idle connection timeout value for your load balancer. /// /// /// /// For more information, see the following in the Classic Load Balancers Guide: /// ///

/// /// Cross-Zone /// Load Balancing /// ///
/// /// Connection /// Draining /// ///
/// /// Access /// Logs /// ///
/// /// Idle /// Connection Timeout /// ///

///

/// Container for the necessary parameters to execute the ModifyLoadBalancerAttributes service method. /// /// The response from the ModifyLoadBalancerAttributes service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The requested configuration change is not valid. /// /// /// The specified load balancer attribute does not exist. /// /// REST API Reference for ModifyLoadBalancerAttributes Operation ModifyLoadBalancerAttributesResponse ModifyLoadBalancerAttributes(ModifyLoadBalancerAttributesRequest request); ///

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

/// /// Container for the necessary parameters to execute the ModifyLoadBalancerAttributes operation on AmazonElasticLoadBalancingClient. /// 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 EndModifyLoadBalancerAttributes /// operation. /// REST API Reference for ModifyLoadBalancerAttributes Operation IAsyncResult BeginModifyLoadBalancerAttributes(ModifyLoadBalancerAttributesRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginModifyLoadBalancerAttributes. /// /// Returns a ModifyLoadBalancerAttributesResult from ElasticLoadBalancing. /// REST API Reference for ModifyLoadBalancerAttributes Operation ModifyLoadBalancerAttributesResponse EndModifyLoadBalancerAttributes(IAsyncResult asyncResult); #endregion #region RegisterInstancesWithLoadBalancer ///

/// Adds the specified instances to the specified load balancer. /// /// /// /// The instance must be a running instance in the same network as the load balancer (EC2-Classic /// or the same VPC). If you have EC2-Classic instances and a load balancer in a VPC with /// ClassicLink enabled, you can link the EC2-Classic instances to that VPC and then register /// the linked EC2-Classic instances with the load balancer in the VPC. /// /// /// /// Note that RegisterInstanceWithLoadBalancer completes when the request /// has been registered. Instance registration takes a little time to complete. To check /// the state of the registered instances, use DescribeLoadBalancers or DescribeInstanceHealth. /// /// /// /// After the instance is registered, it starts receiving traffic and requests from the /// load balancer. Any instance that is not in one of the Availability Zones registered /// for the load balancer is moved to the OutOfService state. If an Availability /// Zone is added to the load balancer later, any instances registered with the load balancer /// move to the InService state. /// /// /// /// To deregister instances from a load balancer, use DeregisterInstancesFromLoadBalancer. /// /// /// /// For more information, see Register /// or De-Register EC2 Instances in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the RegisterInstancesWithLoadBalancer service method. /// /// The response from the RegisterInstancesWithLoadBalancer service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The specified endpoint is not valid. /// /// REST API Reference for RegisterInstancesWithLoadBalancer Operation RegisterInstancesWithLoadBalancerResponse RegisterInstancesWithLoadBalancer(RegisterInstancesWithLoadBalancerRequest request); ///

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

/// /// Container for the necessary parameters to execute the RegisterInstancesWithLoadBalancer operation on AmazonElasticLoadBalancingClient. /// 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 EndRegisterInstancesWithLoadBalancer /// operation. /// REST API Reference for RegisterInstancesWithLoadBalancer Operation IAsyncResult BeginRegisterInstancesWithLoadBalancer(RegisterInstancesWithLoadBalancerRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginRegisterInstancesWithLoadBalancer. /// /// Returns a RegisterInstancesWithLoadBalancerResult from ElasticLoadBalancing. /// REST API Reference for RegisterInstancesWithLoadBalancer Operation RegisterInstancesWithLoadBalancerResponse EndRegisterInstancesWithLoadBalancer(IAsyncResult asyncResult); #endregion #region RemoveTags ///

/// Removes one or more tags from the specified load balancer. ///

/// Container for the necessary parameters to execute the RemoveTags service method. /// /// The response from the RemoveTags service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// REST API Reference for RemoveTags Operation RemoveTagsResponse RemoveTags(RemoveTagsRequest request); ///

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

/// /// Container for the necessary parameters to execute the RemoveTags operation on AmazonElasticLoadBalancingClient. /// 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 EndRemoveTags /// operation. /// REST API Reference for RemoveTags Operation IAsyncResult BeginRemoveTags(RemoveTagsRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginRemoveTags. /// /// Returns a RemoveTagsResult from ElasticLoadBalancing. /// REST API Reference for RemoveTags Operation RemoveTagsResponse EndRemoveTags(IAsyncResult asyncResult); #endregion #region SetLoadBalancerListenerSSLCertificate ///

/// Sets the certificate that terminates the specified listener's SSL connections. The /// specified certificate replaces any prior certificate that was used on the same load /// balancer and port. /// /// /// /// For more information about updating your SSL certificate, see Replace /// the SSL Certificate for Your Load Balancer in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the SetLoadBalancerListenerSSLCertificate service method. /// /// The response from the SetLoadBalancerListenerSSLCertificate service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The specified ARN does not refer to a valid SSL certificate in AWS Identity and Access /// Management (IAM) or AWS Certificate Manager (ACM). Note that if you recently uploaded /// the certificate to IAM, this error might indicate that the certificate is not fully /// available yet. /// /// /// The requested configuration change is not valid. /// /// /// The load balancer does not have a listener configured at the specified port. /// /// /// The specified protocol or signature version is not supported. /// /// REST API Reference for SetLoadBalancerListenerSSLCertificate Operation SetLoadBalancerListenerSSLCertificateResponse SetLoadBalancerListenerSSLCertificate(SetLoadBalancerListenerSSLCertificateRequest request); ///

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

/// /// Container for the necessary parameters to execute the SetLoadBalancerListenerSSLCertificate operation on AmazonElasticLoadBalancingClient. /// 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 EndSetLoadBalancerListenerSSLCertificate /// operation. /// REST API Reference for SetLoadBalancerListenerSSLCertificate Operation IAsyncResult BeginSetLoadBalancerListenerSSLCertificate(SetLoadBalancerListenerSSLCertificateRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginSetLoadBalancerListenerSSLCertificate. /// /// Returns a SetLoadBalancerListenerSSLCertificateResult from ElasticLoadBalancing. /// REST API Reference for SetLoadBalancerListenerSSLCertificate Operation SetLoadBalancerListenerSSLCertificateResponse EndSetLoadBalancerListenerSSLCertificate(IAsyncResult asyncResult); #endregion #region SetLoadBalancerPoliciesForBackendServer ///

/// Replaces the set of policies associated with the specified port on which the EC2 instance /// is listening with a new set of policies. At this time, only the back-end server authentication /// policy type can be applied to the instance ports; this policy type is composed of /// multiple public key policies. /// /// /// /// Each time you use SetLoadBalancerPoliciesForBackendServer to enable the /// policies, use the PolicyNames parameter to list the policies that you /// want to enable. /// /// /// /// You can use DescribeLoadBalancers or DescribeLoadBalancerPolicies to /// verify that the policy is associated with the EC2 instance. /// /// /// /// For more information about enabling back-end instance authentication, see Configure /// Back-end Instance Authentication in the Classic Load Balancers Guide. For /// more information about Proxy Protocol, see Configure /// Proxy Protocol Support in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the SetLoadBalancerPoliciesForBackendServer service method. /// /// The response from the SetLoadBalancerPoliciesForBackendServer service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The requested configuration change is not valid. /// /// /// One or more of the specified policies do not exist. /// /// REST API Reference for SetLoadBalancerPoliciesForBackendServer Operation SetLoadBalancerPoliciesForBackendServerResponse SetLoadBalancerPoliciesForBackendServer(SetLoadBalancerPoliciesForBackendServerRequest request); ///

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

/// /// Container for the necessary parameters to execute the SetLoadBalancerPoliciesForBackendServer operation on AmazonElasticLoadBalancingClient. /// 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 EndSetLoadBalancerPoliciesForBackendServer /// operation. /// REST API Reference for SetLoadBalancerPoliciesForBackendServer Operation IAsyncResult BeginSetLoadBalancerPoliciesForBackendServer(SetLoadBalancerPoliciesForBackendServerRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginSetLoadBalancerPoliciesForBackendServer. /// /// Returns a SetLoadBalancerPoliciesForBackendServerResult from ElasticLoadBalancing. /// REST API Reference for SetLoadBalancerPoliciesForBackendServer Operation SetLoadBalancerPoliciesForBackendServerResponse EndSetLoadBalancerPoliciesForBackendServer(IAsyncResult asyncResult); #endregion #region SetLoadBalancerPoliciesOfListener ///

/// Replaces the current set of policies for the specified load balancer port with the /// specified set of policies. /// /// /// /// To enable back-end server authentication, use SetLoadBalancerPoliciesForBackendServer. /// /// /// /// For more information about setting policies, see Update /// the SSL Negotiation Configuration, Duration-Based /// Session Stickiness, and Application-Controlled /// Session Stickiness in the Classic Load Balancers Guide. /// ///

/// Container for the necessary parameters to execute the SetLoadBalancerPoliciesOfListener service method. /// /// The response from the SetLoadBalancerPoliciesOfListener service method, as returned by ElasticLoadBalancing. /// /// The specified load balancer does not exist. /// /// /// The requested configuration change is not valid. /// /// /// The load balancer does not have a listener configured at the specified port. /// /// /// One or more of the specified policies do not exist. /// /// REST API Reference for SetLoadBalancerPoliciesOfListener Operation SetLoadBalancerPoliciesOfListenerResponse SetLoadBalancerPoliciesOfListener(SetLoadBalancerPoliciesOfListenerRequest request); ///

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

/// /// Container for the necessary parameters to execute the SetLoadBalancerPoliciesOfListener operation on AmazonElasticLoadBalancingClient. /// 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 EndSetLoadBalancerPoliciesOfListener /// operation. /// REST API Reference for SetLoadBalancerPoliciesOfListener Operation IAsyncResult BeginSetLoadBalancerPoliciesOfListener(SetLoadBalancerPoliciesOfListenerRequest request, AsyncCallback callback, object state); ///

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

/// /// The IAsyncResult returned by the call to BeginSetLoadBalancerPoliciesOfListener. /// /// Returns a SetLoadBalancerPoliciesOfListenerResult from ElasticLoadBalancing. /// REST API Reference for SetLoadBalancerPoliciesOfListener Operation SetLoadBalancerPoliciesOfListenerResponse EndSetLoadBalancerPoliciesOfListener(IAsyncResult asyncResult); #endregion } }