slb

Documentation

Index

• Constants
• type Slb
  • func ExtraNew(info *utils.UrlInfo, p client.ConfigProvider, cfgs ...*aws.Config) *Slb
  • func New(p client.ConfigProvider, cfgs ...*aws.Config) *Slb
  • func SdkNew(p client.ConfigProvider, cfgs *ksc.Config, info ...*utils.UrlInfo) *Slb
  • func (c *Slb) AssociateLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) AssociateLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) AssociateLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) ConfigureHealthCheck(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ConfigureHealthCheckRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ConfigureHealthCheckWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) CreateBackendServerGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) CreateBackendServerGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) CreateBackendServerGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) CreateHostHeader(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) CreateHostHeaderRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) CreateHostHeaderWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) CreateListeners(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) CreateListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) CreateListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) CreateLoadBalancer(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) CreateLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) CreateLoadBalancerAclEntry(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) CreateLoadBalancerAclEntryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) CreateLoadBalancerAclEntryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) CreateLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) CreateLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) CreateLoadBalancerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) CreateLoadBalancerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) CreateSlbRule(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) CreateSlbRuleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) CreateSlbRuleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DeleteBackendServerGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeleteBackendServerGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeleteBackendServerGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DeleteHealthCheck(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeleteHealthCheckRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeleteHealthCheckWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DeleteHostHeader(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeleteHostHeaderRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeleteHostHeaderWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DeleteListeners(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeleteListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeleteListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DeleteLoadBalancer(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeleteLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeleteLoadBalancerAclEntry(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeleteLoadBalancerAclEntryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeleteLoadBalancerAclEntryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DeleteLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeleteLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DeleteLoadBalancerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeleteLoadBalancerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DeleteRule(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeleteRuleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeleteRuleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DeregisterBackendServer(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeregisterBackendServerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeregisterBackendServerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DeregisterInstancesFromListener(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeregisterInstancesFromListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeregisterInstancesFromListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DescribeBackendServerGroups(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DescribeBackendServerGroupsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DescribeBackendServerGroupsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DescribeBackendServers(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DescribeBackendServersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DescribeBackendServersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DescribeHealthChecks(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DescribeHealthChecksRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DescribeHealthChecksWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DescribeHostHeaders(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DescribeHostHeadersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DescribeHostHeadersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DescribeInstancesWithListener(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DescribeInstancesWithListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DescribeInstancesWithListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DescribeListeners(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DescribeListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DescribeListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DescribeLoadBalancerAcls(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DescribeLoadBalancerAclsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DescribeLoadBalancerAclsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DescribeLoadBalancers(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DescribeLoadBalancersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DescribeLoadBalancersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DescribeRules(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DescribeRulesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DescribeRulesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DisassociateLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DisassociateLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DisassociateLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) ModifyBackendServer(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ModifyBackendServerGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ModifyBackendServerGroupHealthCheck(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ModifyBackendServerGroupHealthCheckRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ModifyBackendServerGroupHealthCheckWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) ModifyBackendServerGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ModifyBackendServerGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) ModifyBackendServerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ModifyBackendServerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) ModifyHealthCheck(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ModifyHealthCheckRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ModifyHealthCheckWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) ModifyHostHeader(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ModifyHostHeaderRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ModifyHostHeaderWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) ModifyInstancesWithListener(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ModifyInstancesWithListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ModifyInstancesWithListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) ModifyListeners(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ModifyListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ModifyListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) ModifyLoadBalancer(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ModifyLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ModifyLoadBalancerAclEntry(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ModifyLoadBalancerAclEntryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ModifyLoadBalancerAclEntryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) ModifyLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ModifyLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) ModifyLoadBalancerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ModifyLoadBalancerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) ModifySlbRule(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ModifySlbRuleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ModifySlbRuleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) RegisterBackendServer(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) RegisterBackendServerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) RegisterBackendServerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) RegisterInstancesWithListener(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) RegisterInstancesWithListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) RegisterInstancesWithListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

Constants

const (
	ServiceName = "slb"       // Name of service.
	EndpointsID = ServiceName // ID to lookup a service endpoint with.
	ServiceID   = "slb"       // ServiceID is a unique identifer of a specific service.
)

Service information constants

Types

type Slb

type Slb struct {
	*client.Client
}

Slb provides the API operation methods for making requests to slb. See this package's package overview docs for details on the service.

Slb methods are safe to use concurrently. It is not safe to modify mutate any of the struct's properties though.

func ExtraNew

func ExtraNew(info *utils.UrlInfo, p client.ConfigProvider, cfgs ...*aws.Config) *Slb

extraNew create int can support ssl or region locate set

func New

func New(p client.ConfigProvider, cfgs ...*aws.Config) *Slb

New creates a new instance of the Slb client with a session. If additional configuration is needed for the client instance use the optional ksc.Config parameter to add your extra config.

Example:

// Create a Slb client from just a session.
svc := slb.New(mySession)

// Create a Slb client with additional configuration
svc := slb.New(mySession, aws.NewConfig().WithRegion("us-west-2"))

func SdkNew

func SdkNew(p client.ConfigProvider, cfgs *ksc.Config, info ...*utils.UrlInfo) *Slb

SdkNew create int can support ssl or region locate set

func (*Slb) AssociateLoadBalancerAcl

func (c *Slb) AssociateLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) AssociateLoadBalancerAclRequest

func (c *Slb) AssociateLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) AssociateLoadBalancerAclWithContext

func (c *Slb) AssociateLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) ConfigureHealthCheck

func (c *Slb) ConfigureHealthCheck(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) ConfigureHealthCheckRequest

func (c *Slb) ConfigureHealthCheckRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) ConfigureHealthCheckWithContext

func (c *Slb) ConfigureHealthCheckWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) CreateBackendServerGroup

func (c *Slb) CreateBackendServerGroup(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) CreateBackendServerGroupRequest

func (c *Slb) CreateBackendServerGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) CreateBackendServerGroupWithContext

func (c *Slb) CreateBackendServerGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) CreateHostHeader

func (c *Slb) CreateHostHeader(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) CreateHostHeaderRequest

func (c *Slb) CreateHostHeaderRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) CreateHostHeaderWithContext

func (c *Slb) CreateHostHeaderWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) CreateListeners

func (c *Slb) CreateListeners(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) CreateListenersRequest

func (c *Slb) CreateListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) CreateListenersWithContext

func (c *Slb) CreateListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) CreateLoadBalancer

func (c *Slb) CreateLoadBalancer(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) CreateLoadBalancerAcl

func (c *Slb) CreateLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) CreateLoadBalancerAclEntry

func (c *Slb) CreateLoadBalancerAclEntry(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) CreateLoadBalancerAclEntryRequest

func (c *Slb) CreateLoadBalancerAclEntryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) CreateLoadBalancerAclEntryWithContext

func (c *Slb) CreateLoadBalancerAclEntryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) CreateLoadBalancerAclRequest

func (c *Slb) CreateLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) CreateLoadBalancerAclWithContext

func (c *Slb) CreateLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) CreateLoadBalancerRequest

func (c *Slb) CreateLoadBalancerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) CreateLoadBalancerWithContext

func (c *Slb) CreateLoadBalancerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) CreateSlbRule

func (c *Slb) CreateSlbRule(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) CreateSlbRuleRequest

func (c *Slb) CreateSlbRuleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) CreateSlbRuleWithContext

func (c *Slb) CreateSlbRuleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) DeleteBackendServerGroup

func (c *Slb) DeleteBackendServerGroup(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) DeleteBackendServerGroupRequest

func (c *Slb) DeleteBackendServerGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) DeleteBackendServerGroupWithContext

func (c *Slb) DeleteBackendServerGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) DeleteHealthCheck

func (c *Slb) DeleteHealthCheck(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) DeleteHealthCheckRequest

func (c *Slb) DeleteHealthCheckRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) DeleteHealthCheckWithContext

func (c *Slb) DeleteHealthCheckWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) DeleteHostHeader

func (c *Slb) DeleteHostHeader(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) DeleteHostHeaderRequest

func (c *Slb) DeleteHostHeaderRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) DeleteHostHeaderWithContext

func (c *Slb) DeleteHostHeaderWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) DeleteListeners

func (c *Slb) DeleteListeners(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) DeleteListenersRequest

func (c *Slb) DeleteListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) DeleteListenersWithContext

func (c *Slb) DeleteListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) DeleteLoadBalancer

func (c *Slb) DeleteLoadBalancer(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) DeleteLoadBalancerAcl

func (c *Slb) DeleteLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) DeleteLoadBalancerAclEntry

func (c *Slb) DeleteLoadBalancerAclEntry(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) DeleteLoadBalancerAclEntryRequest

func (c *Slb) DeleteLoadBalancerAclEntryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) DeleteLoadBalancerAclEntryWithContext

func (c *Slb) DeleteLoadBalancerAclEntryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) DeleteLoadBalancerAclRequest

func (c *Slb) DeleteLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) DeleteLoadBalancerAclWithContext

func (c *Slb) DeleteLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) DeleteLoadBalancerRequest

func (c *Slb) DeleteLoadBalancerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) DeleteLoadBalancerWithContext

func (c *Slb) DeleteLoadBalancerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) DeleteRule

func (c *Slb) DeleteRule(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) DeleteRuleRequest

func (c *Slb) DeleteRuleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) DeleteRuleWithContext

func (c *Slb) DeleteRuleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) DeregisterBackendServer

func (c *Slb) DeregisterBackendServer(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) DeregisterBackendServerRequest

func (c *Slb) DeregisterBackendServerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) DeregisterBackendServerWithContext

func (c *Slb) DeregisterBackendServerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) DeregisterInstancesFromListener

func (c *Slb) DeregisterInstancesFromListener(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) DeregisterInstancesFromListenerRequest

func (c *Slb) DeregisterInstancesFromListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) DeregisterInstancesFromListenerWithContext

func (c *Slb) DeregisterInstancesFromListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) DescribeBackendServerGroups

func (c *Slb) DescribeBackendServerGroups(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) DescribeBackendServerGroupsRequest

func (c *Slb) DescribeBackendServerGroupsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) DescribeBackendServerGroupsWithContext

func (c *Slb) DescribeBackendServerGroupsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) DescribeBackendServers

func (c *Slb) DescribeBackendServers(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) DescribeBackendServersRequest

func (c *Slb) DescribeBackendServersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) DescribeBackendServersWithContext

func (c *Slb) DescribeBackendServersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) DescribeHealthChecks

func (c *Slb) DescribeHealthChecks(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) DescribeHealthChecksRequest

func (c *Slb) DescribeHealthChecksRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) DescribeHealthChecksWithContext

func (c *Slb) DescribeHealthChecksWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) DescribeHostHeaders

func (c *Slb) DescribeHostHeaders(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) DescribeHostHeadersRequest

func (c *Slb) DescribeHostHeadersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) DescribeHostHeadersWithContext

func (c *Slb) DescribeHostHeadersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) DescribeInstancesWithListener

func (c *Slb) DescribeInstancesWithListener(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) DescribeInstancesWithListenerRequest

func (c *Slb) DescribeInstancesWithListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) DescribeInstancesWithListenerWithContext

func (c *Slb) DescribeInstancesWithListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) DescribeListeners

func (c *Slb) DescribeListeners(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) DescribeListenersRequest

func (c *Slb) DescribeListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) DescribeListenersWithContext

func (c *Slb) DescribeListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) DescribeLoadBalancerAcls

func (c *Slb) DescribeLoadBalancerAcls(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) DescribeLoadBalancerAclsRequest

func (c *Slb) DescribeLoadBalancerAclsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) DescribeLoadBalancerAclsWithContext

func (c *Slb) DescribeLoadBalancerAclsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) DescribeLoadBalancers

func (c *Slb) DescribeLoadBalancers(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) DescribeLoadBalancersRequest

func (c *Slb) DescribeLoadBalancersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) DescribeLoadBalancersWithContext

func (c *Slb) DescribeLoadBalancersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) DescribeRules

func (c *Slb) DescribeRules(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) DescribeRulesRequest

func (c *Slb) DescribeRulesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) DescribeRulesWithContext

func (c *Slb) DescribeRulesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) DisassociateLoadBalancerAcl

func (c *Slb) DisassociateLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) DisassociateLoadBalancerAclRequest

func (c *Slb) DisassociateLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) DisassociateLoadBalancerAclWithContext

func (c *Slb) DisassociateLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) ModifyBackendServer

func (c *Slb) ModifyBackendServer(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) ModifyBackendServerGroup

func (c *Slb) ModifyBackendServerGroup(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) ModifyBackendServerGroupHealthCheck

func (c *Slb) ModifyBackendServerGroupHealthCheck(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) ModifyBackendServerGroupHealthCheckRequest

func (c *Slb) ModifyBackendServerGroupHealthCheckRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) ModifyBackendServerGroupHealthCheckWithContext

func (c *Slb) ModifyBackendServerGroupHealthCheckWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) ModifyBackendServerGroupRequest

func (c *Slb) ModifyBackendServerGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) ModifyBackendServerGroupWithContext

func (c *Slb) ModifyBackendServerGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) ModifyBackendServerRequest

func (c *Slb) ModifyBackendServerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) ModifyBackendServerWithContext

func (c *Slb) ModifyBackendServerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) ModifyHealthCheck

func (c *Slb) ModifyHealthCheck(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) ModifyHealthCheckRequest

func (c *Slb) ModifyHealthCheckRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) ModifyHealthCheckWithContext

func (c *Slb) ModifyHealthCheckWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) ModifyHostHeader

func (c *Slb) ModifyHostHeader(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) ModifyHostHeaderRequest

func (c *Slb) ModifyHostHeaderRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) ModifyHostHeaderWithContext

func (c *Slb) ModifyHostHeaderWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) ModifyInstancesWithListener

func (c *Slb) ModifyInstancesWithListener(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) ModifyInstancesWithListenerRequest

func (c *Slb) ModifyInstancesWithListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) ModifyInstancesWithListenerWithContext

func (c *Slb) ModifyInstancesWithListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) ModifyListeners

func (c *Slb) ModifyListeners(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) ModifyListenersRequest

func (c *Slb) ModifyListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) ModifyListenersWithContext

func (c *Slb) ModifyListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) ModifyLoadBalancer

func (c *Slb) ModifyLoadBalancer(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) ModifyLoadBalancerAcl

func (c *Slb) ModifyLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) ModifyLoadBalancerAclEntry

func (c *Slb) ModifyLoadBalancerAclEntry(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) ModifyLoadBalancerAclEntryRequest

func (c *Slb) ModifyLoadBalancerAclEntryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) ModifyLoadBalancerAclEntryWithContext

func (c *Slb) ModifyLoadBalancerAclEntryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) ModifyLoadBalancerAclRequest

func (c *Slb) ModifyLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) ModifyLoadBalancerAclWithContext

func (c *Slb) ModifyLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) ModifyLoadBalancerRequest

func (c *Slb) ModifyLoadBalancerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) ModifyLoadBalancerWithContext

func (c *Slb) ModifyLoadBalancerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) ModifySlbRule

func (c *Slb) ModifySlbRule(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) ModifySlbRuleRequest

func (c *Slb) ModifySlbRuleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) ModifySlbRuleWithContext

func (c *Slb) ModifySlbRuleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) RegisterBackendServer

func (c *Slb) RegisterBackendServer(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) RegisterBackendServerRequest

func (c *Slb) RegisterBackendServerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) RegisterBackendServerWithContext

func (c *Slb) RegisterBackendServerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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 (*Slb) RegisterInstancesWithListener

func (c *Slb) RegisterInstancesWithListener(input *map[string]interface{}) (*map[string]interface{}, error)

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 (*Slb) RegisterInstancesWithListenerRequest

func (c *Slb) RegisterInstancesWithListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

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 (*Slb) RegisterInstancesWithListenerWithContext

func (c *Slb) RegisterInstancesWithListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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.