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) AddAlbRule(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) AddAlbRuleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) AddAlbRuleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) AssociateCertificateWithGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) AssociateCertificateWithGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) AssociateCertificateWithGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • 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) CreateAlb(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) CreateAlbListener(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) CreateAlbListenerCertGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) CreateAlbListenerCertGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) CreateAlbListenerCertGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) CreateAlbListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) CreateAlbListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) CreateAlbRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) CreateAlbRuleGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) CreateAlbRuleGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) CreateAlbRuleGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) CreateAlbWithContext(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) DeleteAlb(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeleteAlbListener(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeleteAlbListenerCertGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeleteAlbListenerCertGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeleteAlbListenerCertGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DeleteAlbListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeleteAlbListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DeleteAlbRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeleteAlbRule(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeleteAlbRuleGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeleteAlbRuleGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeleteAlbRuleGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DeleteAlbRuleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeleteAlbRuleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DeleteAlbWithContext(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) DescribeAlbListenerCertGroups(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DescribeAlbListenerCertGroupsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DescribeAlbListenerCertGroupsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DescribeAlbListeners(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DescribeAlbListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DescribeAlbListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DescribeAlbRuleGroups(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DescribeAlbRuleGroupsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DescribeAlbRuleGroupsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DescribeAlbs(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DescribeAlbsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DescribeAlbsWithContext(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) DescribeLoadBalancerAttributes(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DescribeLoadBalancerAttributesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DescribeLoadBalancerAttributesWithContext(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) DissociateCertificateWithGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DissociateCertificateWithGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DissociateCertificateWithGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) ModifyAlbListener(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ModifyAlbListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ModifyAlbListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) ModifyAlbRuleGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ModifyAlbRuleGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ModifyAlbRuleGroupWithContext(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) ModifyLoadBalancerAttributes(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ModifyLoadBalancerAttributesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ModifyLoadBalancerAttributesWithContext(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)
  • func (c *Slb) SetAlbAccessLog(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) SetAlbAccessLogRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) SetAlbAccessLogWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) SetAlbName(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) SetAlbNameRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) SetAlbNameWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) SetAlbStatus(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) SetAlbStatusRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) SetAlbStatusWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) SetEnableAlbAccessLog(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) SetEnableAlbAccessLogRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) SetEnableAlbAccessLogWithContext(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) AddAlbRule

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

AddAlbRule 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 AddAlbRule for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/AddAlbRule

func (*Slb) AddAlbRuleRequest

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

AddAlbRuleRequest generates a "ksc/request.Request" representing the client's request for the AddAlbRule 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 AddAlbRule for more information on using the AddAlbRule 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 AddAlbRuleRequest method.
req, resp := client.AddAlbRuleRequest(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/AddAlbRule

func (*Slb) AddAlbRuleWithContext

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

AddAlbRuleWithContext is the same as AddAlbRule with the addition of the ability to pass a context and additional request options.

See AddAlbRule 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) AssociateCertificateWithGroup

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

AssociateCertificateWithGroup 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 AssociateCertificateWithGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/AssociateCertificateWithGroup

func (*Slb) AssociateCertificateWithGroupRequest

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

AssociateCertificateWithGroupRequest generates a "ksc/request.Request" representing the client's request for the AssociateCertificateWithGroup 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 AssociateCertificateWithGroup for more information on using the AssociateCertificateWithGroup 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 AssociateCertificateWithGroupRequest method.
req, resp := client.AssociateCertificateWithGroupRequest(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/AssociateCertificateWithGroup

func (*Slb) AssociateCertificateWithGroupWithContext

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

AssociateCertificateWithGroupWithContext is the same as AssociateCertificateWithGroup with the addition of the ability to pass a context and additional request options.

See AssociateCertificateWithGroup 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) 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) CreateAlb

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

CreateAlb 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 CreateAlb for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateAlb

func (*Slb) CreateAlbListener

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

CreateAlbListener 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 CreateAlbListener for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateAlbListener

func (*Slb) CreateAlbListenerCertGroup

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

CreateAlbListenerCertGroup 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 CreateAlbListenerCertGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateAlbListenerCertGroup

func (*Slb) CreateAlbListenerCertGroupRequest

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

CreateAlbListenerCertGroupRequest generates a "ksc/request.Request" representing the client's request for the CreateAlbListenerCertGroup 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 CreateAlbListenerCertGroup for more information on using the CreateAlbListenerCertGroup 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 CreateAlbListenerCertGroupRequest method.
req, resp := client.CreateAlbListenerCertGroupRequest(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/CreateAlbListenerCertGroup

func (*Slb) CreateAlbListenerCertGroupWithContext

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

CreateAlbListenerCertGroupWithContext is the same as CreateAlbListenerCertGroup with the addition of the ability to pass a context and additional request options.

See CreateAlbListenerCertGroup 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) CreateAlbListenerRequest

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

CreateAlbListenerRequest generates a "ksc/request.Request" representing the client's request for the CreateAlbListener 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 CreateAlbListener for more information on using the CreateAlbListener 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 CreateAlbListenerRequest method.
req, resp := client.CreateAlbListenerRequest(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/CreateAlbListener

func (*Slb) CreateAlbListenerWithContext

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

CreateAlbListenerWithContext is the same as CreateAlbListener with the addition of the ability to pass a context and additional request options.

See CreateAlbListener 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) CreateAlbRequest

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

CreateAlbRequest generates a "ksc/request.Request" representing the client's request for the CreateAlb 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 CreateAlb for more information on using the CreateAlb 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 CreateAlbRequest method.
req, resp := client.CreateAlbRequest(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/CreateAlb

func (*Slb) CreateAlbRuleGroup

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

CreateAlbRuleGroup 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 CreateAlbRuleGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateAlbRuleGroup

func (*Slb) CreateAlbRuleGroupRequest

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

CreateAlbRuleGroupRequest generates a "ksc/request.Request" representing the client's request for the CreateAlbRuleGroup 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 CreateAlbRuleGroup for more information on using the CreateAlbRuleGroup 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 CreateAlbRuleGroupRequest method.
req, resp := client.CreateAlbRuleGroupRequest(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/CreateAlbRuleGroup

func (*Slb) CreateAlbRuleGroupWithContext

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

CreateAlbRuleGroupWithContext is the same as CreateAlbRuleGroup with the addition of the ability to pass a context and additional request options.

See CreateAlbRuleGroup 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) CreateAlbWithContext

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

CreateAlbWithContext is the same as CreateAlb with the addition of the ability to pass a context and additional request options.

See CreateAlb 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) DeleteAlb

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

DeleteAlb 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 DeleteAlb for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteAlb

func (*Slb) DeleteAlbListener

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

DeleteAlbListener 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 DeleteAlbListener for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteAlbListener

func (*Slb) DeleteAlbListenerCertGroup

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

DeleteAlbListenerCertGroup 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 DeleteAlbListenerCertGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteAlbListenerCertGroup

func (*Slb) DeleteAlbListenerCertGroupRequest

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

DeleteAlbListenerCertGroupRequest generates a "ksc/request.Request" representing the client's request for the DeleteAlbListenerCertGroup 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 DeleteAlbListenerCertGroup for more information on using the DeleteAlbListenerCertGroup 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 DeleteAlbListenerCertGroupRequest method.
req, resp := client.DeleteAlbListenerCertGroupRequest(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/DeleteAlbListenerCertGroup

func (*Slb) DeleteAlbListenerCertGroupWithContext

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

DeleteAlbListenerCertGroupWithContext is the same as DeleteAlbListenerCertGroup with the addition of the ability to pass a context and additional request options.

See DeleteAlbListenerCertGroup 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) DeleteAlbListenerRequest

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

DeleteAlbListenerRequest generates a "ksc/request.Request" representing the client's request for the DeleteAlbListener 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 DeleteAlbListener for more information on using the DeleteAlbListener 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 DeleteAlbListenerRequest method.
req, resp := client.DeleteAlbListenerRequest(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/DeleteAlbListener

func (*Slb) DeleteAlbListenerWithContext

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

DeleteAlbListenerWithContext is the same as DeleteAlbListener with the addition of the ability to pass a context and additional request options.

See DeleteAlbListener 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) DeleteAlbRequest

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

DeleteAlbRequest generates a "ksc/request.Request" representing the client's request for the DeleteAlb 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 DeleteAlb for more information on using the DeleteAlb 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 DeleteAlbRequest method.
req, resp := client.DeleteAlbRequest(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/DeleteAlb

func (*Slb) DeleteAlbRule

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

DeleteAlbRule 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 DeleteAlbRule for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteAlbRule

func (*Slb) DeleteAlbRuleGroup

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

DeleteAlbRuleGroup 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 DeleteAlbRuleGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteAlbRuleGroup

func (*Slb) DeleteAlbRuleGroupRequest

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

DeleteAlbRuleGroupRequest generates a "ksc/request.Request" representing the client's request for the DeleteAlbRuleGroup 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 DeleteAlbRuleGroup for more information on using the DeleteAlbRuleGroup 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 DeleteAlbRuleGroupRequest method.
req, resp := client.DeleteAlbRuleGroupRequest(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/DeleteAlbRuleGroup

func (*Slb) DeleteAlbRuleGroupWithContext

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

DeleteAlbRuleGroupWithContext is the same as DeleteAlbRuleGroup with the addition of the ability to pass a context and additional request options.

See DeleteAlbRuleGroup 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) DeleteAlbRuleRequest

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

DeleteAlbRuleRequest generates a "ksc/request.Request" representing the client's request for the DeleteAlbRule 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 DeleteAlbRule for more information on using the DeleteAlbRule 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 DeleteAlbRuleRequest method.
req, resp := client.DeleteAlbRuleRequest(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/DeleteAlbRule

func (*Slb) DeleteAlbRuleWithContext

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

DeleteAlbRuleWithContext is the same as DeleteAlbRule with the addition of the ability to pass a context and additional request options.

See DeleteAlbRule 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) DeleteAlbWithContext

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

DeleteAlbWithContext is the same as DeleteAlb with the addition of the ability to pass a context and additional request options.

See DeleteAlb 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) DescribeAlbListenerCertGroups

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

DescribeAlbListenerCertGroups 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 DescribeAlbListenerCertGroups for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeAlbListenerCertGroups

func (*Slb) DescribeAlbListenerCertGroupsRequest

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

DescribeAlbListenerCertGroupsRequest generates a "ksc/request.Request" representing the client's request for the DescribeAlbListenerCertGroups 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 DescribeAlbListenerCertGroups for more information on using the DescribeAlbListenerCertGroups 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 DescribeAlbListenerCertGroupsRequest method.
req, resp := client.DescribeAlbListenerCertGroupsRequest(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/DescribeAlbListenerCertGroups

func (*Slb) DescribeAlbListenerCertGroupsWithContext

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

DescribeAlbListenerCertGroupsWithContext is the same as DescribeAlbListenerCertGroups with the addition of the ability to pass a context and additional request options.

See DescribeAlbListenerCertGroups 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) DescribeAlbListeners

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

DescribeAlbListeners 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 DescribeAlbListeners for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeAlbListeners

func (*Slb) DescribeAlbListenersRequest

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

DescribeAlbListenersRequest generates a "ksc/request.Request" representing the client's request for the DescribeAlbListeners 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 DescribeAlbListeners for more information on using the DescribeAlbListeners 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 DescribeAlbListenersRequest method.
req, resp := client.DescribeAlbListenersRequest(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/DescribeAlbListeners

func (*Slb) DescribeAlbListenersWithContext

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

DescribeAlbListenersWithContext is the same as DescribeAlbListeners with the addition of the ability to pass a context and additional request options.

See DescribeAlbListeners 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) DescribeAlbRuleGroups

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

DescribeAlbRuleGroups 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 DescribeAlbRuleGroups for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeAlbRuleGroups

func (*Slb) DescribeAlbRuleGroupsRequest

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

DescribeAlbRuleGroupsRequest generates a "ksc/request.Request" representing the client's request for the DescribeAlbRuleGroups 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 DescribeAlbRuleGroups for more information on using the DescribeAlbRuleGroups 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 DescribeAlbRuleGroupsRequest method.
req, resp := client.DescribeAlbRuleGroupsRequest(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/DescribeAlbRuleGroups

func (*Slb) DescribeAlbRuleGroupsWithContext

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

DescribeAlbRuleGroupsWithContext is the same as DescribeAlbRuleGroups with the addition of the ability to pass a context and additional request options.

See DescribeAlbRuleGroups 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) DescribeAlbs

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

DescribeAlbs 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 DescribeAlbs for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeAlbs

func (*Slb) DescribeAlbsRequest

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

DescribeAlbsRequest generates a "ksc/request.Request" representing the client's request for the DescribeAlbs 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 DescribeAlbs for more information on using the DescribeAlbs 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 DescribeAlbsRequest method.
req, resp := client.DescribeAlbsRequest(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/DescribeAlbs

func (*Slb) DescribeAlbsWithContext

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

DescribeAlbsWithContext is the same as DescribeAlbs with the addition of the ability to pass a context and additional request options.

See DescribeAlbs 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) DescribeLoadBalancerAttributes

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

DescribeLoadBalancerAttributes 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 DescribeLoadBalancerAttributes for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeLoadBalancerAttributes

func (*Slb) DescribeLoadBalancerAttributesRequest

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

DescribeLoadBalancerAttributesRequest generates a "ksc/request.Request" representing the client's request for the DescribeLoadBalancerAttributes 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 DescribeLoadBalancerAttributes for more information on using the DescribeLoadBalancerAttributes 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 DescribeLoadBalancerAttributesRequest method.
req, resp := client.DescribeLoadBalancerAttributesRequest(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/DescribeLoadBalancerAttributes

func (*Slb) DescribeLoadBalancerAttributesWithContext

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

DescribeLoadBalancerAttributesWithContext is the same as DescribeLoadBalancerAttributes with the addition of the ability to pass a context and additional request options.

See DescribeLoadBalancerAttributes 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) DissociateCertificateWithGroup

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

DissociateCertificateWithGroup 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 DissociateCertificateWithGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DissociateCertificateWithGroup

func (*Slb) DissociateCertificateWithGroupRequest

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

DissociateCertificateWithGroupRequest generates a "ksc/request.Request" representing the client's request for the DissociateCertificateWithGroup 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 DissociateCertificateWithGroup for more information on using the DissociateCertificateWithGroup 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 DissociateCertificateWithGroupRequest method.
req, resp := client.DissociateCertificateWithGroupRequest(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/DissociateCertificateWithGroup

func (*Slb) DissociateCertificateWithGroupWithContext

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

DissociateCertificateWithGroupWithContext is the same as DissociateCertificateWithGroup with the addition of the ability to pass a context and additional request options.

See DissociateCertificateWithGroup 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) ModifyAlbListener

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

ModifyAlbListener 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 ModifyAlbListener for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyAlbListener

func (*Slb) ModifyAlbListenerRequest

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

ModifyAlbListenerRequest generates a "ksc/request.Request" representing the client's request for the ModifyAlbListener 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 ModifyAlbListener for more information on using the ModifyAlbListener 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 ModifyAlbListenerRequest method.
req, resp := client.ModifyAlbListenerRequest(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/ModifyAlbListener

func (*Slb) ModifyAlbListenerWithContext

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

ModifyAlbListenerWithContext is the same as ModifyAlbListener with the addition of the ability to pass a context and additional request options.

See ModifyAlbListener 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) ModifyAlbRuleGroup

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

ModifyAlbRuleGroup 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 ModifyAlbRuleGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyAlbRuleGroup

func (*Slb) ModifyAlbRuleGroupRequest

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

ModifyAlbRuleGroupRequest generates a "ksc/request.Request" representing the client's request for the ModifyAlbRuleGroup 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 ModifyAlbRuleGroup for more information on using the ModifyAlbRuleGroup 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 ModifyAlbRuleGroupRequest method.
req, resp := client.ModifyAlbRuleGroupRequest(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/ModifyAlbRuleGroup

func (*Slb) ModifyAlbRuleGroupWithContext

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

ModifyAlbRuleGroupWithContext is the same as ModifyAlbRuleGroup with the addition of the ability to pass a context and additional request options.

See ModifyAlbRuleGroup 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) ModifyLoadBalancerAttributes

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

ModifyLoadBalancerAttributes 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 ModifyLoadBalancerAttributes for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyLoadBalancerAttributes

func (*Slb) ModifyLoadBalancerAttributesRequest

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

ModifyLoadBalancerAttributesRequest generates a "ksc/request.Request" representing the client's request for the ModifyLoadBalancerAttributes 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 ModifyLoadBalancerAttributes for more information on using the ModifyLoadBalancerAttributes 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 ModifyLoadBalancerAttributesRequest method.
req, resp := client.ModifyLoadBalancerAttributesRequest(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/ModifyLoadBalancerAttributes

func (*Slb) ModifyLoadBalancerAttributesWithContext

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

ModifyLoadBalancerAttributesWithContext is the same as ModifyLoadBalancerAttributes with the addition of the ability to pass a context and additional request options.

See ModifyLoadBalancerAttributes 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.

func (*Slb) SetAlbAccessLog

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

SetAlbAccessLog 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 SetAlbAccessLog for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/SetAlbAccessLog

func (*Slb) SetAlbAccessLogRequest

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

SetAlbAccessLogRequest generates a "ksc/request.Request" representing the client's request for the SetAlbAccessLog 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 SetAlbAccessLog for more information on using the SetAlbAccessLog 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 SetAlbAccessLogRequest method.
req, resp := client.SetAlbAccessLogRequest(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/SetAlbAccessLog

func (*Slb) SetAlbAccessLogWithContext

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

SetAlbAccessLogWithContext is the same as SetAlbAccessLog with the addition of the ability to pass a context and additional request options.

See SetAlbAccessLog 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) SetAlbName

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

SetAlbName 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 SetAlbName for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/SetAlbName

func (*Slb) SetAlbNameRequest

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

SetAlbNameRequest generates a "ksc/request.Request" representing the client's request for the SetAlbName 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 SetAlbName for more information on using the SetAlbName 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 SetAlbNameRequest method.
req, resp := client.SetAlbNameRequest(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/SetAlbName

func (*Slb) SetAlbNameWithContext

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

SetAlbNameWithContext is the same as SetAlbName with the addition of the ability to pass a context and additional request options.

See SetAlbName 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) SetAlbStatus

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

SetAlbStatus 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 SetAlbStatus for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/SetAlbStatus

func (*Slb) SetAlbStatusRequest

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

SetAlbStatusRequest generates a "ksc/request.Request" representing the client's request for the SetAlbStatus 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 SetAlbStatus for more information on using the SetAlbStatus 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 SetAlbStatusRequest method.
req, resp := client.SetAlbStatusRequest(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/SetAlbStatus

func (*Slb) SetAlbStatusWithContext

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

SetAlbStatusWithContext is the same as SetAlbStatus with the addition of the ability to pass a context and additional request options.

See SetAlbStatus 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) SetEnableAlbAccessLog

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

SetEnableAlbAccessLog 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 SetEnableAlbAccessLog for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/SetEnableAlbAccessLog

func (*Slb) SetEnableAlbAccessLogRequest

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

SetEnableAlbAccessLogRequest generates a "ksc/request.Request" representing the client's request for the SetEnableAlbAccessLog 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 SetEnableAlbAccessLog for more information on using the SetEnableAlbAccessLog 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 SetEnableAlbAccessLogRequest method.
req, resp := client.SetEnableAlbAccessLogRequest(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/SetEnableAlbAccessLog

func (*Slb) SetEnableAlbAccessLogWithContext

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

SetEnableAlbAccessLogWithContext is the same as SetEnableAlbAccessLog with the addition of the ability to pass a context and additional request options.

See SetEnableAlbAccessLog 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.