func (c *ELB) CreateLoadBalancerPolicy(input *CreateLoadBalancerPolicyInput) (*CreateLoadBalancerPolicyOutput, error) {
	req, out := c.CreateLoadBalancerPolicyRequest(input)
	err := req.Send()
	return out, err
}
CreateLoadBalancerPolicy API operation for Elastic Load Balancing.

Creates a policy with the specified attributes for the specified load balancer.

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

Returns awserr.Error for service API and SDK errors. Use runtime type assertions
with awserr.Error's Code and Message methods to get detailed information about
the error.

See the AWS API reference guide for Elastic Load Balancing's
API operation CreateLoadBalancerPolicy for usage and error information.

Returned Error Codes:
* LoadBalancerNotFound
The specified load balancer does not exist.

* PolicyTypeNotFound
One or more of the specified policy types do not exist.

* DuplicatePolicyName
A policy with the specified name already exists for this load balancer.

* TooManyPolicies
The quota for the number of policies for this load balancer has been reached.

* InvalidConfigurationRequest
The requested configuration change is not valid.
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
}