alb

func (*ALB) AddAclEntries ¶

func (c *ALB) AddAclEntries(input *AddAclEntriesInput) (*AddAclEntriesOutput, error)

AddAclEntries API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation AddAclEntries for usage and error information.

func (*ALB) AddAclEntriesCommon ¶

func (c *ALB) AddAclEntriesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

AddAclEntriesCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation AddAclEntriesCommon for usage and error information.

func (*ALB) AddAclEntriesCommonRequest ¶

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

AddAclEntriesCommonRequest generates a "byteplus/request.Request" representing the client's request for the AddAclEntriesCommon operation. The "output" return value will be populated with the AddAclEntriesCommon request's response once the request completes successfully.

Use "Send" method on the returned AddAclEntriesCommon Request to send the API call to the service. the "output" return value is not valid until after AddAclEntriesCommon Send returns without error.

See AddAclEntriesCommon for more information on using the AddAclEntriesCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) AddAclEntriesCommonWithContext ¶

func (c *ALB) AddAclEntriesCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See AddAclEntriesCommon 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 (*ALB) AddAclEntriesRequest ¶

func (c *ALB) AddAclEntriesRequest(input *AddAclEntriesInput) (req *request.Request, output *AddAclEntriesOutput)

AddAclEntriesRequest generates a "byteplus/request.Request" representing the client's request for the AddAclEntries operation. The "output" return value will be populated with the AddAclEntriesCommon request's response once the request completes successfully.

Use "Send" method on the returned AddAclEntriesCommon Request to send the API call to the service. the "output" return value is not valid until after AddAclEntriesCommon Send returns without error.

See AddAclEntries for more information on using the AddAclEntries API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) AddAclEntriesWithContext ¶

func (c *ALB) AddAclEntriesWithContext(ctx byteplus.Context, input *AddAclEntriesInput, opts ...request.Option) (*AddAclEntriesOutput, error)

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

See AddAclEntries for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. Ifthe 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 (*ALB) AddServerGroupBackendServers ¶

func (c *ALB) AddServerGroupBackendServers(input *AddServerGroupBackendServersInput) (*AddServerGroupBackendServersOutput, error)

AddServerGroupBackendServers API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation AddServerGroupBackendServers for usage and error information.

func (*ALB) AddServerGroupBackendServersCommon ¶

func (c *ALB) AddServerGroupBackendServersCommon(input *map[string]interface{}) (*map[string]interface{}, error)

AddServerGroupBackendServersCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation AddServerGroupBackendServersCommon for usage and error information.

func (*ALB) AddServerGroupBackendServersCommonRequest ¶

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

AddServerGroupBackendServersCommonRequest generates a "byteplus/request.Request" representing the client's request for the AddServerGroupBackendServersCommon operation. The "output" return value will be populated with the AddServerGroupBackendServersCommon request's response once the request completes successfully.

Use "Send" method on the returned AddServerGroupBackendServersCommon Request to send the API call to the service. the "output" return value is not valid until after AddServerGroupBackendServersCommon Send returns without error.

See AddServerGroupBackendServersCommon for more information on using the AddServerGroupBackendServersCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) AddServerGroupBackendServersCommonWithContext ¶

func (c *ALB) AddServerGroupBackendServersCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See AddServerGroupBackendServersCommon 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 (*ALB) AddServerGroupBackendServersRequest ¶

func (c *ALB) AddServerGroupBackendServersRequest(input *AddServerGroupBackendServersInput) (req *request.Request, output *AddServerGroupBackendServersOutput)

AddServerGroupBackendServersRequest generates a "byteplus/request.Request" representing the client's request for the AddServerGroupBackendServers operation. The "output" return value will be populated with the AddServerGroupBackendServersCommon request's response once the request completes successfully.

Use "Send" method on the returned AddServerGroupBackendServersCommon Request to send the API call to the service. the "output" return value is not valid until after AddServerGroupBackendServersCommon Send returns without error.

See AddServerGroupBackendServers for more information on using the AddServerGroupBackendServers API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) AddServerGroupBackendServersWithContext ¶

func (c *ALB) AddServerGroupBackendServersWithContext(ctx byteplus.Context, input *AddServerGroupBackendServersInput, opts ...request.Option) (*AddServerGroupBackendServersOutput, error)

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

See AddServerGroupBackendServers for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. Ifthe 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 (*ALB) CloneLoadBalancer ¶

func (c *ALB) CloneLoadBalancer(input *CloneLoadBalancerInput) (*CloneLoadBalancerOutput, error)

CloneLoadBalancer API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation CloneLoadBalancer for usage and error information.

func (*ALB) CloneLoadBalancerCommon ¶

func (c *ALB) CloneLoadBalancerCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CloneLoadBalancerCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation CloneLoadBalancerCommon for usage and error information.

func (*ALB) CloneLoadBalancerCommonRequest ¶

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

CloneLoadBalancerCommonRequest generates a "byteplus/request.Request" representing the client's request for the CloneLoadBalancerCommon operation. The "output" return value will be populated with the CloneLoadBalancerCommon request's response once the request completes successfully.

Use "Send" method on the returned CloneLoadBalancerCommon Request to send the API call to the service. the "output" return value is not valid until after CloneLoadBalancerCommon Send returns without error.

See CloneLoadBalancerCommon for more information on using the CloneLoadBalancerCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) CloneLoadBalancerCommonWithContext ¶

func (c *ALB) CloneLoadBalancerCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CloneLoadBalancerCommon 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 (*ALB) CloneLoadBalancerRequest ¶

func (c *ALB) CloneLoadBalancerRequest(input *CloneLoadBalancerInput) (req *request.Request, output *CloneLoadBalancerOutput)

CloneLoadBalancerRequest generates a "byteplus/request.Request" representing the client's request for the CloneLoadBalancer operation. The "output" return value will be populated with the CloneLoadBalancerCommon request's response once the request completes successfully.

Use "Send" method on the returned CloneLoadBalancerCommon Request to send the API call to the service. the "output" return value is not valid until after CloneLoadBalancerCommon Send returns without error.

See CloneLoadBalancer for more information on using the CloneLoadBalancer API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) CloneLoadBalancerWithContext ¶

func (c *ALB) CloneLoadBalancerWithContext(ctx byteplus.Context, input *CloneLoadBalancerInput, opts ...request.Option) (*CloneLoadBalancerOutput, error)

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

See CloneLoadBalancer for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. Ifthe 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 (*ALB) CreateAcl ¶

func (c *ALB) CreateAcl(input *CreateAclInput) (*CreateAclOutput, error)

CreateAcl API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation CreateAcl for usage and error information.

func (*ALB) CreateAclCommon ¶

func (c *ALB) CreateAclCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateAclCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation CreateAclCommon for usage and error information.

func (*ALB) CreateAclCommonRequest ¶

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

CreateAclCommonRequest generates a "byteplus/request.Request" representing the client's request for the CreateAclCommon operation. The "output" return value will be populated with the CreateAclCommon request's response once the request completes successfully.

Use "Send" method on the returned CreateAclCommon Request to send the API call to the service. the "output" return value is not valid until after CreateAclCommon Send returns without error.

See CreateAclCommon for more information on using the CreateAclCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) CreateAclCommonWithContext ¶

func (c *ALB) CreateAclCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateAclCommon 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 (*ALB) CreateAclRequest ¶

func (c *ALB) CreateAclRequest(input *CreateAclInput) (req *request.Request, output *CreateAclOutput)

CreateAclRequest generates a "byteplus/request.Request" representing the client's request for the CreateAcl operation. The "output" return value will be populated with the CreateAclCommon request's response once the request completes successfully.

Use "Send" method on the returned CreateAclCommon Request to send the API call to the service. the "output" return value is not valid until after CreateAclCommon Send returns without error.

See CreateAcl for more information on using the CreateAcl API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) CreateAclWithContext ¶

func (c *ALB) CreateAclWithContext(ctx byteplus.Context, input *CreateAclInput, opts ...request.Option) (*CreateAclOutput, error)

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

See CreateAcl for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. Ifthe 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 (*ALB) CreateCustomizedCfg ¶

func (c *ALB) CreateCustomizedCfg(input *CreateCustomizedCfgInput) (*CreateCustomizedCfgOutput, error)

CreateCustomizedCfg API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation CreateCustomizedCfg for usage and error information.

func (*ALB) CreateCustomizedCfgCommon ¶

func (c *ALB) CreateCustomizedCfgCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateCustomizedCfgCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation CreateCustomizedCfgCommon for usage and error information.

func (*ALB) CreateCustomizedCfgCommonRequest ¶

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

CreateCustomizedCfgCommonRequest generates a "byteplus/request.Request" representing the client's request for the CreateCustomizedCfgCommon operation. The "output" return value will be populated with the CreateCustomizedCfgCommon request's response once the request completes successfully.

Use "Send" method on the returned CreateCustomizedCfgCommon Request to send the API call to the service. the "output" return value is not valid until after CreateCustomizedCfgCommon Send returns without error.

See CreateCustomizedCfgCommon for more information on using the CreateCustomizedCfgCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) CreateCustomizedCfgCommonWithContext ¶

func (c *ALB) CreateCustomizedCfgCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateCustomizedCfgCommon 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 (*ALB) CreateCustomizedCfgRequest ¶

func (c *ALB) CreateCustomizedCfgRequest(input *CreateCustomizedCfgInput) (req *request.Request, output *CreateCustomizedCfgOutput)

CreateCustomizedCfgRequest generates a "byteplus/request.Request" representing the client's request for the CreateCustomizedCfg operation. The "output" return value will be populated with the CreateCustomizedCfgCommon request's response once the request completes successfully.

Use "Send" method on the returned CreateCustomizedCfgCommon Request to send the API call to the service. the "output" return value is not valid until after CreateCustomizedCfgCommon Send returns without error.

See CreateCustomizedCfg for more information on using the CreateCustomizedCfg API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) CreateCustomizedCfgWithContext ¶

func (c *ALB) CreateCustomizedCfgWithContext(ctx byteplus.Context, input *CreateCustomizedCfgInput, opts ...request.Option) (*CreateCustomizedCfgOutput, error)

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

See CreateCustomizedCfg for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. Ifthe 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 (*ALB) CreateHealthCheckTemplates ¶

func (c *ALB) CreateHealthCheckTemplates(input *CreateHealthCheckTemplatesInput) (*CreateHealthCheckTemplatesOutput, error)

CreateHealthCheckTemplates API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation CreateHealthCheckTemplates for usage and error information.

func (*ALB) CreateHealthCheckTemplatesCommon ¶

func (c *ALB) CreateHealthCheckTemplatesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateHealthCheckTemplatesCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation CreateHealthCheckTemplatesCommon for usage and error information.

func (*ALB) CreateHealthCheckTemplatesCommonRequest ¶

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

CreateHealthCheckTemplatesCommonRequest generates a "byteplus/request.Request" representing the client's request for the CreateHealthCheckTemplatesCommon operation. The "output" return value will be populated with the CreateHealthCheckTemplatesCommon request's response once the request completes successfully.

Use "Send" method on the returned CreateHealthCheckTemplatesCommon Request to send the API call to the service. the "output" return value is not valid until after CreateHealthCheckTemplatesCommon Send returns without error.

See CreateHealthCheckTemplatesCommon for more information on using the CreateHealthCheckTemplatesCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) CreateHealthCheckTemplatesCommonWithContext ¶

func (c *ALB) CreateHealthCheckTemplatesCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateHealthCheckTemplatesCommon 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 (*ALB) CreateHealthCheckTemplatesRequest ¶

func (c *ALB) CreateHealthCheckTemplatesRequest(input *CreateHealthCheckTemplatesInput) (req *request.Request, output *CreateHealthCheckTemplatesOutput)

CreateHealthCheckTemplatesRequest generates a "byteplus/request.Request" representing the client's request for the CreateHealthCheckTemplates operation. The "output" return value will be populated with the CreateHealthCheckTemplatesCommon request's response once the request completes successfully.

Use "Send" method on the returned CreateHealthCheckTemplatesCommon Request to send the API call to the service. the "output" return value is not valid until after CreateHealthCheckTemplatesCommon Send returns without error.

See CreateHealthCheckTemplates for more information on using the CreateHealthCheckTemplates API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) CreateHealthCheckTemplatesWithContext ¶

func (c *ALB) CreateHealthCheckTemplatesWithContext(ctx byteplus.Context, input *CreateHealthCheckTemplatesInput, opts ...request.Option) (*CreateHealthCheckTemplatesOutput, error)

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

See CreateHealthCheckTemplates for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. Ifthe 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 (*ALB) CreateListener ¶

func (c *ALB) CreateListener(input *CreateListenerInput) (*CreateListenerOutput, error)

CreateListener API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation CreateListener for usage and error information.

func (*ALB) CreateListenerCommon ¶

func (c *ALB) CreateListenerCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateListenerCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation CreateListenerCommon for usage and error information.

func (*ALB) CreateListenerCommonRequest ¶

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

CreateListenerCommonRequest generates a "byteplus/request.Request" representing the client's request for the CreateListenerCommon operation. The "output" return value will be populated with the CreateListenerCommon request's response once the request completes successfully.

Use "Send" method on the returned CreateListenerCommon Request to send the API call to the service. the "output" return value is not valid until after CreateListenerCommon Send returns without error.

See CreateListenerCommon for more information on using the CreateListenerCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) CreateListenerCommonWithContext ¶

func (c *ALB) CreateListenerCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateListenerCommon 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 (*ALB) CreateListenerRequest ¶

func (c *ALB) CreateListenerRequest(input *CreateListenerInput) (req *request.Request, output *CreateListenerOutput)

CreateListenerRequest generates a "byteplus/request.Request" representing the client's request for the CreateListener operation. The "output" return value will be populated with the CreateListenerCommon request's response once the request completes successfully.

Use "Send" method on the returned CreateListenerCommon Request to send the API call to the service. the "output" return value is not valid until after CreateListenerCommon Send returns without error.

See CreateListener for more information on using the CreateListener API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) CreateListenerWithContext ¶

func (c *ALB) CreateListenerWithContext(ctx byteplus.Context, input *CreateListenerInput, opts ...request.Option) (*CreateListenerOutput, error)

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

See CreateListener for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. Ifthe 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 (*ALB) CreateLoadBalancer ¶

func (c *ALB) CreateLoadBalancer(input *CreateLoadBalancerInput) (*CreateLoadBalancerOutput, error)

CreateLoadBalancer API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation CreateLoadBalancer for usage and error information.

func (*ALB) CreateLoadBalancerCommon ¶

func (c *ALB) CreateLoadBalancerCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateLoadBalancerCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation CreateLoadBalancerCommon for usage and error information.

func (*ALB) CreateLoadBalancerCommonRequest ¶

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

CreateLoadBalancerCommonRequest generates a "byteplus/request.Request" representing the client's request for the CreateLoadBalancerCommon operation. The "output" return value will be populated with the CreateLoadBalancerCommon request's response once the request completes successfully.

Use "Send" method on the returned CreateLoadBalancerCommon Request to send the API call to the service. the "output" return value is not valid until after CreateLoadBalancerCommon Send returns without error.

See CreateLoadBalancerCommon for more information on using the CreateLoadBalancerCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) CreateLoadBalancerCommonWithContext ¶

func (c *ALB) CreateLoadBalancerCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateLoadBalancerCommon 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 (*ALB) CreateLoadBalancerRequest ¶

func (c *ALB) CreateLoadBalancerRequest(input *CreateLoadBalancerInput) (req *request.Request, output *CreateLoadBalancerOutput)

CreateLoadBalancerRequest generates a "byteplus/request.Request" representing the client's request for the CreateLoadBalancer operation. The "output" return value will be populated with the CreateLoadBalancerCommon request's response once the request completes successfully.

Use "Send" method on the returned CreateLoadBalancerCommon Request to send the API call to the service. the "output" return value is not valid until after CreateLoadBalancerCommon Send returns without error.

See CreateLoadBalancer for more information on using the CreateLoadBalancer API call, and error handling.

// 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)
}

func (*ALB) CreateLoadBalancerWithContext ¶

func (c *ALB) CreateLoadBalancerWithContext(ctx byteplus.Context, input *CreateLoadBalancerInput, opts ...request.Option) (*CreateLoadBalancerOutput, 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. Ifthe 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 (*ALB) CreateRules ¶

func (c *ALB) CreateRules(input *CreateRulesInput) (*CreateRulesOutput, error)

CreateRules API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation CreateRules for usage and error information.

func (*ALB) CreateRulesCommon ¶

func (c *ALB) CreateRulesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateRulesCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation CreateRulesCommon for usage and error information.

func (*ALB) CreateRulesCommonRequest ¶

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

CreateRulesCommonRequest generates a "byteplus/request.Request" representing the client's request for the CreateRulesCommon operation. The "output" return value will be populated with the CreateRulesCommon request's response once the request completes successfully.

Use "Send" method on the returned CreateRulesCommon Request to send the API call to the service. the "output" return value is not valid until after CreateRulesCommon Send returns without error.

See CreateRulesCommon for more information on using the CreateRulesCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) CreateRulesCommonWithContext ¶

func (c *ALB) CreateRulesCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateRulesCommon 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 (*ALB) CreateRulesRequest ¶

func (c *ALB) CreateRulesRequest(input *CreateRulesInput) (req *request.Request, output *CreateRulesOutput)

CreateRulesRequest generates a "byteplus/request.Request" representing the client's request for the CreateRules operation. The "output" return value will be populated with the CreateRulesCommon request's response once the request completes successfully.

Use "Send" method on the returned CreateRulesCommon Request to send the API call to the service. the "output" return value is not valid until after CreateRulesCommon Send returns without error.

See CreateRules for more information on using the CreateRules API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) CreateRulesWithContext ¶

func (c *ALB) CreateRulesWithContext(ctx byteplus.Context, input *CreateRulesInput, opts ...request.Option) (*CreateRulesOutput, error)

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

See CreateRules for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. Ifthe 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 (*ALB) CreateServerGroup ¶

func (c *ALB) CreateServerGroup(input *CreateServerGroupInput) (*CreateServerGroupOutput, error)

CreateServerGroup API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation CreateServerGroup for usage and error information.

func (*ALB) CreateServerGroupCommon ¶

func (c *ALB) CreateServerGroupCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateServerGroupCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation CreateServerGroupCommon for usage and error information.

func (*ALB) CreateServerGroupCommonRequest ¶

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

CreateServerGroupCommonRequest generates a "byteplus/request.Request" representing the client's request for the CreateServerGroupCommon operation. The "output" return value will be populated with the CreateServerGroupCommon request's response once the request completes successfully.

Use "Send" method on the returned CreateServerGroupCommon Request to send the API call to the service. the "output" return value is not valid until after CreateServerGroupCommon Send returns without error.

See CreateServerGroupCommon for more information on using the CreateServerGroupCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) CreateServerGroupCommonWithContext ¶

func (c *ALB) CreateServerGroupCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateServerGroupCommon 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 (*ALB) CreateServerGroupRequest ¶

func (c *ALB) CreateServerGroupRequest(input *CreateServerGroupInput) (req *request.Request, output *CreateServerGroupOutput)

CreateServerGroupRequest generates a "byteplus/request.Request" representing the client's request for the CreateServerGroup operation. The "output" return value will be populated with the CreateServerGroupCommon request's response once the request completes successfully.

Use "Send" method on the returned CreateServerGroupCommon Request to send the API call to the service. the "output" return value is not valid until after CreateServerGroupCommon Send returns without error.

See CreateServerGroup for more information on using the CreateServerGroup API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) CreateServerGroupWithContext ¶

func (c *ALB) CreateServerGroupWithContext(ctx byteplus.Context, input *CreateServerGroupInput, opts ...request.Option) (*CreateServerGroupOutput, error)

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

See CreateServerGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. Ifthe 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 (*ALB) DeleteAcl ¶

func (c *ALB) DeleteAcl(input *DeleteAclInput) (*DeleteAclOutput, error)

DeleteAcl API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DeleteAcl for usage and error information.

func (*ALB) DeleteAclCommon ¶

func (c *ALB) DeleteAclCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteAclCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DeleteAclCommon for usage and error information.

func (*ALB) DeleteAclCommonRequest ¶

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

DeleteAclCommonRequest generates a "byteplus/request.Request" representing the client's request for the DeleteAclCommon operation. The "output" return value will be populated with the DeleteAclCommon request's response once the request completes successfully.

Use "Send" method on the returned DeleteAclCommon Request to send the API call to the service. the "output" return value is not valid until after DeleteAclCommon Send returns without error.

See DeleteAclCommon for more information on using the DeleteAclCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DeleteAclCommonWithContext ¶

func (c *ALB) DeleteAclCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteAclCommon 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 (*ALB) DeleteAclRequest ¶

func (c *ALB) DeleteAclRequest(input *DeleteAclInput) (req *request.Request, output *DeleteAclOutput)

DeleteAclRequest generates a "byteplus/request.Request" representing the client's request for the DeleteAcl operation. The "output" return value will be populated with the DeleteAclCommon request's response once the request completes successfully.

Use "Send" method on the returned DeleteAclCommon Request to send the API call to the service. the "output" return value is not valid until after DeleteAclCommon Send returns without error.

See DeleteAcl for more information on using the DeleteAcl API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DeleteAclWithContext ¶

func (c *ALB) DeleteAclWithContext(ctx byteplus.Context, input *DeleteAclInput, opts ...request.Option) (*DeleteAclOutput, error)

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

See DeleteAcl for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. Ifthe 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 (*ALB) DeleteCACertificate ¶

func (c *ALB) DeleteCACertificate(input *DeleteCACertificateInput) (*DeleteCACertificateOutput, error)

DeleteCACertificate API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DeleteCACertificate for usage and error information.

func (*ALB) DeleteCACertificateCommon ¶

func (c *ALB) DeleteCACertificateCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteCACertificateCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DeleteCACertificateCommon for usage and error information.

func (*ALB) DeleteCACertificateCommonRequest ¶

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

DeleteCACertificateCommonRequest generates a "byteplus/request.Request" representing the client's request for the DeleteCACertificateCommon operation. The "output" return value will be populated with the DeleteCACertificateCommon request's response once the request completes successfully.

Use "Send" method on the returned DeleteCACertificateCommon Request to send the API call to the service. the "output" return value is not valid until after DeleteCACertificateCommon Send returns without error.

See DeleteCACertificateCommon for more information on using the DeleteCACertificateCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DeleteCACertificateCommonWithContext ¶

func (c *ALB) DeleteCACertificateCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteCACertificateCommon 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 (*ALB) DeleteCACertificateRequest ¶

func (c *ALB) DeleteCACertificateRequest(input *DeleteCACertificateInput) (req *request.Request, output *DeleteCACertificateOutput)

DeleteCACertificateRequest generates a "byteplus/request.Request" representing the client's request for the DeleteCACertificate operation. The "output" return value will be populated with the DeleteCACertificateCommon request's response once the request completes successfully.

Use "Send" method on the returned DeleteCACertificateCommon Request to send the API call to the service. the "output" return value is not valid until after DeleteCACertificateCommon Send returns without error.

See DeleteCACertificate for more information on using the DeleteCACertificate API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DeleteCACertificateWithContext ¶

func (c *ALB) DeleteCACertificateWithContext(ctx byteplus.Context, input *DeleteCACertificateInput, opts ...request.Option) (*DeleteCACertificateOutput, error)

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

See DeleteCACertificate for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. Ifthe 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 (*ALB) DeleteCertificate ¶

func (c *ALB) DeleteCertificate(input *DeleteCertificateInput) (*DeleteCertificateOutput, error)

DeleteCertificate API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DeleteCertificate for usage and error information.

func (*ALB) DeleteCertificateCommon ¶

func (c *ALB) DeleteCertificateCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteCertificateCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DeleteCertificateCommon for usage and error information.

func (*ALB) DeleteCertificateCommonRequest ¶

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

DeleteCertificateCommonRequest generates a "byteplus/request.Request" representing the client's request for the DeleteCertificateCommon operation. The "output" return value will be populated with the DeleteCertificateCommon request's response once the request completes successfully.

Use "Send" method on the returned DeleteCertificateCommon Request to send the API call to the service. the "output" return value is not valid until after DeleteCertificateCommon Send returns without error.

See DeleteCertificateCommon for more information on using the DeleteCertificateCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DeleteCertificateCommonWithContext ¶

func (c *ALB) DeleteCertificateCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteCertificateCommon 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 (*ALB) DeleteCertificateRequest ¶

func (c *ALB) DeleteCertificateRequest(input *DeleteCertificateInput) (req *request.Request, output *DeleteCertificateOutput)

DeleteCertificateRequest generates a "byteplus/request.Request" representing the client's request for the DeleteCertificate operation. The "output" return value will be populated with the DeleteCertificateCommon request's response once the request completes successfully.

Use "Send" method on the returned DeleteCertificateCommon Request to send the API call to the service. the "output" return value is not valid until after DeleteCertificateCommon Send returns without error.

See DeleteCertificate for more information on using the DeleteCertificate API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DeleteCertificateWithContext ¶

func (c *ALB) DeleteCertificateWithContext(ctx byteplus.Context, input *DeleteCertificateInput, opts ...request.Option) (*DeleteCertificateOutput, error)

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

See DeleteCertificate for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. Ifthe 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 (*ALB) DeleteCustomizedCfg ¶

func (c *ALB) DeleteCustomizedCfg(input *DeleteCustomizedCfgInput) (*DeleteCustomizedCfgOutput, error)

DeleteCustomizedCfg API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DeleteCustomizedCfg for usage and error information.

func (*ALB) DeleteCustomizedCfgCommon ¶

func (c *ALB) DeleteCustomizedCfgCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteCustomizedCfgCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DeleteCustomizedCfgCommon for usage and error information.

func (*ALB) DeleteCustomizedCfgCommonRequest ¶

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

DeleteCustomizedCfgCommonRequest generates a "byteplus/request.Request" representing the client's request for the DeleteCustomizedCfgCommon operation. The "output" return value will be populated with the DeleteCustomizedCfgCommon request's response once the request completes successfully.

Use "Send" method on the returned DeleteCustomizedCfgCommon Request to send the API call to the service. the "output" return value is not valid until after DeleteCustomizedCfgCommon Send returns without error.

See DeleteCustomizedCfgCommon for more information on using the DeleteCustomizedCfgCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DeleteCustomizedCfgCommonWithContext ¶

func (c *ALB) DeleteCustomizedCfgCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteCustomizedCfgCommon 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 (*ALB) DeleteCustomizedCfgRequest ¶

func (c *ALB) DeleteCustomizedCfgRequest(input *DeleteCustomizedCfgInput) (req *request.Request, output *DeleteCustomizedCfgOutput)

DeleteCustomizedCfgRequest generates a "byteplus/request.Request" representing the client's request for the DeleteCustomizedCfg operation. The "output" return value will be populated with the DeleteCustomizedCfgCommon request's response once the request completes successfully.

Use "Send" method on the returned DeleteCustomizedCfgCommon Request to send the API call to the service. the "output" return value is not valid until after DeleteCustomizedCfgCommon Send returns without error.

See DeleteCustomizedCfg for more information on using the DeleteCustomizedCfg API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DeleteCustomizedCfgWithContext ¶

func (c *ALB) DeleteCustomizedCfgWithContext(ctx byteplus.Context, input *DeleteCustomizedCfgInput, opts ...request.Option) (*DeleteCustomizedCfgOutput, error)

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

See DeleteCustomizedCfg for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. Ifthe 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 (*ALB) DeleteHealthCheckTemplates ¶

func (c *ALB) DeleteHealthCheckTemplates(input *DeleteHealthCheckTemplatesInput) (*DeleteHealthCheckTemplatesOutput, error)

DeleteHealthCheckTemplates API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DeleteHealthCheckTemplates for usage and error information.

func (*ALB) DeleteHealthCheckTemplatesCommon ¶

func (c *ALB) DeleteHealthCheckTemplatesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteHealthCheckTemplatesCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DeleteHealthCheckTemplatesCommon for usage and error information.

func (*ALB) DeleteHealthCheckTemplatesCommonRequest ¶

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

DeleteHealthCheckTemplatesCommonRequest generates a "byteplus/request.Request" representing the client's request for the DeleteHealthCheckTemplatesCommon operation. The "output" return value will be populated with the DeleteHealthCheckTemplatesCommon request's response once the request completes successfully.

Use "Send" method on the returned DeleteHealthCheckTemplatesCommon Request to send the API call to the service. the "output" return value is not valid until after DeleteHealthCheckTemplatesCommon Send returns without error.

See DeleteHealthCheckTemplatesCommon for more information on using the DeleteHealthCheckTemplatesCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DeleteHealthCheckTemplatesCommonWithContext ¶

func (c *ALB) DeleteHealthCheckTemplatesCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteHealthCheckTemplatesCommon 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 (*ALB) DeleteHealthCheckTemplatesRequest ¶

func (c *ALB) DeleteHealthCheckTemplatesRequest(input *DeleteHealthCheckTemplatesInput) (req *request.Request, output *DeleteHealthCheckTemplatesOutput)

DeleteHealthCheckTemplatesRequest generates a "byteplus/request.Request" representing the client's request for the DeleteHealthCheckTemplates operation. The "output" return value will be populated with the DeleteHealthCheckTemplatesCommon request's response once the request completes successfully.

Use "Send" method on the returned DeleteHealthCheckTemplatesCommon Request to send the API call to the service. the "output" return value is not valid until after DeleteHealthCheckTemplatesCommon Send returns without error.

See DeleteHealthCheckTemplates for more information on using the DeleteHealthCheckTemplates API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DeleteHealthCheckTemplatesWithContext ¶

func (c *ALB) DeleteHealthCheckTemplatesWithContext(ctx byteplus.Context, input *DeleteHealthCheckTemplatesInput, opts ...request.Option) (*DeleteHealthCheckTemplatesOutput, error)

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

See DeleteHealthCheckTemplates for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. Ifthe 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 (*ALB) DeleteListener ¶

func (c *ALB) DeleteListener(input *DeleteListenerInput) (*DeleteListenerOutput, error)

DeleteListener API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DeleteListener for usage and error information.

func (*ALB) DeleteListenerCommon ¶

func (c *ALB) DeleteListenerCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteListenerCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DeleteListenerCommon for usage and error information.

func (*ALB) DeleteListenerCommonRequest ¶

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

DeleteListenerCommonRequest generates a "byteplus/request.Request" representing the client's request for the DeleteListenerCommon operation. The "output" return value will be populated with the DeleteListenerCommon request's response once the request completes successfully.

Use "Send" method on the returned DeleteListenerCommon Request to send the API call to the service. the "output" return value is not valid until after DeleteListenerCommon Send returns without error.

See DeleteListenerCommon for more information on using the DeleteListenerCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DeleteListenerCommonWithContext ¶

func (c *ALB) DeleteListenerCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteListenerCommon 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 (*ALB) DeleteListenerRequest ¶

func (c *ALB) DeleteListenerRequest(input *DeleteListenerInput) (req *request.Request, output *DeleteListenerOutput)

DeleteListenerRequest generates a "byteplus/request.Request" representing the client's request for the DeleteListener operation. The "output" return value will be populated with the DeleteListenerCommon request's response once the request completes successfully.

Use "Send" method on the returned DeleteListenerCommon Request to send the API call to the service. the "output" return value is not valid until after DeleteListenerCommon Send returns without error.

See DeleteListener for more information on using the DeleteListener API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DeleteListenerWithContext ¶

func (c *ALB) DeleteListenerWithContext(ctx byteplus.Context, input *DeleteListenerInput, opts ...request.Option) (*DeleteListenerOutput, error)

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

See DeleteListener for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. Ifthe 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 (*ALB) DeleteLoadBalancer ¶

func (c *ALB) DeleteLoadBalancer(input *DeleteLoadBalancerInput) (*DeleteLoadBalancerOutput, error)

DeleteLoadBalancer API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DeleteLoadBalancer for usage and error information.

func (*ALB) DeleteLoadBalancerCommon ¶

func (c *ALB) DeleteLoadBalancerCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteLoadBalancerCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DeleteLoadBalancerCommon for usage and error information.

func (*ALB) DeleteLoadBalancerCommonRequest ¶

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

DeleteLoadBalancerCommonRequest generates a "byteplus/request.Request" representing the client's request for the DeleteLoadBalancerCommon operation. The "output" return value will be populated with the DeleteLoadBalancerCommon request's response once the request completes successfully.

Use "Send" method on the returned DeleteLoadBalancerCommon Request to send the API call to the service. the "output" return value is not valid until after DeleteLoadBalancerCommon Send returns without error.

See DeleteLoadBalancerCommon for more information on using the DeleteLoadBalancerCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DeleteLoadBalancerCommonWithContext ¶

func (c *ALB) DeleteLoadBalancerCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteLoadBalancerCommon 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 (*ALB) DeleteLoadBalancerRequest ¶

func (c *ALB) DeleteLoadBalancerRequest(input *DeleteLoadBalancerInput) (req *request.Request, output *DeleteLoadBalancerOutput)

DeleteLoadBalancerRequest generates a "byteplus/request.Request" representing the client's request for the DeleteLoadBalancer operation. The "output" return value will be populated with the DeleteLoadBalancerCommon request's response once the request completes successfully.

Use "Send" method on the returned DeleteLoadBalancerCommon Request to send the API call to the service. the "output" return value is not valid until after DeleteLoadBalancerCommon Send returns without error.

See DeleteLoadBalancer for more information on using the DeleteLoadBalancer API call, and error handling.

// 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)
}

func (*ALB) DeleteLoadBalancerWithContext ¶

func (c *ALB) DeleteLoadBalancerWithContext(ctx byteplus.Context, input *DeleteLoadBalancerInput, opts ...request.Option) (*DeleteLoadBalancerOutput, 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. Ifthe 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 (*ALB) DeleteRules ¶

func (c *ALB) DeleteRules(input *DeleteRulesInput) (*DeleteRulesOutput, error)

DeleteRules API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DeleteRules for usage and error information.

func (*ALB) DeleteRulesCommon ¶

func (c *ALB) DeleteRulesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteRulesCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DeleteRulesCommon for usage and error information.

func (*ALB) DeleteRulesCommonRequest ¶

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

DeleteRulesCommonRequest generates a "byteplus/request.Request" representing the client's request for the DeleteRulesCommon operation. The "output" return value will be populated with the DeleteRulesCommon request's response once the request completes successfully.

Use "Send" method on the returned DeleteRulesCommon Request to send the API call to the service. the "output" return value is not valid until after DeleteRulesCommon Send returns without error.

See DeleteRulesCommon for more information on using the DeleteRulesCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DeleteRulesCommonWithContext ¶

func (c *ALB) DeleteRulesCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteRulesCommon 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 (*ALB) DeleteRulesRequest ¶

func (c *ALB) DeleteRulesRequest(input *DeleteRulesInput) (req *request.Request, output *DeleteRulesOutput)

DeleteRulesRequest generates a "byteplus/request.Request" representing the client's request for the DeleteRules operation. The "output" return value will be populated with the DeleteRulesCommon request's response once the request completes successfully.

Use "Send" method on the returned DeleteRulesCommon Request to send the API call to the service. the "output" return value is not valid until after DeleteRulesCommon Send returns without error.

See DeleteRules for more information on using the DeleteRules API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DeleteRulesWithContext ¶

func (c *ALB) DeleteRulesWithContext(ctx byteplus.Context, input *DeleteRulesInput, opts ...request.Option) (*DeleteRulesOutput, error)

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

See DeleteRules for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. Ifthe 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 (*ALB) DeleteServerGroup ¶

func (c *ALB) DeleteServerGroup(input *DeleteServerGroupInput) (*DeleteServerGroupOutput, error)

DeleteServerGroup API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DeleteServerGroup for usage and error information.

func (*ALB) DeleteServerGroupCommon ¶

func (c *ALB) DeleteServerGroupCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteServerGroupCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DeleteServerGroupCommon for usage and error information.

func (*ALB) DeleteServerGroupCommonRequest ¶

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

DeleteServerGroupCommonRequest generates a "byteplus/request.Request" representing the client's request for the DeleteServerGroupCommon operation. The "output" return value will be populated with the DeleteServerGroupCommon request's response once the request completes successfully.

Use "Send" method on the returned DeleteServerGroupCommon Request to send the API call to the service. the "output" return value is not valid until after DeleteServerGroupCommon Send returns without error.

See DeleteServerGroupCommon for more information on using the DeleteServerGroupCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DeleteServerGroupCommonWithContext ¶

func (c *ALB) DeleteServerGroupCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteServerGroupCommon 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 (*ALB) DeleteServerGroupRequest ¶

func (c *ALB) DeleteServerGroupRequest(input *DeleteServerGroupInput) (req *request.Request, output *DeleteServerGroupOutput)

DeleteServerGroupRequest generates a "byteplus/request.Request" representing the client's request for the DeleteServerGroup operation. The "output" return value will be populated with the DeleteServerGroupCommon request's response once the request completes successfully.

Use "Send" method on the returned DeleteServerGroupCommon Request to send the API call to the service. the "output" return value is not valid until after DeleteServerGroupCommon Send returns without error.

See DeleteServerGroup for more information on using the DeleteServerGroup API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DeleteServerGroupWithContext ¶

func (c *ALB) DeleteServerGroupWithContext(ctx byteplus.Context, input *DeleteServerGroupInput, opts ...request.Option) (*DeleteServerGroupOutput, error)

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

See DeleteServerGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. Ifthe 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 (*ALB) DescribeAclAttributes ¶

func (c *ALB) DescribeAclAttributes(input *DescribeAclAttributesInput) (*DescribeAclAttributesOutput, error)

DescribeAclAttributes API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DescribeAclAttributes for usage and error information.

func (*ALB) DescribeAclAttributesCommon ¶

func (c *ALB) DescribeAclAttributesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeAclAttributesCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DescribeAclAttributesCommon for usage and error information.

func (*ALB) DescribeAclAttributesCommonRequest ¶

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

DescribeAclAttributesCommonRequest generates a "byteplus/request.Request" representing the client's request for the DescribeAclAttributesCommon operation. The "output" return value will be populated with the DescribeAclAttributesCommon request's response once the request completes successfully.

Use "Send" method on the returned DescribeAclAttributesCommon Request to send the API call to the service. the "output" return value is not valid until after DescribeAclAttributesCommon Send returns without error.

See DescribeAclAttributesCommon for more information on using the DescribeAclAttributesCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DescribeAclAttributesCommonWithContext ¶

func (c *ALB) DescribeAclAttributesCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DescribeAclAttributesCommon 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 (*ALB) DescribeAclAttributesRequest ¶

func (c *ALB) DescribeAclAttributesRequest(input *DescribeAclAttributesInput) (req *request.Request, output *DescribeAclAttributesOutput)

DescribeAclAttributesRequest generates a "byteplus/request.Request" representing the client's request for the DescribeAclAttributes operation. The "output" return value will be populated with the DescribeAclAttributesCommon request's response once the request completes successfully.

Use "Send" method on the returned DescribeAclAttributesCommon Request to send the API call to the service. the "output" return value is not valid until after DescribeAclAttributesCommon Send returns without error.

See DescribeAclAttributes for more information on using the DescribeAclAttributes API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DescribeAclAttributesWithContext ¶

func (c *ALB) DescribeAclAttributesWithContext(ctx byteplus.Context, input *DescribeAclAttributesInput, opts ...request.Option) (*DescribeAclAttributesOutput, error)

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

See DescribeAclAttributes for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. Ifthe 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 (*ALB) DescribeAcls ¶

func (c *ALB) DescribeAcls(input *DescribeAclsInput) (*DescribeAclsOutput, error)

DescribeAcls API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DescribeAcls for usage and error information.

func (*ALB) DescribeAclsCommon ¶

func (c *ALB) DescribeAclsCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeAclsCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DescribeAclsCommon for usage and error information.

func (*ALB) DescribeAclsCommonRequest ¶

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

DescribeAclsCommonRequest generates a "byteplus/request.Request" representing the client's request for the DescribeAclsCommon operation. The "output" return value will be populated with the DescribeAclsCommon request's response once the request completes successfully.

Use "Send" method on the returned DescribeAclsCommon Request to send the API call to the service. the "output" return value is not valid until after DescribeAclsCommon Send returns without error.

See DescribeAclsCommon for more information on using the DescribeAclsCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DescribeAclsCommonWithContext ¶

func (c *ALB) DescribeAclsCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DescribeAclsCommon 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 (*ALB) DescribeAclsRequest ¶

func (c *ALB) DescribeAclsRequest(input *DescribeAclsInput) (req *request.Request, output *DescribeAclsOutput)

DescribeAclsRequest generates a "byteplus/request.Request" representing the client's request for the DescribeAcls operation. The "output" return value will be populated with the DescribeAclsCommon request's response once the request completes successfully.

Use "Send" method on the returned DescribeAclsCommon Request to send the API call to the service. the "output" return value is not valid until after DescribeAclsCommon Send returns without error.

See DescribeAcls for more information on using the DescribeAcls API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DescribeAclsWithContext ¶

func (c *ALB) DescribeAclsWithContext(ctx byteplus.Context, input *DescribeAclsInput, opts ...request.Option) (*DescribeAclsOutput, error)

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

See DescribeAcls for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. Ifthe 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 (*ALB) DescribeAllCertificates ¶

func (c *ALB) DescribeAllCertificates(input *DescribeAllCertificatesInput) (*DescribeAllCertificatesOutput, error)

DescribeAllCertificates API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DescribeAllCertificates for usage and error information.

func (*ALB) DescribeAllCertificatesCommon ¶

func (c *ALB) DescribeAllCertificatesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeAllCertificatesCommon API operation for ALB.

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

See the BYTEPLUS API reference guide for ALB's API operation DescribeAllCertificatesCommon for usage and error information.

func (*ALB) DescribeAllCertificatesCommonRequest ¶

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

DescribeAllCertificatesCommonRequest generates a "byteplus/request.Request" representing the client's request for the DescribeAllCertificatesCommon operation. The "output" return value will be populated with the DescribeAllCertificatesCommon request's response once the request completes successfully.

Use "Send" method on the returned DescribeAllCertificatesCommon Request to send the API call to the service. the "output" return value is not valid until after DescribeAllCertificatesCommon Send returns without error.

See DescribeAllCertificatesCommon for more information on using the DescribeAllCertificatesCommon API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DescribeAllCertificatesCommonWithContext ¶

func (c *ALB) DescribeAllCertificatesCommonWithContext(ctx byteplus.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DescribeAllCertificatesCommon 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 (*ALB) DescribeAllCertificatesRequest ¶

func (c *ALB) DescribeAllCertificatesRequest(input *DescribeAllCertificatesInput) (req *request.Request, output *DescribeAllCertificatesOutput)

DescribeAllCertificatesRequest generates a "byteplus/request.Request" representing the client's request for the DescribeAllCertificates operation. The "output" return value will be populated with the DescribeAllCertificatesCommon request's response once the request completes successfully.

Use "Send" method on the returned DescribeAllCertificatesCommon Request to send the API call to the service. the "output" return value is not valid until after DescribeAllCertificatesCommon Send returns without error.

See DescribeAllCertificates for more information on using the DescribeAllCertificates API call, and error handling.

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

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*ALB) DescribeAllCertificatesWithContext ¶

func (c *ALB) DescribeAllCertificatesWithContext(ctx byteplus.Context, input *DescribeAllCertificatesInput, opts ...request.Option) (*DescribeAllCertificatesOutput, error)

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

See DescribeAllCertificates for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. Ifthe 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 (*ALB) DescribeCACertificates ¶

func (c *ALB) DescribeCACertificates(input *DescribeCACertificatesInput) (*DescribeCACertificatesOutput, error)