api.go

// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.

package slb

import (
	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/request"
)

const opAssociateLoadBalancerAcl = "AssociateLoadBalancerAcl"

// AssociateLoadBalancerAclRequest generates a "ksc/request.Request" representing the
// client's request for the AssociateLoadBalancerAcl operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See AssociateLoadBalancerAcl for more information on using the AssociateLoadBalancerAcl
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the AssociateLoadBalancerAclRequest method.
//    req, resp := client.AssociateLoadBalancerAclRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/AssociateLoadBalancerAcl
func (c *Slb) AssociateLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opAssociateLoadBalancerAcl,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// AssociateLoadBalancerAcl API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation AssociateLoadBalancerAcl for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/AssociateLoadBalancerAcl
func (c *Slb) AssociateLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.AssociateLoadBalancerAclRequest(input)
	return out, req.Send()
}

// AssociateLoadBalancerAclWithContext is the same as AssociateLoadBalancerAcl with the addition of
// the ability to pass a context and additional request options.
//
// See AssociateLoadBalancerAcl for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) AssociateLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.AssociateLoadBalancerAclRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opConfigureHealthCheck = "ConfigureHealthCheck"

// ConfigureHealthCheckRequest generates a "ksc/request.Request" representing the
// client's request for the ConfigureHealthCheck operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ConfigureHealthCheck for more information on using the ConfigureHealthCheck
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ConfigureHealthCheckRequest method.
//    req, resp := client.ConfigureHealthCheckRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ConfigureHealthCheck
func (c *Slb) ConfigureHealthCheckRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opConfigureHealthCheck,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// ConfigureHealthCheck API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation ConfigureHealthCheck for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ConfigureHealthCheck
func (c *Slb) ConfigureHealthCheck(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.ConfigureHealthCheckRequest(input)
	return out, req.Send()
}

// ConfigureHealthCheckWithContext is the same as ConfigureHealthCheck with the addition of
// the ability to pass a context and additional request options.
//
// See ConfigureHealthCheck for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) ConfigureHealthCheckWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.ConfigureHealthCheckRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateBackendServerGroup = "CreateBackendServerGroup"

// CreateBackendServerGroupRequest generates a "ksc/request.Request" representing the
// client's request for the CreateBackendServerGroup operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateBackendServerGroup for more information on using the CreateBackendServerGroup
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the CreateBackendServerGroupRequest method.
//    req, resp := client.CreateBackendServerGroupRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateBackendServerGroup
func (c *Slb) CreateBackendServerGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opCreateBackendServerGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// CreateBackendServerGroup API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation CreateBackendServerGroup for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateBackendServerGroup
func (c *Slb) CreateBackendServerGroup(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.CreateBackendServerGroupRequest(input)
	return out, req.Send()
}

// CreateBackendServerGroupWithContext is the same as CreateBackendServerGroup with the addition of
// the ability to pass a context and additional request options.
//
// See CreateBackendServerGroup for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) CreateBackendServerGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.CreateBackendServerGroupRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateHostHeader = "CreateHostHeader"

// CreateHostHeaderRequest generates a "ksc/request.Request" representing the
// client's request for the CreateHostHeader operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateHostHeader for more information on using the CreateHostHeader
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the CreateHostHeaderRequest method.
//    req, resp := client.CreateHostHeaderRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateHostHeader
func (c *Slb) CreateHostHeaderRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opCreateHostHeader,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// CreateHostHeader API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation CreateHostHeader for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateHostHeader
func (c *Slb) CreateHostHeader(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.CreateHostHeaderRequest(input)
	return out, req.Send()
}

// CreateHostHeaderWithContext is the same as CreateHostHeader with the addition of
// the ability to pass a context and additional request options.
//
// See CreateHostHeader for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) CreateHostHeaderWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.CreateHostHeaderRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateListeners = "CreateListeners"

// CreateListenersRequest generates a "ksc/request.Request" representing the
// client's request for the CreateListeners operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateListeners for more information on using the CreateListeners
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the CreateListenersRequest method.
//    req, resp := client.CreateListenersRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateListeners
func (c *Slb) CreateListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opCreateListeners,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// CreateListeners API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation CreateListeners for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateListeners
func (c *Slb) CreateListeners(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.CreateListenersRequest(input)
	return out, req.Send()
}

// CreateListenersWithContext is the same as CreateListeners with the addition of
// the ability to pass a context and additional request options.
//
// See CreateListeners for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) CreateListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.CreateListenersRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateLoadBalancer = "CreateLoadBalancer"

// CreateLoadBalancerRequest generates a "ksc/request.Request" representing the
// client's request for the CreateLoadBalancer operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateLoadBalancer for more information on using the CreateLoadBalancer
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the CreateLoadBalancerRequest method.
//    req, resp := client.CreateLoadBalancerRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateLoadBalancer
func (c *Slb) CreateLoadBalancerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opCreateLoadBalancer,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// CreateLoadBalancer API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation CreateLoadBalancer for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateLoadBalancer
func (c *Slb) CreateLoadBalancer(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.CreateLoadBalancerRequest(input)
	return out, req.Send()
}

// CreateLoadBalancerWithContext is the same as CreateLoadBalancer with the addition of
// the ability to pass a context and additional request options.
//
// See CreateLoadBalancer for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) CreateLoadBalancerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.CreateLoadBalancerRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateLoadBalancerAcl = "CreateLoadBalancerAcl"

// CreateLoadBalancerAclRequest generates a "ksc/request.Request" representing the
// client's request for the CreateLoadBalancerAcl operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateLoadBalancerAcl for more information on using the CreateLoadBalancerAcl
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the CreateLoadBalancerAclRequest method.
//    req, resp := client.CreateLoadBalancerAclRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateLoadBalancerAcl
func (c *Slb) CreateLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opCreateLoadBalancerAcl,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// CreateLoadBalancerAcl API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation CreateLoadBalancerAcl for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateLoadBalancerAcl
func (c *Slb) CreateLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.CreateLoadBalancerAclRequest(input)
	return out, req.Send()
}

// CreateLoadBalancerAclWithContext is the same as CreateLoadBalancerAcl with the addition of
// the ability to pass a context and additional request options.
//
// See CreateLoadBalancerAcl for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) CreateLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.CreateLoadBalancerAclRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateLoadBalancerAclEntry = "CreateLoadBalancerAclEntry"

// CreateLoadBalancerAclEntryRequest generates a "ksc/request.Request" representing the
// client's request for the CreateLoadBalancerAclEntry operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateLoadBalancerAclEntry for more information on using the CreateLoadBalancerAclEntry
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the CreateLoadBalancerAclEntryRequest method.
//    req, resp := client.CreateLoadBalancerAclEntryRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateLoadBalancerAclEntry
func (c *Slb) CreateLoadBalancerAclEntryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opCreateLoadBalancerAclEntry,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// CreateLoadBalancerAclEntry API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation CreateLoadBalancerAclEntry for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateLoadBalancerAclEntry
func (c *Slb) CreateLoadBalancerAclEntry(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.CreateLoadBalancerAclEntryRequest(input)
	return out, req.Send()
}

// CreateLoadBalancerAclEntryWithContext is the same as CreateLoadBalancerAclEntry with the addition of
// the ability to pass a context and additional request options.
//
// See CreateLoadBalancerAclEntry for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) CreateLoadBalancerAclEntryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.CreateLoadBalancerAclEntryRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateSlbRule = "CreateSlbRule"

// CreateSlbRuleRequest generates a "ksc/request.Request" representing the
// client's request for the CreateSlbRule operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateSlbRule for more information on using the CreateSlbRule
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the CreateSlbRuleRequest method.
//    req, resp := client.CreateSlbRuleRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateSlbRule
func (c *Slb) CreateSlbRuleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opCreateSlbRule,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// CreateSlbRule API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation CreateSlbRule for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateSlbRule
func (c *Slb) CreateSlbRule(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.CreateSlbRuleRequest(input)
	return out, req.Send()
}

// CreateSlbRuleWithContext is the same as CreateSlbRule with the addition of
// the ability to pass a context and additional request options.
//
// See CreateSlbRule for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) CreateSlbRuleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.CreateSlbRuleRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteBackendServerGroup = "DeleteBackendServerGroup"

// DeleteBackendServerGroupRequest generates a "ksc/request.Request" representing the
// client's request for the DeleteBackendServerGroup operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteBackendServerGroup for more information on using the DeleteBackendServerGroup
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeleteBackendServerGroupRequest method.
//    req, resp := client.DeleteBackendServerGroupRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteBackendServerGroup
func (c *Slb) DeleteBackendServerGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opDeleteBackendServerGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// DeleteBackendServerGroup API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation DeleteBackendServerGroup for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteBackendServerGroup
func (c *Slb) DeleteBackendServerGroup(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.DeleteBackendServerGroupRequest(input)
	return out, req.Send()
}

// DeleteBackendServerGroupWithContext is the same as DeleteBackendServerGroup with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteBackendServerGroup for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) DeleteBackendServerGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.DeleteBackendServerGroupRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteHealthCheck = "DeleteHealthCheck"

// DeleteHealthCheckRequest generates a "ksc/request.Request" representing the
// client's request for the DeleteHealthCheck operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteHealthCheck for more information on using the DeleteHealthCheck
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeleteHealthCheckRequest method.
//    req, resp := client.DeleteHealthCheckRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteHealthCheck
func (c *Slb) DeleteHealthCheckRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opDeleteHealthCheck,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// DeleteHealthCheck API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation DeleteHealthCheck for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteHealthCheck
func (c *Slb) DeleteHealthCheck(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.DeleteHealthCheckRequest(input)
	return out, req.Send()
}

// DeleteHealthCheckWithContext is the same as DeleteHealthCheck with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteHealthCheck for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) DeleteHealthCheckWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.DeleteHealthCheckRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteHostHeader = "DeleteHostHeader"

// DeleteHostHeaderRequest generates a "ksc/request.Request" representing the
// client's request for the DeleteHostHeader operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteHostHeader for more information on using the DeleteHostHeader
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeleteHostHeaderRequest method.
//    req, resp := client.DeleteHostHeaderRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteHostHeader
func (c *Slb) DeleteHostHeaderRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opDeleteHostHeader,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// DeleteHostHeader API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation DeleteHostHeader for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteHostHeader
func (c *Slb) DeleteHostHeader(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.DeleteHostHeaderRequest(input)
	return out, req.Send()
}

// DeleteHostHeaderWithContext is the same as DeleteHostHeader with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteHostHeader for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) DeleteHostHeaderWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.DeleteHostHeaderRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteListeners = "DeleteListeners"

// DeleteListenersRequest generates a "ksc/request.Request" representing the
// client's request for the DeleteListeners operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteListeners for more information on using the DeleteListeners
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeleteListenersRequest method.
//    req, resp := client.DeleteListenersRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteListeners
func (c *Slb) DeleteListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opDeleteListeners,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// DeleteListeners API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation DeleteListeners for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteListeners
func (c *Slb) DeleteListeners(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.DeleteListenersRequest(input)
	return out, req.Send()
}

// DeleteListenersWithContext is the same as DeleteListeners with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteListeners for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) DeleteListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.DeleteListenersRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteLoadBalancer = "DeleteLoadBalancer"

// DeleteLoadBalancerRequest generates a "ksc/request.Request" representing the
// client's request for the DeleteLoadBalancer operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteLoadBalancer for more information on using the DeleteLoadBalancer
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeleteLoadBalancerRequest method.
//    req, resp := client.DeleteLoadBalancerRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteLoadBalancer
func (c *Slb) DeleteLoadBalancerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opDeleteLoadBalancer,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// DeleteLoadBalancer API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation DeleteLoadBalancer for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteLoadBalancer
func (c *Slb) DeleteLoadBalancer(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.DeleteLoadBalancerRequest(input)
	return out, req.Send()
}

// DeleteLoadBalancerWithContext is the same as DeleteLoadBalancer with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteLoadBalancer for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) DeleteLoadBalancerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.DeleteLoadBalancerRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteLoadBalancerAcl = "DeleteLoadBalancerAcl"

// DeleteLoadBalancerAclRequest generates a "ksc/request.Request" representing the
// client's request for the DeleteLoadBalancerAcl operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteLoadBalancerAcl for more information on using the DeleteLoadBalancerAcl
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeleteLoadBalancerAclRequest method.
//    req, resp := client.DeleteLoadBalancerAclRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteLoadBalancerAcl
func (c *Slb) DeleteLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opDeleteLoadBalancerAcl,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// DeleteLoadBalancerAcl API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation DeleteLoadBalancerAcl for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteLoadBalancerAcl
func (c *Slb) DeleteLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.DeleteLoadBalancerAclRequest(input)
	return out, req.Send()
}

// DeleteLoadBalancerAclWithContext is the same as DeleteLoadBalancerAcl with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteLoadBalancerAcl for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) DeleteLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.DeleteLoadBalancerAclRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteLoadBalancerAclEntry = "DeleteLoadBalancerAclEntry"

// DeleteLoadBalancerAclEntryRequest generates a "ksc/request.Request" representing the
// client's request for the DeleteLoadBalancerAclEntry operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteLoadBalancerAclEntry for more information on using the DeleteLoadBalancerAclEntry
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeleteLoadBalancerAclEntryRequest method.
//    req, resp := client.DeleteLoadBalancerAclEntryRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteLoadBalancerAclEntry
func (c *Slb) DeleteLoadBalancerAclEntryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opDeleteLoadBalancerAclEntry,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// DeleteLoadBalancerAclEntry API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation DeleteLoadBalancerAclEntry for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteLoadBalancerAclEntry
func (c *Slb) DeleteLoadBalancerAclEntry(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.DeleteLoadBalancerAclEntryRequest(input)
	return out, req.Send()
}

// DeleteLoadBalancerAclEntryWithContext is the same as DeleteLoadBalancerAclEntry with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteLoadBalancerAclEntry for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) DeleteLoadBalancerAclEntryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.DeleteLoadBalancerAclEntryRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteRule = "DeleteRule"

// DeleteRuleRequest generates a "ksc/request.Request" representing the
// client's request for the DeleteRule operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteRule for more information on using the DeleteRule
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeleteRuleRequest method.
//    req, resp := client.DeleteRuleRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteRule
func (c *Slb) DeleteRuleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opDeleteRule,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// DeleteRule API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation DeleteRule for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteRule
func (c *Slb) DeleteRule(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.DeleteRuleRequest(input)
	return out, req.Send()
}

// DeleteRuleWithContext is the same as DeleteRule with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteRule for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) DeleteRuleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.DeleteRuleRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeregisterBackendServer = "DeregisterBackendServer"

// DeregisterBackendServerRequest generates a "ksc/request.Request" representing the
// client's request for the DeregisterBackendServer operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeregisterBackendServer for more information on using the DeregisterBackendServer
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeregisterBackendServerRequest method.
//    req, resp := client.DeregisterBackendServerRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeregisterBackendServer
func (c *Slb) DeregisterBackendServerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opDeregisterBackendServer,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// DeregisterBackendServer API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation DeregisterBackendServer for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeregisterBackendServer
func (c *Slb) DeregisterBackendServer(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.DeregisterBackendServerRequest(input)
	return out, req.Send()
}

// DeregisterBackendServerWithContext is the same as DeregisterBackendServer with the addition of
// the ability to pass a context and additional request options.
//
// See DeregisterBackendServer for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) DeregisterBackendServerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.DeregisterBackendServerRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeregisterInstancesFromListener = "DeregisterInstancesFromListener"

// DeregisterInstancesFromListenerRequest generates a "ksc/request.Request" representing the
// client's request for the DeregisterInstancesFromListener operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeregisterInstancesFromListener for more information on using the DeregisterInstancesFromListener
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeregisterInstancesFromListenerRequest method.
//    req, resp := client.DeregisterInstancesFromListenerRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeregisterInstancesFromListener
func (c *Slb) DeregisterInstancesFromListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opDeregisterInstancesFromListener,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// DeregisterInstancesFromListener API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation DeregisterInstancesFromListener for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeregisterInstancesFromListener
func (c *Slb) DeregisterInstancesFromListener(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.DeregisterInstancesFromListenerRequest(input)
	return out, req.Send()
}

// DeregisterInstancesFromListenerWithContext is the same as DeregisterInstancesFromListener with the addition of
// the ability to pass a context and additional request options.
//
// See DeregisterInstancesFromListener for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) DeregisterInstancesFromListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.DeregisterInstancesFromListenerRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeBackendServerGroups = "DescribeBackendServerGroups"

// DescribeBackendServerGroupsRequest generates a "ksc/request.Request" representing the
// client's request for the DescribeBackendServerGroups operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeBackendServerGroups for more information on using the DescribeBackendServerGroups
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DescribeBackendServerGroupsRequest method.
//    req, resp := client.DescribeBackendServerGroupsRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeBackendServerGroups
func (c *Slb) DescribeBackendServerGroupsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opDescribeBackendServerGroups,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// DescribeBackendServerGroups API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation DescribeBackendServerGroups for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeBackendServerGroups
func (c *Slb) DescribeBackendServerGroups(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.DescribeBackendServerGroupsRequest(input)
	return out, req.Send()
}

// DescribeBackendServerGroupsWithContext is the same as DescribeBackendServerGroups with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeBackendServerGroups for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) DescribeBackendServerGroupsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.DescribeBackendServerGroupsRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeBackendServers = "DescribeBackendServers"

// DescribeBackendServersRequest generates a "ksc/request.Request" representing the
// client's request for the DescribeBackendServers operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeBackendServers for more information on using the DescribeBackendServers
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DescribeBackendServersRequest method.
//    req, resp := client.DescribeBackendServersRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeBackendServers
func (c *Slb) DescribeBackendServersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opDescribeBackendServers,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// DescribeBackendServers API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation DescribeBackendServers for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeBackendServers
func (c *Slb) DescribeBackendServers(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.DescribeBackendServersRequest(input)
	return out, req.Send()
}

// DescribeBackendServersWithContext is the same as DescribeBackendServers with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeBackendServers for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) DescribeBackendServersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.DescribeBackendServersRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeHealthChecks = "DescribeHealthChecks"

// DescribeHealthChecksRequest generates a "ksc/request.Request" representing the
// client's request for the DescribeHealthChecks operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeHealthChecks for more information on using the DescribeHealthChecks
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DescribeHealthChecksRequest method.
//    req, resp := client.DescribeHealthChecksRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeHealthChecks
func (c *Slb) DescribeHealthChecksRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opDescribeHealthChecks,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// DescribeHealthChecks API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation DescribeHealthChecks for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeHealthChecks
func (c *Slb) DescribeHealthChecks(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.DescribeHealthChecksRequest(input)
	return out, req.Send()
}

// DescribeHealthChecksWithContext is the same as DescribeHealthChecks with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeHealthChecks for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) DescribeHealthChecksWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.DescribeHealthChecksRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeHostHeaders = "DescribeHostHeaders"

// DescribeHostHeadersRequest generates a "ksc/request.Request" representing the
// client's request for the DescribeHostHeaders operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeHostHeaders for more information on using the DescribeHostHeaders
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DescribeHostHeadersRequest method.
//    req, resp := client.DescribeHostHeadersRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeHostHeaders
func (c *Slb) DescribeHostHeadersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opDescribeHostHeaders,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// DescribeHostHeaders API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation DescribeHostHeaders for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeHostHeaders
func (c *Slb) DescribeHostHeaders(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.DescribeHostHeadersRequest(input)
	return out, req.Send()
}

// DescribeHostHeadersWithContext is the same as DescribeHostHeaders with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeHostHeaders for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) DescribeHostHeadersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.DescribeHostHeadersRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeInstancesWithListener = "DescribeInstancesWithListener"

// DescribeInstancesWithListenerRequest generates a "ksc/request.Request" representing the
// client's request for the DescribeInstancesWithListener operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeInstancesWithListener for more information on using the DescribeInstancesWithListener
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DescribeInstancesWithListenerRequest method.
//    req, resp := client.DescribeInstancesWithListenerRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeInstancesWithListener
func (c *Slb) DescribeInstancesWithListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opDescribeInstancesWithListener,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// DescribeInstancesWithListener API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation DescribeInstancesWithListener for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeInstancesWithListener
func (c *Slb) DescribeInstancesWithListener(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.DescribeInstancesWithListenerRequest(input)
	return out, req.Send()
}

// DescribeInstancesWithListenerWithContext is the same as DescribeInstancesWithListener with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeInstancesWithListener for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) DescribeInstancesWithListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.DescribeInstancesWithListenerRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeListeners = "DescribeListeners"

// DescribeListenersRequest generates a "ksc/request.Request" representing the
// client's request for the DescribeListeners operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeListeners for more information on using the DescribeListeners
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DescribeListenersRequest method.
//    req, resp := client.DescribeListenersRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeListeners
func (c *Slb) DescribeListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opDescribeListeners,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// DescribeListeners API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation DescribeListeners for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeListeners
func (c *Slb) DescribeListeners(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.DescribeListenersRequest(input)
	return out, req.Send()
}

// DescribeListenersWithContext is the same as DescribeListeners with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeListeners for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) DescribeListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.DescribeListenersRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeLoadBalancerAcls = "DescribeLoadBalancerAcls"

// DescribeLoadBalancerAclsRequest generates a "ksc/request.Request" representing the
// client's request for the DescribeLoadBalancerAcls operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeLoadBalancerAcls for more information on using the DescribeLoadBalancerAcls
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DescribeLoadBalancerAclsRequest method.
//    req, resp := client.DescribeLoadBalancerAclsRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeLoadBalancerAcls
func (c *Slb) DescribeLoadBalancerAclsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opDescribeLoadBalancerAcls,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// DescribeLoadBalancerAcls API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation DescribeLoadBalancerAcls for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeLoadBalancerAcls
func (c *Slb) DescribeLoadBalancerAcls(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.DescribeLoadBalancerAclsRequest(input)
	return out, req.Send()
}

// DescribeLoadBalancerAclsWithContext is the same as DescribeLoadBalancerAcls with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeLoadBalancerAcls for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) DescribeLoadBalancerAclsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.DescribeLoadBalancerAclsRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeLoadBalancers = "DescribeLoadBalancers"

// DescribeLoadBalancersRequest generates a "ksc/request.Request" representing the
// client's request for the DescribeLoadBalancers operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeLoadBalancers for more information on using the DescribeLoadBalancers
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DescribeLoadBalancersRequest method.
//    req, resp := client.DescribeLoadBalancersRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeLoadBalancers
func (c *Slb) DescribeLoadBalancersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opDescribeLoadBalancers,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// DescribeLoadBalancers API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation DescribeLoadBalancers for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeLoadBalancers
func (c *Slb) DescribeLoadBalancers(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.DescribeLoadBalancersRequest(input)
	return out, req.Send()
}

// DescribeLoadBalancersWithContext is the same as DescribeLoadBalancers with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeLoadBalancers for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) DescribeLoadBalancersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.DescribeLoadBalancersRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeRules = "DescribeRules"

// DescribeRulesRequest generates a "ksc/request.Request" representing the
// client's request for the DescribeRules operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeRules for more information on using the DescribeRules
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DescribeRulesRequest method.
//    req, resp := client.DescribeRulesRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeRules
func (c *Slb) DescribeRulesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opDescribeRules,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// DescribeRules API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation DescribeRules for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeRules
func (c *Slb) DescribeRules(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.DescribeRulesRequest(input)
	return out, req.Send()
}

// DescribeRulesWithContext is the same as DescribeRules with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeRules for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) DescribeRulesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.DescribeRulesRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDisassociateLoadBalancerAcl = "DisassociateLoadBalancerAcl"

// DisassociateLoadBalancerAclRequest generates a "ksc/request.Request" representing the
// client's request for the DisassociateLoadBalancerAcl operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DisassociateLoadBalancerAcl for more information on using the DisassociateLoadBalancerAcl
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DisassociateLoadBalancerAclRequest method.
//    req, resp := client.DisassociateLoadBalancerAclRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DisassociateLoadBalancerAcl
func (c *Slb) DisassociateLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opDisassociateLoadBalancerAcl,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// DisassociateLoadBalancerAcl API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation DisassociateLoadBalancerAcl for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DisassociateLoadBalancerAcl
func (c *Slb) DisassociateLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.DisassociateLoadBalancerAclRequest(input)
	return out, req.Send()
}

// DisassociateLoadBalancerAclWithContext is the same as DisassociateLoadBalancerAcl with the addition of
// the ability to pass a context and additional request options.
//
// See DisassociateLoadBalancerAcl for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) DisassociateLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.DisassociateLoadBalancerAclRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opModifyBackendServer = "ModifyBackendServer"

// ModifyBackendServerRequest generates a "ksc/request.Request" representing the
// client's request for the ModifyBackendServer operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ModifyBackendServer for more information on using the ModifyBackendServer
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ModifyBackendServerRequest method.
//    req, resp := client.ModifyBackendServerRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyBackendServer
func (c *Slb) ModifyBackendServerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opModifyBackendServer,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// ModifyBackendServer API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation ModifyBackendServer for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyBackendServer
func (c *Slb) ModifyBackendServer(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.ModifyBackendServerRequest(input)
	return out, req.Send()
}

// ModifyBackendServerWithContext is the same as ModifyBackendServer with the addition of
// the ability to pass a context and additional request options.
//
// See ModifyBackendServer for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) ModifyBackendServerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.ModifyBackendServerRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opModifyBackendServerGroup = "ModifyBackendServerGroup"

// ModifyBackendServerGroupRequest generates a "ksc/request.Request" representing the
// client's request for the ModifyBackendServerGroup operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ModifyBackendServerGroup for more information on using the ModifyBackendServerGroup
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ModifyBackendServerGroupRequest method.
//    req, resp := client.ModifyBackendServerGroupRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyBackendServerGroup
func (c *Slb) ModifyBackendServerGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opModifyBackendServerGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// ModifyBackendServerGroup API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation ModifyBackendServerGroup for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyBackendServerGroup
func (c *Slb) ModifyBackendServerGroup(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.ModifyBackendServerGroupRequest(input)
	return out, req.Send()
}

// ModifyBackendServerGroupWithContext is the same as ModifyBackendServerGroup with the addition of
// the ability to pass a context and additional request options.
//
// See ModifyBackendServerGroup for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) ModifyBackendServerGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.ModifyBackendServerGroupRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opModifyBackendServerGroupHealthCheck = "ModifyBackendServerGroupHealthCheck"

// ModifyBackendServerGroupHealthCheckRequest generates a "ksc/request.Request" representing the
// client's request for the ModifyBackendServerGroupHealthCheck operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ModifyBackendServerGroupHealthCheck for more information on using the ModifyBackendServerGroupHealthCheck
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ModifyBackendServerGroupHealthCheckRequest method.
//    req, resp := client.ModifyBackendServerGroupHealthCheckRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyBackendServerGroupHealthCheck
func (c *Slb) ModifyBackendServerGroupHealthCheckRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opModifyBackendServerGroupHealthCheck,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// ModifyBackendServerGroupHealthCheck API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation ModifyBackendServerGroupHealthCheck for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyBackendServerGroupHealthCheck
func (c *Slb) ModifyBackendServerGroupHealthCheck(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.ModifyBackendServerGroupHealthCheckRequest(input)
	return out, req.Send()
}

// ModifyBackendServerGroupHealthCheckWithContext is the same as ModifyBackendServerGroupHealthCheck with the addition of
// the ability to pass a context and additional request options.
//
// See ModifyBackendServerGroupHealthCheck for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) ModifyBackendServerGroupHealthCheckWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.ModifyBackendServerGroupHealthCheckRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opModifyHealthCheck = "ModifyHealthCheck"

// ModifyHealthCheckRequest generates a "ksc/request.Request" representing the
// client's request for the ModifyHealthCheck operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ModifyHealthCheck for more information on using the ModifyHealthCheck
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ModifyHealthCheckRequest method.
//    req, resp := client.ModifyHealthCheckRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyHealthCheck
func (c *Slb) ModifyHealthCheckRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opModifyHealthCheck,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// ModifyHealthCheck API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation ModifyHealthCheck for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyHealthCheck
func (c *Slb) ModifyHealthCheck(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.ModifyHealthCheckRequest(input)
	return out, req.Send()
}

// ModifyHealthCheckWithContext is the same as ModifyHealthCheck with the addition of
// the ability to pass a context and additional request options.
//
// See ModifyHealthCheck for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) ModifyHealthCheckWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.ModifyHealthCheckRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opModifyHostHeader = "ModifyHostHeader"

// ModifyHostHeaderRequest generates a "ksc/request.Request" representing the
// client's request for the ModifyHostHeader operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ModifyHostHeader for more information on using the ModifyHostHeader
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ModifyHostHeaderRequest method.
//    req, resp := client.ModifyHostHeaderRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyHostHeader
func (c *Slb) ModifyHostHeaderRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opModifyHostHeader,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// ModifyHostHeader API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation ModifyHostHeader for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyHostHeader
func (c *Slb) ModifyHostHeader(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.ModifyHostHeaderRequest(input)
	return out, req.Send()
}

// ModifyHostHeaderWithContext is the same as ModifyHostHeader with the addition of
// the ability to pass a context and additional request options.
//
// See ModifyHostHeader for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) ModifyHostHeaderWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.ModifyHostHeaderRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opModifyInstancesWithListener = "ModifyInstancesWithListener"

// ModifyInstancesWithListenerRequest generates a "ksc/request.Request" representing the
// client's request for the ModifyInstancesWithListener operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ModifyInstancesWithListener for more information on using the ModifyInstancesWithListener
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ModifyInstancesWithListenerRequest method.
//    req, resp := client.ModifyInstancesWithListenerRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyInstancesWithListener
func (c *Slb) ModifyInstancesWithListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opModifyInstancesWithListener,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// ModifyInstancesWithListener API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation ModifyInstancesWithListener for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyInstancesWithListener
func (c *Slb) ModifyInstancesWithListener(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.ModifyInstancesWithListenerRequest(input)
	return out, req.Send()
}

// ModifyInstancesWithListenerWithContext is the same as ModifyInstancesWithListener with the addition of
// the ability to pass a context and additional request options.
//
// See ModifyInstancesWithListener for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) ModifyInstancesWithListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.ModifyInstancesWithListenerRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opModifyListeners = "ModifyListeners"

// ModifyListenersRequest generates a "ksc/request.Request" representing the
// client's request for the ModifyListeners operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ModifyListeners for more information on using the ModifyListeners
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ModifyListenersRequest method.
//    req, resp := client.ModifyListenersRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyListeners
func (c *Slb) ModifyListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opModifyListeners,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// ModifyListeners API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation ModifyListeners for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyListeners
func (c *Slb) ModifyListeners(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.ModifyListenersRequest(input)
	return out, req.Send()
}

// ModifyListenersWithContext is the same as ModifyListeners with the addition of
// the ability to pass a context and additional request options.
//
// See ModifyListeners for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) ModifyListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.ModifyListenersRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opModifyLoadBalancer = "ModifyLoadBalancer"

// ModifyLoadBalancerRequest generates a "ksc/request.Request" representing the
// client's request for the ModifyLoadBalancer operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ModifyLoadBalancer for more information on using the ModifyLoadBalancer
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ModifyLoadBalancerRequest method.
//    req, resp := client.ModifyLoadBalancerRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyLoadBalancer
func (c *Slb) ModifyLoadBalancerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opModifyLoadBalancer,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// ModifyLoadBalancer API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation ModifyLoadBalancer for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyLoadBalancer
func (c *Slb) ModifyLoadBalancer(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.ModifyLoadBalancerRequest(input)
	return out, req.Send()
}

// ModifyLoadBalancerWithContext is the same as ModifyLoadBalancer with the addition of
// the ability to pass a context and additional request options.
//
// See ModifyLoadBalancer for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) ModifyLoadBalancerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.ModifyLoadBalancerRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opModifyLoadBalancerAcl = "ModifyLoadBalancerAcl"

// ModifyLoadBalancerAclRequest generates a "ksc/request.Request" representing the
// client's request for the ModifyLoadBalancerAcl operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ModifyLoadBalancerAcl for more information on using the ModifyLoadBalancerAcl
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ModifyLoadBalancerAclRequest method.
//    req, resp := client.ModifyLoadBalancerAclRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyLoadBalancerAcl
func (c *Slb) ModifyLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opModifyLoadBalancerAcl,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// ModifyLoadBalancerAcl API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation ModifyLoadBalancerAcl for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyLoadBalancerAcl
func (c *Slb) ModifyLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.ModifyLoadBalancerAclRequest(input)
	return out, req.Send()
}

// ModifyLoadBalancerAclWithContext is the same as ModifyLoadBalancerAcl with the addition of
// the ability to pass a context and additional request options.
//
// See ModifyLoadBalancerAcl for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) ModifyLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.ModifyLoadBalancerAclRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opModifyLoadBalancerAclEntry = "ModifyLoadBalancerAclEntry"

// ModifyLoadBalancerAclEntryRequest generates a "ksc/request.Request" representing the
// client's request for the ModifyLoadBalancerAclEntry operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ModifyLoadBalancerAclEntry for more information on using the ModifyLoadBalancerAclEntry
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ModifyLoadBalancerAclEntryRequest method.
//    req, resp := client.ModifyLoadBalancerAclEntryRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyLoadBalancerAclEntry
func (c *Slb) ModifyLoadBalancerAclEntryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opModifyLoadBalancerAclEntry,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// ModifyLoadBalancerAclEntry API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation ModifyLoadBalancerAclEntry for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyLoadBalancerAclEntry
func (c *Slb) ModifyLoadBalancerAclEntry(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.ModifyLoadBalancerAclEntryRequest(input)
	return out, req.Send()
}

// ModifyLoadBalancerAclEntryWithContext is the same as ModifyLoadBalancerAclEntry with the addition of
// the ability to pass a context and additional request options.
//
// See ModifyLoadBalancerAclEntry for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) ModifyLoadBalancerAclEntryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.ModifyLoadBalancerAclEntryRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opModifySlbRule = "ModifySlbRule"

// ModifySlbRuleRequest generates a "ksc/request.Request" representing the
// client's request for the ModifySlbRule operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ModifySlbRule for more information on using the ModifySlbRule
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ModifySlbRuleRequest method.
//    req, resp := client.ModifySlbRuleRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifySlbRule
func (c *Slb) ModifySlbRuleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opModifySlbRule,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// ModifySlbRule API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation ModifySlbRule for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifySlbRule
func (c *Slb) ModifySlbRule(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.ModifySlbRuleRequest(input)
	return out, req.Send()
}

// ModifySlbRuleWithContext is the same as ModifySlbRule with the addition of
// the ability to pass a context and additional request options.
//
// See ModifySlbRule for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) ModifySlbRuleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.ModifySlbRuleRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opRegisterBackendServer = "RegisterBackendServer"

// RegisterBackendServerRequest generates a "ksc/request.Request" representing the
// client's request for the RegisterBackendServer operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See RegisterBackendServer for more information on using the RegisterBackendServer
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the RegisterBackendServerRequest method.
//    req, resp := client.RegisterBackendServerRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/RegisterBackendServer
func (c *Slb) RegisterBackendServerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opRegisterBackendServer,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// RegisterBackendServer API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation RegisterBackendServer for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/RegisterBackendServer
func (c *Slb) RegisterBackendServer(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.RegisterBackendServerRequest(input)
	return out, req.Send()
}

// RegisterBackendServerWithContext is the same as RegisterBackendServer with the addition of
// the ability to pass a context and additional request options.
//
// See RegisterBackendServer for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) RegisterBackendServerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.RegisterBackendServerRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opRegisterInstancesWithListener = "RegisterInstancesWithListener"

// RegisterInstancesWithListenerRequest generates a "ksc/request.Request" representing the
// client's request for the RegisterInstancesWithListener operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See RegisterInstancesWithListener for more information on using the RegisterInstancesWithListener
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the RegisterInstancesWithListenerRequest method.
//    req, resp := client.RegisterInstancesWithListenerRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/RegisterInstancesWithListener
func (c *Slb) RegisterInstancesWithListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{}) {
	op := &request.Operation{
		Name:       opRegisterInstancesWithListener,
		HTTPMethod: "GET",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &map[string]interface{}{}
	}

	output = &map[string]interface{}{}
	req = c.newRequest(op, input, output)

	return
}

// RegisterInstancesWithListener API operation for slb.
//
// 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 KSC API reference guide for slb's
// API operation RegisterInstancesWithListener for usage and error information.
// See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/RegisterInstancesWithListener
func (c *Slb) RegisterInstancesWithListener(input *map[string]interface{}) (*map[string]interface{}, error) {
	req, out := c.RegisterInstancesWithListenerRequest(input)
	return out, req.Send()
}

// RegisterInstancesWithListenerWithContext is the same as RegisterInstancesWithListener with the addition of
// the ability to pass a context and additional request options.
//
// See RegisterInstancesWithListener for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Slb) RegisterInstancesWithListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error) {
	req, out := c.RegisterInstancesWithListenerRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}