func (c *ELB) DeregisterInstancesFromLoadBalancerRequest(input *DeregisterInstancesFromLoadBalancerInput) (req *request.Request, output *DeregisterInstancesFromLoadBalancerOutput) {
	op := &request.Operation{
		Name:       opDeregisterInstancesFromLoadBalancer,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeregisterInstancesFromLoadBalancerInput{}
	}
	req = c.newRequest(op, input, output)
	output = &DeregisterInstancesFromLoadBalancerOutput{}
	req.Data = output
	return
}
DeregisterInstancesFromLoadBalancerRequest generates a "aws/request.Request" representing the
client's request for the DeregisterInstancesFromLoadBalancer operation. The "output" return
value can be used to capture response data after the request's "Send" method
is called.

See DeregisterInstancesFromLoadBalancer for usage and error information.

Creating a request object using this method should be used when you want to inject
custom logic into the request's lifecycle using a custom handler, or if you want to
access properties on the request object before or after sending the request. If
you just want the service response, call the DeregisterInstancesFromLoadBalancer method directly
instead.

Note: You must call the "Send" method on the returned request object in order
to execute the request.

// Example sending a request using the DeregisterInstancesFromLoadBalancerRequest method.
req, resp := client.DeregisterInstancesFromLoadBalancerRequest(params)

err := req.Send()
if err == nil { // resp is now filled
fmt.Println(resp)
}
package elb
import (
	"fmt"
	"time"
	"github.com/aws/aws-sdk-go/aws/awsutil"
	"github.com/aws/aws-sdk-go/aws/request"
)
const opAddTags = "AddTags"
func (c *ELB) AddTagsRequest(input *AddTagsInput) (req *request.Request, output *AddTagsOutput) {
	op := &request.Operation{
		Name:       opAddTags,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AddTagsInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AddTagsOutput{}
	req.Data = output
	return
}
func (c *ELB) AddTags(input *AddTagsInput) (*AddTagsOutput, error) {
	req, out := c.AddTagsRequest(input)
	err := req.Send()
	return out, err
}
const opApplySecurityGroupsToLoadBalancer = "ApplySecurityGroupsToLoadBalancer"
func (c *ELB) ApplySecurityGroupsToLoadBalancerRequest(input *ApplySecurityGroupsToLoadBalancerInput) (req *request.Request, output *ApplySecurityGroupsToLoadBalancerOutput) {
	op := &request.Operation{
		Name:       opApplySecurityGroupsToLoadBalancer,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &ApplySecurityGroupsToLoadBalancerInput{}
	}
	req = c.newRequest(op, input, output)
	output = &ApplySecurityGroupsToLoadBalancerOutput{}
	req.Data = output
	return
}
func (c *ELB) ApplySecurityGroupsToLoadBalancer(input *ApplySecurityGroupsToLoadBalancerInput) (*ApplySecurityGroupsToLoadBalancerOutput, error) {
	req, out := c.ApplySecurityGroupsToLoadBalancerRequest(input)
	err := req.Send()
	return out, err
}
const opAttachLoadBalancerToSubnets = "AttachLoadBalancerToSubnets"
func (c *ELB) AttachLoadBalancerToSubnetsRequest(input *AttachLoadBalancerToSubnetsInput) (req *request.Request, output *AttachLoadBalancerToSubnetsOutput) {
	op := &request.Operation{
		Name:       opAttachLoadBalancerToSubnets,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AttachLoadBalancerToSubnetsInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AttachLoadBalancerToSubnetsOutput{}
	req.Data = output
	return
}
func (c *ELB) AttachLoadBalancerToSubnets(input *AttachLoadBalancerToSubnetsInput) (*AttachLoadBalancerToSubnetsOutput, error) {
	req, out := c.AttachLoadBalancerToSubnetsRequest(input)
	err := req.Send()
	return out, err
}
const opConfigureHealthCheck = "ConfigureHealthCheck"
func (c *ELB) ConfigureHealthCheckRequest(input *ConfigureHealthCheckInput) (req *request.Request, output *ConfigureHealthCheckOutput) {
	op := &request.Operation{
		Name:       opConfigureHealthCheck,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &ConfigureHealthCheckInput{}
	}
	req = c.newRequest(op, input, output)
	output = &ConfigureHealthCheckOutput{}
	req.Data = output
	return
}
func (c *ELB) ConfigureHealthCheck(input *ConfigureHealthCheckInput) (*ConfigureHealthCheckOutput, error) {
	req, out := c.ConfigureHealthCheckRequest(input)
	err := req.Send()
	return out, err
}
const opCreateAppCookieStickinessPolicy = "CreateAppCookieStickinessPolicy"
func (c *ELB) CreateAppCookieStickinessPolicyRequest(input *CreateAppCookieStickinessPolicyInput) (req *request.Request, output *CreateAppCookieStickinessPolicyOutput) {
	op := &request.Operation{
		Name:       opCreateAppCookieStickinessPolicy,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateAppCookieStickinessPolicyInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateAppCookieStickinessPolicyOutput{}
	req.Data = output
	return
}
func (c *ELB) CreateAppCookieStickinessPolicy(input *CreateAppCookieStickinessPolicyInput) (*CreateAppCookieStickinessPolicyOutput, error) {
	req, out := c.CreateAppCookieStickinessPolicyRequest(input)
	err := req.Send()
	return out, err
}
const opCreateLBCookieStickinessPolicy = "CreateLBCookieStickinessPolicy"
func (c *ELB) CreateLBCookieStickinessPolicyRequest(input *CreateLBCookieStickinessPolicyInput) (req *request.Request, output *CreateLBCookieStickinessPolicyOutput) {
	op := &request.Operation{
		Name:       opCreateLBCookieStickinessPolicy,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateLBCookieStickinessPolicyInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateLBCookieStickinessPolicyOutput{}
	req.Data = output
	return
}
func (c *ELB) CreateLBCookieStickinessPolicy(input *CreateLBCookieStickinessPolicyInput) (*CreateLBCookieStickinessPolicyOutput, error) {
	req, out := c.CreateLBCookieStickinessPolicyRequest(input)
	err := req.Send()
	return out, err
}
const opCreateLoadBalancer = "CreateLoadBalancer"
func (c *ELB) CreateLoadBalancerRequest(input *CreateLoadBalancerInput) (req *request.Request, output *CreateLoadBalancerOutput) {
	op := &request.Operation{
		Name:       opCreateLoadBalancer,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateLoadBalancerInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateLoadBalancerOutput{}
	req.Data = output
	return
}
func (c *ELB) CreateLoadBalancer(input *CreateLoadBalancerInput) (*CreateLoadBalancerOutput, error) {
	req, out := c.CreateLoadBalancerRequest(input)
	err := req.Send()
	return out, err
}
const opCreateLoadBalancerListeners = "CreateLoadBalancerListeners"
func (c *ELB) CreateLoadBalancerListenersRequest(input *CreateLoadBalancerListenersInput) (req *request.Request, output *CreateLoadBalancerListenersOutput) {
	op := &request.Operation{
		Name:       opCreateLoadBalancerListeners,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateLoadBalancerListenersInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateLoadBalancerListenersOutput{}
	req.Data = output
	return
}
func (c *ELB) CreateLoadBalancerListeners(input *CreateLoadBalancerListenersInput) (*CreateLoadBalancerListenersOutput, error) {
	req, out := c.CreateLoadBalancerListenersRequest(input)
	err := req.Send()
	return out, err
}
const opCreateLoadBalancerPolicy = "CreateLoadBalancerPolicy"
func (c *ELB) CreateLoadBalancerPolicyRequest(input *CreateLoadBalancerPolicyInput) (req *request.Request, output *CreateLoadBalancerPolicyOutput) {
	op := &request.Operation{
		Name:       opCreateLoadBalancerPolicy,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateLoadBalancerPolicyInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateLoadBalancerPolicyOutput{}
	req.Data = output
	return
}
func (c *ELB) CreateLoadBalancerPolicy(input *CreateLoadBalancerPolicyInput) (*CreateLoadBalancerPolicyOutput, error) {
	req, out := c.CreateLoadBalancerPolicyRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteLoadBalancer = "DeleteLoadBalancer"
func (c *ELB) DeleteLoadBalancerRequest(input *DeleteLoadBalancerInput) (req *request.Request, output *DeleteLoadBalancerOutput) {
	op := &request.Operation{
		Name:       opDeleteLoadBalancer,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeleteLoadBalancerInput{}
	}
	req = c.newRequest(op, input, output)
	output = &DeleteLoadBalancerOutput{}
	req.Data = output
	return
}
func (c *ELB) DeleteLoadBalancer(input *DeleteLoadBalancerInput) (*DeleteLoadBalancerOutput, error) {
	req, out := c.DeleteLoadBalancerRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteLoadBalancerListeners = "DeleteLoadBalancerListeners"
func (c *ELB) DeleteLoadBalancerListenersRequest(input *DeleteLoadBalancerListenersInput) (req *request.Request, output *DeleteLoadBalancerListenersOutput) {
	op := &request.Operation{
		Name:       opDeleteLoadBalancerListeners,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeleteLoadBalancerListenersInput{}
	}
	req = c.newRequest(op, input, output)
	output = &DeleteLoadBalancerListenersOutput{}
	req.Data = output
	return
}
func (c *ELB) DeleteLoadBalancerListeners(input *DeleteLoadBalancerListenersInput) (*DeleteLoadBalancerListenersOutput, error) {
	req, out := c.DeleteLoadBalancerListenersRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteLoadBalancerPolicy = "DeleteLoadBalancerPolicy"
func (c *ELB) DeleteLoadBalancerPolicyRequest(input *DeleteLoadBalancerPolicyInput) (req *request.Request, output *DeleteLoadBalancerPolicyOutput) {
	op := &request.Operation{
		Name:       opDeleteLoadBalancerPolicy,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeleteLoadBalancerPolicyInput{}
	}
	req = c.newRequest(op, input, output)
	output = &DeleteLoadBalancerPolicyOutput{}
	req.Data = output
	return
}
func (c *ELB) DeleteLoadBalancerPolicy(input *DeleteLoadBalancerPolicyInput) (*DeleteLoadBalancerPolicyOutput, error) {
	req, out := c.DeleteLoadBalancerPolicyRequest(input)
	err := req.Send()
	return out, err
}
const opDeregisterInstancesFromLoadBalancer = "DeregisterInstancesFromLoadBalancer"