LoadBalancerAsyncClient (Oracle Cloud Infrastructure Java SDK

java.lang.Object
- com.oracle.bmc.loadbalancer.LoadBalancerAsyncClient

All Implemented Interfaces:

LoadBalancerAsync, AutoCloseable
```
@Generated(value="OracleSDKGenerator",
           comments="API Version: 20170115")
public class LoadBalancerAsyncClient
extends Object
implements LoadBalancerAsync
```
Async client implementation for LoadBalancer service.
There are two ways to use async client:
1. Use AsyncHandler: using AsyncHandler, if the response to the call is an InputStream, like getObject Api in object storage service, developers need to process the stream in AsyncHandler, and not anywhere else, because the stream will be closed right after the AsyncHandler is invoked.
2. Use Java Future: using Java Future, developers need to close the stream after they are done with the Java Future.
  Accessing the result should be done in a mutually exclusive manner, either through the Future or the AsyncHandler, but not both. If the Future is used, the caller should pass in null as the AsyncHandler. If the AsyncHandler is used, it is still safe to use the Future to determine whether or not the request was completed via Future.isDone/isCancelled.
  Please refer to https://github.com/oracle/oci-java-sdk/blob/master/bmc-examples/src/main/java/ResteasyClientWithObjectStorageExample.java

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class LoadBalancerAsyncClient.Builder
Builder class for this client.

Nested Classes
Modifier and Type	Class and Description
`static class`	`LoadBalancerAsyncClient.Builder` Builder class for this client.

Field Summary

Fields
Modifier and Type Field and Description

static Service SERVICE
Service instance for LoadBalancer.

Fields
Modifier and Type	Field and Description
`static Service`	`SERVICE` Service instance for LoadBalancer.

Constructor Summary

Constructors
Constructor and Description
`LoadBalancerAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator, RequestSignerFactory defaultRequestSignerFactory)` Creates a new service instance using the given authentication provider and client configuration.
`LoadBalancerAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator, RequestSignerFactory defaultRequestSignerFactory, List<ClientConfigurator> additionalClientConfigurators)` Creates a new service instance using the given authentication provider and client configuration.
`LoadBalancerAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator, RequestSignerFactory defaultRequestSignerFactory, List<ClientConfigurator> additionalClientConfigurators, String endpoint)` Creates a new service instance using the given authentication provider and client configuration.
`LoadBalancerAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator, RequestSignerFactory defaultRequestSignerFactory, Map<SigningStrategy,RequestSignerFactory> signingStrategyRequestSignerFactories, List<ClientConfigurator> additionalClientConfigurators, String endpoint)` Creates a new service instance using the given authentication provider and client configuration.
`LoadBalancerAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator, RequestSignerFactory defaultRequestSignerFactory, Map<SigningStrategy,RequestSignerFactory> signingStrategyRequestSignerFactories, List<ClientConfigurator> additionalClientConfigurators, String endpoint, com.oracle.bmc.http.internal.RestClientFactoryBuilder restClientFactoryBuilder)` Creates a new service instance using the given authentication provider and client configuration.
`LoadBalancerAsyncClient(BasicAuthenticationDetailsProvider authenticationDetailsProvider)` Creates a new service instance using the given authentication provider.
`LoadBalancerAsyncClient(BasicAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration)` Creates a new service instance using the given authentication provider and client configuration.
`LoadBalancerAsyncClient(BasicAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator)` Creates a new service instance using the given authentication provider and client configuration.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static LoadBalancerAsyncClient.Builder`	`builder()` Create a builder for this client.
`Future<ChangeLoadBalancerCompartmentResponse>`	`changeLoadBalancerCompartment(ChangeLoadBalancerCompartmentRequest request, AsyncHandler<ChangeLoadBalancerCompartmentRequest,ChangeLoadBalancerCompartmentResponse> handler)` Moves a load balancer into a different compartment within the same tenancy.
`void`	`close()`
`Future<CreateBackendResponse>`	`createBackend(CreateBackendRequest request, AsyncHandler<CreateBackendRequest,CreateBackendResponse> handler)` Adds a backend server to a backend set.
`Future<CreateBackendSetResponse>`	`createBackendSet(CreateBackendSetRequest request, AsyncHandler<CreateBackendSetRequest,CreateBackendSetResponse> handler)` Adds a backend set to a load balancer.
`Future<CreateCertificateResponse>`	`createCertificate(CreateCertificateRequest request, AsyncHandler<CreateCertificateRequest,CreateCertificateResponse> handler)` Creates an asynchronous request to add an SSL certificate bundle.
`Future<CreateHostnameResponse>`	`createHostname(CreateHostnameRequest request, AsyncHandler<CreateHostnameRequest,CreateHostnameResponse> handler)` Adds a hostname resource to the specified load balancer.
`Future<CreateListenerResponse>`	`createListener(CreateListenerRequest request, AsyncHandler<CreateListenerRequest,CreateListenerResponse> handler)` Adds a listener to a load balancer.
`Future<CreateLoadBalancerResponse>`	`createLoadBalancer(CreateLoadBalancerRequest request, AsyncHandler<CreateLoadBalancerRequest,CreateLoadBalancerResponse> handler)` Creates a new load balancer in the specified compartment.
`Future<CreatePathRouteSetResponse>`	`createPathRouteSet(CreatePathRouteSetRequest request, AsyncHandler<CreatePathRouteSetRequest,CreatePathRouteSetResponse> handler)` Adds a path route set to a load balancer.
`Future<CreateRuleSetResponse>`	`createRuleSet(CreateRuleSetRequest request, AsyncHandler<CreateRuleSetRequest,CreateRuleSetResponse> handler)` Creates a new rule set associated with the specified load balancer.
`Future<CreateSSLCipherSuiteResponse>`	`createSSLCipherSuite(CreateSSLCipherSuiteRequest request, AsyncHandler<CreateSSLCipherSuiteRequest,CreateSSLCipherSuiteResponse> handler)` Creates a custom SSL cipher suite.
`Future<DeleteBackendResponse>`	`deleteBackend(DeleteBackendRequest request, AsyncHandler<DeleteBackendRequest,DeleteBackendResponse> handler)` Removes a backend server from a given load balancer and backend set.
`Future<DeleteBackendSetResponse>`	`deleteBackendSet(DeleteBackendSetRequest request, AsyncHandler<DeleteBackendSetRequest,DeleteBackendSetResponse> handler)` Deletes the specified backend set.
`Future<DeleteCertificateResponse>`	`deleteCertificate(DeleteCertificateRequest request, AsyncHandler<DeleteCertificateRequest,DeleteCertificateResponse> handler)` Deletes an SSL certificate bundle from a load balancer.
`Future<DeleteHostnameResponse>`	`deleteHostname(DeleteHostnameRequest request, AsyncHandler<DeleteHostnameRequest,DeleteHostnameResponse> handler)` Deletes a hostname resource from the specified load balancer.
`Future<DeleteListenerResponse>`	`deleteListener(DeleteListenerRequest request, AsyncHandler<DeleteListenerRequest,DeleteListenerResponse> handler)` Deletes a listener from a load balancer.
`Future<DeleteLoadBalancerResponse>`	`deleteLoadBalancer(DeleteLoadBalancerRequest request, AsyncHandler<DeleteLoadBalancerRequest,DeleteLoadBalancerResponse> handler)` Stops a load balancer and removes it from service.
`Future<DeletePathRouteSetResponse>`	`deletePathRouteSet(DeletePathRouteSetRequest request, AsyncHandler<DeletePathRouteSetRequest,DeletePathRouteSetResponse> handler)` Deletes a path route set from the specified load balancer.
`Future<DeleteRuleSetResponse>`	`deleteRuleSet(DeleteRuleSetRequest request, AsyncHandler<DeleteRuleSetRequest,DeleteRuleSetResponse> handler)` Deletes a rule set from the specified load balancer.
`Future<DeleteSSLCipherSuiteResponse>`	`deleteSSLCipherSuite(DeleteSSLCipherSuiteRequest request, AsyncHandler<DeleteSSLCipherSuiteRequest,DeleteSSLCipherSuiteResponse> handler)` Deletes an SSL cipher suite from a load balancer.
`Future<GetBackendResponse>`	`getBackend(GetBackendRequest request, AsyncHandler<GetBackendRequest,GetBackendResponse> handler)` Gets the specified backend server’s configuration information.
`Future<GetBackendHealthResponse>`	`getBackendHealth(GetBackendHealthRequest request, AsyncHandler<GetBackendHealthRequest,GetBackendHealthResponse> handler)` Gets the current health status of the specified backend server.
`Future<GetBackendSetResponse>`	`getBackendSet(GetBackendSetRequest request, AsyncHandler<GetBackendSetRequest,GetBackendSetResponse> handler)` Gets the specified backend set’s configuration information.
`Future<GetBackendSetHealthResponse>`	`getBackendSetHealth(GetBackendSetHealthRequest request, AsyncHandler<GetBackendSetHealthRequest,GetBackendSetHealthResponse> handler)` Gets the health status for the specified backend set.
`String`	`getEndpoint()` Gets the set endpoint for REST call (ex, https://www.example.com)
`Future<GetHealthCheckerResponse>`	`getHealthChecker(GetHealthCheckerRequest request, AsyncHandler<GetHealthCheckerRequest,GetHealthCheckerResponse> handler)` Gets the health check policy information for a given load balancer and backend set.
`Future<GetHostnameResponse>`	`getHostname(GetHostnameRequest request, AsyncHandler<GetHostnameRequest,GetHostnameResponse> handler)` Gets the specified hostname resource’s configuration information.
`Future<GetLoadBalancerResponse>`	`getLoadBalancer(GetLoadBalancerRequest request, AsyncHandler<GetLoadBalancerRequest,GetLoadBalancerResponse> handler)` Gets the specified load balancer’s configuration information.
`Future<GetLoadBalancerHealthResponse>`	`getLoadBalancerHealth(GetLoadBalancerHealthRequest request, AsyncHandler<GetLoadBalancerHealthRequest,GetLoadBalancerHealthResponse> handler)` Gets the health status for the specified load balancer.
`Future<GetPathRouteSetResponse>`	`getPathRouteSet(GetPathRouteSetRequest request, AsyncHandler<GetPathRouteSetRequest,GetPathRouteSetResponse> handler)` Gets the specified path route set’s configuration information.
`Future<GetRuleSetResponse>`	`getRuleSet(GetRuleSetRequest request, AsyncHandler<GetRuleSetRequest,GetRuleSetResponse> handler)` Gets the specified set of rules.
`Future<GetSSLCipherSuiteResponse>`	`getSSLCipherSuite(GetSSLCipherSuiteRequest request, AsyncHandler<GetSSLCipherSuiteRequest,GetSSLCipherSuiteResponse> handler)` Gets the specified SSL cipher suite’s configuration information.
`Future<GetWorkRequestResponse>`	`getWorkRequest(GetWorkRequestRequest request, AsyncHandler<GetWorkRequestRequest,GetWorkRequestResponse> handler)` Gets the details of a work request.
`Future<ListBackendsResponse>`	`listBackends(ListBackendsRequest request, AsyncHandler<ListBackendsRequest,ListBackendsResponse> handler)` Lists the backend servers for a given load balancer and backend set.
`Future<ListBackendSetsResponse>`	`listBackendSets(ListBackendSetsRequest request, AsyncHandler<ListBackendSetsRequest,ListBackendSetsResponse> handler)` Lists all backend sets associated with a given load balancer.
`Future<ListCertificatesResponse>`	`listCertificates(ListCertificatesRequest request, AsyncHandler<ListCertificatesRequest,ListCertificatesResponse> handler)` Lists all SSL certificates bundles associated with a given load balancer.
`Future<ListHostnamesResponse>`	`listHostnames(ListHostnamesRequest request, AsyncHandler<ListHostnamesRequest,ListHostnamesResponse> handler)` Lists all hostname resources associated with the specified load balancer.
`Future<ListListenerRulesResponse>`	`listListenerRules(ListListenerRulesRequest request, AsyncHandler<ListListenerRulesRequest,ListListenerRulesResponse> handler)` Lists all of the rules from all of the rule sets associated with the specified listener.
`Future<ListLoadBalancerHealthsResponse>`	`listLoadBalancerHealths(ListLoadBalancerHealthsRequest request, AsyncHandler<ListLoadBalancerHealthsRequest,ListLoadBalancerHealthsResponse> handler)` Lists the summary health statuses for all load balancers in the specified compartment.
`Future<ListLoadBalancersResponse>`	`listLoadBalancers(ListLoadBalancersRequest request, AsyncHandler<ListLoadBalancersRequest,ListLoadBalancersResponse> handler)` Lists all load balancers in the specified compartment.
`Future<ListPathRouteSetsResponse>`	`listPathRouteSets(ListPathRouteSetsRequest request, AsyncHandler<ListPathRouteSetsRequest,ListPathRouteSetsResponse> handler)` Lists all path route sets associated with the specified load balancer.
`Future<ListPoliciesResponse>`	`listPolicies(ListPoliciesRequest request, AsyncHandler<ListPoliciesRequest,ListPoliciesResponse> handler)` Lists the available load balancer policies.
`Future<ListProtocolsResponse>`	`listProtocols(ListProtocolsRequest request, AsyncHandler<ListProtocolsRequest,ListProtocolsResponse> handler)` Lists all supported traffic protocols.
`Future<ListRuleSetsResponse>`	`listRuleSets(ListRuleSetsRequest request, AsyncHandler<ListRuleSetsRequest,ListRuleSetsResponse> handler)` Lists all rule sets associated with the specified load balancer.
`Future<ListShapesResponse>`	`listShapes(ListShapesRequest request, AsyncHandler<ListShapesRequest,ListShapesResponse> handler)` Lists the valid load balancer shapes.
`Future<ListSSLCipherSuitesResponse>`	`listSSLCipherSuites(ListSSLCipherSuitesRequest request, AsyncHandler<ListSSLCipherSuitesRequest,ListSSLCipherSuitesResponse> handler)` Lists all SSL cipher suites associated with the specified load balancer.
`Future<ListWorkRequestsResponse>`	`listWorkRequests(ListWorkRequestsRequest request, AsyncHandler<ListWorkRequestsRequest,ListWorkRequestsResponse> handler)` Lists the work requests for a given load balancer.
`void`	`setEndpoint(String endpoint)` Sets the endpoint to call (ex, https://www.example.com).
`void`	`setRegion(Region region)` Sets the region to call (ex, Region.US_PHOENIX_1).
`void`	`setRegion(String regionId)` Sets the region to call (ex, ‘us-phoenix-1’).
`Future<UpdateBackendResponse>`	`updateBackend(UpdateBackendRequest request, AsyncHandler<UpdateBackendRequest,UpdateBackendResponse> handler)` Updates the configuration of a backend server within the specified backend set.
`Future<UpdateBackendSetResponse>`	`updateBackendSet(UpdateBackendSetRequest request, AsyncHandler<UpdateBackendSetRequest,UpdateBackendSetResponse> handler)` Updates a backend set.
`Future<UpdateHealthCheckerResponse>`	`updateHealthChecker(UpdateHealthCheckerRequest request, AsyncHandler<UpdateHealthCheckerRequest,UpdateHealthCheckerResponse> handler)` Updates the health check policy for a given load balancer and backend set.
`Future<UpdateHostnameResponse>`	`updateHostname(UpdateHostnameRequest request, AsyncHandler<UpdateHostnameRequest,UpdateHostnameResponse> handler)` Overwrites an existing hostname resource on the specified load balancer.
`Future<UpdateListenerResponse>`	`updateListener(UpdateListenerRequest request, AsyncHandler<UpdateListenerRequest,UpdateListenerResponse> handler)` Updates a listener for a given load balancer.
`Future<UpdateLoadBalancerResponse>`	`updateLoadBalancer(UpdateLoadBalancerRequest request, AsyncHandler<UpdateLoadBalancerRequest,UpdateLoadBalancerResponse> handler)` Updates a load balancer’s configuration.
`Future<UpdateLoadBalancerShapeResponse>`	`updateLoadBalancerShape(UpdateLoadBalancerShapeRequest request, AsyncHandler<UpdateLoadBalancerShapeRequest,UpdateLoadBalancerShapeResponse> handler)` Update the shape of a load balancer.
`Future<UpdateNetworkSecurityGroupsResponse>`	`updateNetworkSecurityGroups(UpdateNetworkSecurityGroupsRequest request, AsyncHandler<UpdateNetworkSecurityGroupsRequest,UpdateNetworkSecurityGroupsResponse> handler)` Updates the network security groups associated with the specified load balancer.
`Future<UpdatePathRouteSetResponse>`	`updatePathRouteSet(UpdatePathRouteSetRequest request, AsyncHandler<UpdatePathRouteSetRequest,UpdatePathRouteSetResponse> handler)` Overwrites an existing path route set on the specified load balancer.
`Future<UpdateRuleSetResponse>`	`updateRuleSet(UpdateRuleSetRequest request, AsyncHandler<UpdateRuleSetRequest,UpdateRuleSetResponse> handler)` Overwrites an existing set of rules on the specified load balancer.
`Future<UpdateSSLCipherSuiteResponse>`	`updateSSLCipherSuite(UpdateSSLCipherSuiteRequest request, AsyncHandler<UpdateSSLCipherSuiteRequest,UpdateSSLCipherSuiteResponse> handler)` Updates an existing SSL cipher suite for the specified load balancer.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - SERVICE
```
public static final Service SERVICE
```
    Service instance for LoadBalancer.
- Constructor Detail
  - LoadBalancerAsyncClient
```
public LoadBalancerAsyncClient(BasicAuthenticationDetailsProvider authenticationDetailsProvider)
```
    Creates a new service instance using the given authentication provider.
    
    Parameters:
    
    authenticationDetailsProvider - The authentication details provider, required.
  - LoadBalancerAsyncClient
```
public LoadBalancerAsyncClient(BasicAuthenticationDetailsProvider authenticationDetailsProvider,
                               ClientConfiguration configuration)
```
    Creates a new service instance using the given authentication provider and client configuration.
    
    Parameters:
    
    authenticationDetailsProvider - The authentication details provider, required.
    
    configuration - The client configuration, optional.
  - LoadBalancerAsyncClient
```
public LoadBalancerAsyncClient(BasicAuthenticationDetailsProvider authenticationDetailsProvider,
                               ClientConfiguration configuration,
                               ClientConfigurator clientConfigurator)
```
    Creates a new service instance using the given authentication provider and client configuration. Additionally, a Consumer can be provided that will be invoked whenever a REST Client is created to allow for additional configuration/customization.
    
    Parameters:
    
    authenticationDetailsProvider - The authentication details provider, required.
    
    configuration - The client configuration, optional.
    
    clientConfigurator - ClientConfigurator that will be invoked for additional configuration of a REST client, optional.
  - LoadBalancerAsyncClient
```
public LoadBalancerAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider,
                               ClientConfiguration configuration,
                               ClientConfigurator clientConfigurator,
                               RequestSignerFactory defaultRequestSignerFactory)
```
    Creates a new service instance using the given authentication provider and client configuration. Additionally, a Consumer can be provided that will be invoked whenever a REST Client is created to allow for additional configuration/customization.
    
    This is an advanced constructor for clients that want to take control over how requests are signed.
    
    Parameters:
    
    authenticationDetailsProvider - The authentication details provider, required.
    
    configuration - The client configuration, optional.
    
    clientConfigurator - ClientConfigurator that will be invoked for additional configuration of a REST client, optional.
    
    defaultRequestSignerFactory - The request signer factory used to create the request signer for this service.
  - LoadBalancerAsyncClient
```
public LoadBalancerAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider,
                               ClientConfiguration configuration,
                               ClientConfigurator clientConfigurator,
                               RequestSignerFactory defaultRequestSignerFactory,
                               List<ClientConfigurator> additionalClientConfigurators)
```
    Creates a new service instance using the given authentication provider and client configuration. Additionally, a Consumer can be provided that will be invoked whenever a REST Client is created to allow for additional configuration/customization.
    
    This is an advanced constructor for clients that want to take control over how requests are signed.
    
    Parameters:
    
    authenticationDetailsProvider - The authentication details provider, required.
    
    configuration - The client configuration, optional.
    
    clientConfigurator - ClientConfigurator that will be invoked for additional configuration of a REST client, optional.
    
    defaultRequestSignerFactory - The request signer factory used to create the request signer for this service.
    
    additionalClientConfigurators - Additional client configurators to be run after the primary configurator.
  - LoadBalancerAsyncClient
```
public LoadBalancerAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider,
                               ClientConfiguration configuration,
                               ClientConfigurator clientConfigurator,
                               RequestSignerFactory defaultRequestSignerFactory,
                               List<ClientConfigurator> additionalClientConfigurators,
                               String endpoint)
```
    Creates a new service instance using the given authentication provider and client configuration. Additionally, a Consumer can be provided that will be invoked whenever a REST Client is created to allow for additional configuration/customization.
    
    This is an advanced constructor for clients that want to take control over how requests are signed.
    
    Parameters:
    
    authenticationDetailsProvider - The authentication details provider, required.
    
    configuration - The client configuration, optional.
    
    clientConfigurator - ClientConfigurator that will be invoked for additional configuration of a REST client, optional.
    
    defaultRequestSignerFactory - The request signer factory used to create the request signer for this service.
    
    additionalClientConfigurators - Additional client configurators to be run after the primary configurator.
    
    endpoint - Endpoint, or null to leave unset (note, may be overridden by authenticationDetailsProvider)
  - LoadBalancerAsyncClient
```
public LoadBalancerAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider,
                               ClientConfiguration configuration,
                               ClientConfigurator clientConfigurator,
                               RequestSignerFactory defaultRequestSignerFactory,
                               Map<SigningStrategy,RequestSignerFactory> signingStrategyRequestSignerFactories,
                               List<ClientConfigurator> additionalClientConfigurators,
                               String endpoint)
```
    Creates a new service instance using the given authentication provider and client configuration. Additionally, a Consumer can be provided that will be invoked whenever a REST Client is created to allow for additional configuration/customization.
    
    This is an advanced constructor for clients that want to take control over how requests are signed.
    
    Parameters:
    
    authenticationDetailsProvider - The authentication details provider, required.
    
    configuration - The client configuration, optional.
    
    clientConfigurator - ClientConfigurator that will be invoked for additional configuration of a REST client, optional.
    
    defaultRequestSignerFactory - The request signer factory used to create the request signer for this service.
    
    signingStrategyRequestSignerFactories - The request signer factories for each signing strategy used to create the request signer
    
    additionalClientConfigurators - Additional client configurators to be run after the primary configurator.
    
    endpoint - Endpoint, or null to leave unset (note, may be overridden by authenticationDetailsProvider)
  - LoadBalancerAsyncClient
```
public LoadBalancerAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider,
                               ClientConfiguration configuration,
                               ClientConfigurator clientConfigurator,
                               RequestSignerFactory defaultRequestSignerFactory,
                               Map<SigningStrategy,RequestSignerFactory> signingStrategyRequestSignerFactories,
                               List<ClientConfigurator> additionalClientConfigurators,
                               String endpoint,
                               com.oracle.bmc.http.internal.RestClientFactoryBuilder restClientFactoryBuilder)
```
    Creates a new service instance using the given authentication provider and client configuration. Additionally, a Consumer can be provided that will be invoked whenever a REST Client is created to allow for additional configuration/customization.
    
    This is an advanced constructor for clients that want to take control over how requests are signed.
    
    Parameters:
    
    authenticationDetailsProvider - The authentication details provider, required.
    
    configuration - The client configuration, optional.
    
    clientConfigurator - ClientConfigurator that will be invoked for additional configuration of a REST client, optional.
    
    defaultRequestSignerFactory - The request signer factory used to create the request signer for this service.
    
    signingStrategyRequestSignerFactories - The request signer factories for each signing strategy used to create the request signer
    
    additionalClientConfigurators - Additional client configurators to be run after the primary configurator.
    
    endpoint - Endpoint, or null to leave unset (note, may be overridden by authenticationDetailsProvider)
    
    restClientFactoryBuilder - the builder for the RestClientFactory
- Method Detail
  - builder
```
public static LoadBalancerAsyncClient.Builder builder()
```
    Create a builder for this client.
    
    Returns:
    
    builder
  - setEndpoint
```
public void setEndpoint(String endpoint)
```
    Description copied from interface: LoadBalancerAsync
    
    Sets the endpoint to call (ex, https://www.example.com).
    
    Specified by:
    
    setEndpoint in interface LoadBalancerAsync
    
    Parameters:
    
    endpoint - The endpoint of the serice.
  - getEndpoint
```
public String getEndpoint()
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the set endpoint for REST call (ex, https://www.example.com)
    
    Specified by:
    
    getEndpoint in interface LoadBalancerAsync
  - setRegion
```
public void setRegion(Region region)
```
    Description copied from interface: LoadBalancerAsync
    
    Sets the region to call (ex, Region.US_PHOENIX_1).
    
    Note, this will call setEndpoint after resolving the endpoint. If the service is not available in this region, however, an IllegalArgumentException will be raised.
    
    Specified by:
    
    setRegion in interface LoadBalancerAsync
    
    Parameters:
    
    region - The region of the service.
  - setRegion
```
public void setRegion(String regionId)
```
    Description copied from interface: LoadBalancerAsync
    
    Sets the region to call (ex, ‘us-phoenix-1’).
    
    Note, this will first try to map the region ID to a known Region and call setRegion.
    If no known Region could be determined, it will create an endpoint based on the default endpoint format (Region.formatDefaultRegionEndpoint(Service, String) and then call setEndpoint.
    
    Specified by:
    
    setRegion in interface LoadBalancerAsync
    
    Parameters:
    
    regionId - The public region ID.
  - close
```
public void close()
```
    Specified by:
    
    close in interface AutoCloseable
  - changeLoadBalancerCompartment
```
public Future<ChangeLoadBalancerCompartmentResponse> changeLoadBalancerCompartment(ChangeLoadBalancerCompartmentRequest request,
                                                                                   AsyncHandler<ChangeLoadBalancerCompartmentRequest,ChangeLoadBalancerCompartmentResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Moves a load balancer into a different compartment within the same tenancy. For information about moving resources between compartments, see Moving Resources to a Different Compartment.
    
    Specified by:
    
    changeLoadBalancerCompartment in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createBackend
```
public Future<CreateBackendResponse> createBackend(CreateBackendRequest request,
                                                   AsyncHandler<CreateBackendRequest,CreateBackendResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Adds a backend server to a backend set.
    
    Specified by:
    
    createBackend in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createBackendSet
```
public Future<CreateBackendSetResponse> createBackendSet(CreateBackendSetRequest request,
                                                         AsyncHandler<CreateBackendSetRequest,CreateBackendSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Adds a backend set to a load balancer.
    
    Specified by:
    
    createBackendSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createCertificate
```
public Future<CreateCertificateResponse> createCertificate(CreateCertificateRequest request,
                                                           AsyncHandler<CreateCertificateRequest,CreateCertificateResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Creates an asynchronous request to add an SSL certificate bundle.
    
    Specified by:
    
    createCertificate in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createHostname
```
public Future<CreateHostnameResponse> createHostname(CreateHostnameRequest request,
                                                     AsyncHandler<CreateHostnameRequest,CreateHostnameResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Adds a hostname resource to the specified load balancer. For more information, see Managing Request Routing.
    
    Specified by:
    
    createHostname in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createListener
```
public Future<CreateListenerResponse> createListener(CreateListenerRequest request,
                                                     AsyncHandler<CreateListenerRequest,CreateListenerResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Adds a listener to a load balancer.
    
    Specified by:
    
    createListener in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createLoadBalancer
```
public Future<CreateLoadBalancerResponse> createLoadBalancer(CreateLoadBalancerRequest request,
                                                             AsyncHandler<CreateLoadBalancerRequest,CreateLoadBalancerResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Creates a new load balancer in the specified compartment. For general information about load balancers, see Overview of the Load Balancing Service.
    
    For the purposes of access control, you must provide the OCID of the compartment where you want the load balancer to reside. Notice that the load balancer doesn't have to be in the same compartment as the VCN or backend set. If you're not sure which compartment to use, put the load balancer in the same compartment as the VCN. For information about access control and compartments, see [Overview of the IAM Service](https://docs.cloud.oracle.com/Content/Identity/Concepts/overview.htm).
    You must specify a display name for the load balancer. It does not have to be unique, and you can change it.
    For information about Availability Domains, see [Regions and Availability Domains](https://docs.cloud.oracle.com/Content/General/Concepts/regions.htm). To get a list of Availability Domains, use the `ListAvailabilityDomains` operation in the Identity and Access Management Service API.
    All Oracle Cloud Infrastructure resources, including load balancers, get an Oracle-assigned, unique ID called an Oracle Cloud Identifier (OCID). When you create a resource, you can find its OCID in the response. You can also retrieve a resource's OCID by using a List API operation on that resource type, or by viewing the resource in the Console. Fore more information, see [Resource Identifiers](https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm).
    After you send your request, the new object's state will temporarily be PROVISIONING. Before using the object, first make sure its state has changed to RUNNING.
    When you create a load balancer, the system assigns an IP address. To get the IP address, use the getLoadBalancer operation.
    
    Specified by:
    
    createLoadBalancer in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createPathRouteSet
```
public Future<CreatePathRouteSetResponse> createPathRouteSet(CreatePathRouteSetRequest request,
                                                             AsyncHandler<CreatePathRouteSetRequest,CreatePathRouteSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Adds a path route set to a load balancer. For more information, see Managing Request Routing.
    
    Specified by:
    
    createPathRouteSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createRuleSet
```
public Future<CreateRuleSetResponse> createRuleSet(CreateRuleSetRequest request,
                                                   AsyncHandler<CreateRuleSetRequest,CreateRuleSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Creates a new rule set associated with the specified load balancer. For more information, see Managing Rule Sets.
    
    Specified by:
    
    createRuleSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createSSLCipherSuite
```
public Future<CreateSSLCipherSuiteResponse> createSSLCipherSuite(CreateSSLCipherSuiteRequest request,
                                                                 AsyncHandler<CreateSSLCipherSuiteRequest,CreateSSLCipherSuiteResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Creates a custom SSL cipher suite.
    
    Specified by:
    
    createSSLCipherSuite in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteBackend
```
public Future<DeleteBackendResponse> deleteBackend(DeleteBackendRequest request,
                                                   AsyncHandler<DeleteBackendRequest,DeleteBackendResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Removes a backend server from a given load balancer and backend set.
    
    Specified by:
    
    deleteBackend in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteBackendSet
```
public Future<DeleteBackendSetResponse> deleteBackendSet(DeleteBackendSetRequest request,
                                                         AsyncHandler<DeleteBackendSetRequest,DeleteBackendSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Deletes the specified backend set. Note that deleting a backend set removes its backend servers from the load balancer.
    
    Before you can delete a backend set, you must remove it from any active listeners.
    
    Specified by:
    
    deleteBackendSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteCertificate
```
public Future<DeleteCertificateResponse> deleteCertificate(DeleteCertificateRequest request,
                                                           AsyncHandler<DeleteCertificateRequest,DeleteCertificateResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Deletes an SSL certificate bundle from a load balancer.
    
    Specified by:
    
    deleteCertificate in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteHostname
```
public Future<DeleteHostnameResponse> deleteHostname(DeleteHostnameRequest request,
                                                     AsyncHandler<DeleteHostnameRequest,DeleteHostnameResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Deletes a hostname resource from the specified load balancer.
    
    Specified by:
    
    deleteHostname in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteListener
```
public Future<DeleteListenerResponse> deleteListener(DeleteListenerRequest request,
                                                     AsyncHandler<DeleteListenerRequest,DeleteListenerResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Deletes a listener from a load balancer.
    
    Specified by:
    
    deleteListener in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteLoadBalancer
```
public Future<DeleteLoadBalancerResponse> deleteLoadBalancer(DeleteLoadBalancerRequest request,
                                                             AsyncHandler<DeleteLoadBalancerRequest,DeleteLoadBalancerResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Stops a load balancer and removes it from service.
    
    Specified by:
    
    deleteLoadBalancer in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deletePathRouteSet
```
public Future<DeletePathRouteSetResponse> deletePathRouteSet(DeletePathRouteSetRequest request,
                                                             AsyncHandler<DeletePathRouteSetRequest,DeletePathRouteSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Deletes a path route set from the specified load balancer.
    
    To delete a path route rule from a path route set, use the updatePathRouteSet operation.
    
    Specified by:
    
    deletePathRouteSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteRuleSet
```
public Future<DeleteRuleSetResponse> deleteRuleSet(DeleteRuleSetRequest request,
                                                   AsyncHandler<DeleteRuleSetRequest,DeleteRuleSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Deletes a rule set from the specified load balancer.
    
    To delete a rule from a rule set, use the updateRuleSet operation.
    
    Specified by:
    
    deleteRuleSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteSSLCipherSuite
```
public Future<DeleteSSLCipherSuiteResponse> deleteSSLCipherSuite(DeleteSSLCipherSuiteRequest request,
                                                                 AsyncHandler<DeleteSSLCipherSuiteRequest,DeleteSSLCipherSuiteResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Deletes an SSL cipher suite from a load balancer.
    
    Specified by:
    
    deleteSSLCipherSuite in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getBackend
```
public Future<GetBackendResponse> getBackend(GetBackendRequest request,
                                             AsyncHandler<GetBackendRequest,GetBackendResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the specified backend server’s configuration information.
    
    Specified by:
    
    getBackend in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getBackendHealth
```
public Future<GetBackendHealthResponse> getBackendHealth(GetBackendHealthRequest request,
                                                         AsyncHandler<GetBackendHealthRequest,GetBackendHealthResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the current health status of the specified backend server.
    
    Specified by:
    
    getBackendHealth in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getBackendSet
```
public Future<GetBackendSetResponse> getBackendSet(GetBackendSetRequest request,
                                                   AsyncHandler<GetBackendSetRequest,GetBackendSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the specified backend set’s configuration information.
    
    Specified by:
    
    getBackendSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getBackendSetHealth
```
public Future<GetBackendSetHealthResponse> getBackendSetHealth(GetBackendSetHealthRequest request,
                                                               AsyncHandler<GetBackendSetHealthRequest,GetBackendSetHealthResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the health status for the specified backend set.
    
    Specified by:
    
    getBackendSetHealth in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getHealthChecker
```
public Future<GetHealthCheckerResponse> getHealthChecker(GetHealthCheckerRequest request,
                                                         AsyncHandler<GetHealthCheckerRequest,GetHealthCheckerResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the health check policy information for a given load balancer and backend set.
    
    Specified by:
    
    getHealthChecker in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getHostname
```
public Future<GetHostnameResponse> getHostname(GetHostnameRequest request,
                                               AsyncHandler<GetHostnameRequest,GetHostnameResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the specified hostname resource’s configuration information.
    
    Specified by:
    
    getHostname in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getLoadBalancer
```
public Future<GetLoadBalancerResponse> getLoadBalancer(GetLoadBalancerRequest request,
                                                       AsyncHandler<GetLoadBalancerRequest,GetLoadBalancerResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the specified load balancer’s configuration information.
    
    Specified by:
    
    getLoadBalancer in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getLoadBalancerHealth
```
public Future<GetLoadBalancerHealthResponse> getLoadBalancerHealth(GetLoadBalancerHealthRequest request,
                                                                   AsyncHandler<GetLoadBalancerHealthRequest,GetLoadBalancerHealthResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the health status for the specified load balancer.
    
    Specified by:
    
    getLoadBalancerHealth in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getPathRouteSet
```
public Future<GetPathRouteSetResponse> getPathRouteSet(GetPathRouteSetRequest request,
                                                       AsyncHandler<GetPathRouteSetRequest,GetPathRouteSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the specified path route set’s configuration information.
    
    Specified by:
    
    getPathRouteSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getRuleSet
```
public Future<GetRuleSetResponse> getRuleSet(GetRuleSetRequest request,
                                             AsyncHandler<GetRuleSetRequest,GetRuleSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the specified set of rules.
    
    Specified by:
    
    getRuleSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getSSLCipherSuite
```
public Future<GetSSLCipherSuiteResponse> getSSLCipherSuite(GetSSLCipherSuiteRequest request,
                                                           AsyncHandler<GetSSLCipherSuiteRequest,GetSSLCipherSuiteResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the specified SSL cipher suite’s configuration information.
    
    Specified by:
    
    getSSLCipherSuite in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getWorkRequest
```
public Future<GetWorkRequestResponse> getWorkRequest(GetWorkRequestRequest request,
                                                     AsyncHandler<GetWorkRequestRequest,GetWorkRequestResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the details of a work request.
    
    Specified by:
    
    getWorkRequest in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listBackendSets
```
public Future<ListBackendSetsResponse> listBackendSets(ListBackendSetsRequest request,
                                                       AsyncHandler<ListBackendSetsRequest,ListBackendSetsResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists all backend sets associated with a given load balancer.
    
    Specified by:
    
    listBackendSets in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listBackends
```
public Future<ListBackendsResponse> listBackends(ListBackendsRequest request,
                                                 AsyncHandler<ListBackendsRequest,ListBackendsResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists the backend servers for a given load balancer and backend set.
    
    Specified by:
    
    listBackends in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listCertificates
```
public Future<ListCertificatesResponse> listCertificates(ListCertificatesRequest request,
                                                         AsyncHandler<ListCertificatesRequest,ListCertificatesResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists all SSL certificates bundles associated with a given load balancer.
    
    Specified by:
    
    listCertificates in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listHostnames
```
public Future<ListHostnamesResponse> listHostnames(ListHostnamesRequest request,
                                                   AsyncHandler<ListHostnamesRequest,ListHostnamesResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists all hostname resources associated with the specified load balancer.
    
    Specified by:
    
    listHostnames in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listListenerRules
```
public Future<ListListenerRulesResponse> listListenerRules(ListListenerRulesRequest request,
                                                           AsyncHandler<ListListenerRulesRequest,ListListenerRulesResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists all of the rules from all of the rule sets associated with the specified listener. The response organizes the rules in the following order:
    
    Access control rules * Allow method rules * Request header rules * Response header rules
    
    Specified by:
    
    listListenerRules in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listLoadBalancerHealths
```
public Future<ListLoadBalancerHealthsResponse> listLoadBalancerHealths(ListLoadBalancerHealthsRequest request,
                                                                       AsyncHandler<ListLoadBalancerHealthsRequest,ListLoadBalancerHealthsResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists the summary health statuses for all load balancers in the specified compartment.
    
    Specified by:
    
    listLoadBalancerHealths in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listLoadBalancers
```
public Future<ListLoadBalancersResponse> listLoadBalancers(ListLoadBalancersRequest request,
                                                           AsyncHandler<ListLoadBalancersRequest,ListLoadBalancersResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists all load balancers in the specified compartment.
    
    Specified by:
    
    listLoadBalancers in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listPathRouteSets
```
public Future<ListPathRouteSetsResponse> listPathRouteSets(ListPathRouteSetsRequest request,
                                                           AsyncHandler<ListPathRouteSetsRequest,ListPathRouteSetsResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists all path route sets associated with the specified load balancer.
    
    Specified by:
    
    listPathRouteSets in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listPolicies
```
public Future<ListPoliciesResponse> listPolicies(ListPoliciesRequest request,
                                                 AsyncHandler<ListPoliciesRequest,ListPoliciesResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists the available load balancer policies.
    
    Specified by:
    
    listPolicies in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listProtocols
```
public Future<ListProtocolsResponse> listProtocols(ListProtocolsRequest request,
                                                   AsyncHandler<ListProtocolsRequest,ListProtocolsResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists all supported traffic protocols.
    
    Specified by:
    
    listProtocols in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listRuleSets
```
public Future<ListRuleSetsResponse> listRuleSets(ListRuleSetsRequest request,
                                                 AsyncHandler<ListRuleSetsRequest,ListRuleSetsResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists all rule sets associated with the specified load balancer.
    
    Specified by:
    
    listRuleSets in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listSSLCipherSuites
```
public Future<ListSSLCipherSuitesResponse> listSSLCipherSuites(ListSSLCipherSuitesRequest request,
                                                               AsyncHandler<ListSSLCipherSuitesRequest,ListSSLCipherSuitesResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists all SSL cipher suites associated with the specified load balancer.
    
    Specified by:
    
    listSSLCipherSuites in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listShapes
```
public Future<ListShapesResponse> listShapes(ListShapesRequest request,
                                             AsyncHandler<ListShapesRequest,ListShapesResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists the valid load balancer shapes.
    
    Specified by:
    
    listShapes in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listWorkRequests
```
public Future<ListWorkRequestsResponse> listWorkRequests(ListWorkRequestsRequest request,
                                                         AsyncHandler<ListWorkRequestsRequest,ListWorkRequestsResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists the work requests for a given load balancer.
    
    Specified by:
    
    listWorkRequests in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateBackend
```
public Future<UpdateBackendResponse> updateBackend(UpdateBackendRequest request,
                                                   AsyncHandler<UpdateBackendRequest,UpdateBackendResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Updates the configuration of a backend server within the specified backend set.
    
    Specified by:
    
    updateBackend in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateBackendSet
```
public Future<UpdateBackendSetResponse> updateBackendSet(UpdateBackendSetRequest request,
                                                         AsyncHandler<UpdateBackendSetRequest,UpdateBackendSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Updates a backend set.
    
    Specified by:
    
    updateBackendSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateHealthChecker
```
public Future<UpdateHealthCheckerResponse> updateHealthChecker(UpdateHealthCheckerRequest request,
                                                               AsyncHandler<UpdateHealthCheckerRequest,UpdateHealthCheckerResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Updates the health check policy for a given load balancer and backend set.
    
    Specified by:
    
    updateHealthChecker in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateHostname
```
public Future<UpdateHostnameResponse> updateHostname(UpdateHostnameRequest request,
                                                     AsyncHandler<UpdateHostnameRequest,UpdateHostnameResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Overwrites an existing hostname resource on the specified load balancer. Use this operation to change a virtual hostname.
    
    Specified by:
    
    updateHostname in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateListener
```
public Future<UpdateListenerResponse> updateListener(UpdateListenerRequest request,
                                                     AsyncHandler<UpdateListenerRequest,UpdateListenerResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Updates a listener for a given load balancer.
    
    Specified by:
    
    updateListener in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateLoadBalancer
```
public Future<UpdateLoadBalancerResponse> updateLoadBalancer(UpdateLoadBalancerRequest request,
                                                             AsyncHandler<UpdateLoadBalancerRequest,UpdateLoadBalancerResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Updates a load balancer’s configuration.
    
    Specified by:
    
    updateLoadBalancer in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateLoadBalancerShape
```
public Future<UpdateLoadBalancerShapeResponse> updateLoadBalancerShape(UpdateLoadBalancerShapeRequest request,
                                                                       AsyncHandler<UpdateLoadBalancerShapeRequest,UpdateLoadBalancerShapeResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Update the shape of a load balancer. The new shape can be larger or smaller compared to existing shape of the LB. The service will try to perform this operation in the least disruptive way to existing connections, but there is a possibility that they might be lost during the LB resizing process. The new shape becomes effective as soon as the related work request completes successfully, i.e. when reshaping to a larger shape, the LB will start accepting larger bandwidth and when reshaping to a smaller one, the LB will be accepting smaller bandwidth.
    
    Specified by:
    
    updateLoadBalancerShape in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateNetworkSecurityGroups
```
public Future<UpdateNetworkSecurityGroupsResponse> updateNetworkSecurityGroups(UpdateNetworkSecurityGroupsRequest request,
                                                                               AsyncHandler<UpdateNetworkSecurityGroupsRequest,UpdateNetworkSecurityGroupsResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Updates the network security groups associated with the specified load balancer.
    
    Specified by:
    
    updateNetworkSecurityGroups in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updatePathRouteSet
```
public Future<UpdatePathRouteSetResponse> updatePathRouteSet(UpdatePathRouteSetRequest request,
                                                             AsyncHandler<UpdatePathRouteSetRequest,UpdatePathRouteSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Overwrites an existing path route set on the specified load balancer. Use this operation to add, delete, or alter path route rules in a path route set.
    
    To add a new path route rule to a path route set, the `pathRoutes` in the updatePathRouteSetDetails object must include both the new path route rule to add and the existing path route rules to retain.
    
    Specified by:
    
    updatePathRouteSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateRuleSet
```
public Future<UpdateRuleSetResponse> updateRuleSet(UpdateRuleSetRequest request,
                                                   AsyncHandler<UpdateRuleSetRequest,UpdateRuleSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Overwrites an existing set of rules on the specified load balancer. Use this operation to add or alter the rules in a rule set.
    
    To add a new rule to a set, the body must include both the new rule to add and the existing rules to retain.
    
    Specified by:
    
    updateRuleSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateSSLCipherSuite
```
public Future<UpdateSSLCipherSuiteResponse> updateSSLCipherSuite(UpdateSSLCipherSuiteRequest request,
                                                                 AsyncHandler<UpdateSSLCipherSuiteRequest,UpdateSSLCipherSuiteResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Updates an existing SSL cipher suite for the specified load balancer.
    
    Specified by:
    
    updateSSLCipherSuite in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

Class LoadBalancerAsyncClient

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

SERVICE

Constructor Detail

LoadBalancerAsyncClient

LoadBalancerAsyncClient

LoadBalancerAsyncClient

LoadBalancerAsyncClient

LoadBalancerAsyncClient

LoadBalancerAsyncClient

LoadBalancerAsyncClient

LoadBalancerAsyncClient

Method Detail

builder

setEndpoint

getEndpoint

setRegion

setRegion

close

changeLoadBalancerCompartment

createBackend

createBackendSet

createCertificate

createHostname

createListener

createLoadBalancer

createPathRouteSet

createRuleSet

createSSLCipherSuite

deleteBackend

deleteBackendSet

deleteCertificate

deleteHostname

deleteListener

deleteLoadBalancer

deletePathRouteSet

deleteRuleSet

deleteSSLCipherSuite

getBackend

getBackendHealth

getBackendSet

getBackendSetHealth

getHealthChecker

getHostname

getLoadBalancer

getLoadBalancerHealth

getPathRouteSet

getRuleSet

getSSLCipherSuite

getWorkRequest

listBackendSets

listBackends

listCertificates

listHostnames

listListenerRules

listLoadBalancerHealths

listLoadBalancers

listPathRouteSets

listPolicies

listProtocols

listRuleSets

listSSLCipherSuites

listShapes

listWorkRequests

updateBackend

updateBackendSet

updateHealthChecker

updateHostname

updateListener

updateLoadBalancer

updateLoadBalancerShape

updateNetworkSecurityGroups

updatePathRouteSet

updateRuleSet

updateSSLCipherSuite