autoscaling

func (*AUTOSCALING) AttachInstances ¶

func (c *AUTOSCALING) AttachInstances(input *AttachInstancesInput) (*AttachInstancesOutput, error)

AttachInstances API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation AttachInstances for usage and error information.

func (*AUTOSCALING) AttachInstancesCommon ¶

func (c *AUTOSCALING) AttachInstancesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

AttachInstancesCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation AttachInstancesCommon for usage and error information.

func (*AUTOSCALING) AttachInstancesCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) AttachInstancesCommonWithContext ¶

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

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

See AttachInstancesCommon 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 (*AUTOSCALING) AttachInstancesRequest ¶

func (c *AUTOSCALING) AttachInstancesRequest(input *AttachInstancesInput) (req *request.Request, output *AttachInstancesOutput)

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

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

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

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

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

func (*AUTOSCALING) AttachInstancesWithContext ¶

func (c *AUTOSCALING) AttachInstancesWithContext(ctx byteplus.Context, input *AttachInstancesInput, opts ...request.Option) (*AttachInstancesOutput, error)

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

See AttachInstances 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 (*AUTOSCALING) AttachServerGroups ¶

func (c *AUTOSCALING) AttachServerGroups(input *AttachServerGroupsInput) (*AttachServerGroupsOutput, error)

AttachServerGroups API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation AttachServerGroups for usage and error information.

func (*AUTOSCALING) AttachServerGroupsCommon ¶

func (c *AUTOSCALING) AttachServerGroupsCommon(input *map[string]interface{}) (*map[string]interface{}, error)

AttachServerGroupsCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation AttachServerGroupsCommon for usage and error information.

func (*AUTOSCALING) AttachServerGroupsCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) AttachServerGroupsCommonWithContext ¶

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

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

See AttachServerGroupsCommon 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 (*AUTOSCALING) AttachServerGroupsRequest ¶

func (c *AUTOSCALING) AttachServerGroupsRequest(input *AttachServerGroupsInput) (req *request.Request, output *AttachServerGroupsOutput)

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

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

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

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

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

func (*AUTOSCALING) AttachServerGroupsWithContext ¶

func (c *AUTOSCALING) AttachServerGroupsWithContext(ctx byteplus.Context, input *AttachServerGroupsInput, opts ...request.Option) (*AttachServerGroupsOutput, error)

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

See AttachServerGroups 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 (*AUTOSCALING) CompleteLifecycleActivity ¶

func (c *AUTOSCALING) CompleteLifecycleActivity(input *CompleteLifecycleActivityInput) (*CompleteLifecycleActivityOutput, error)

CompleteLifecycleActivity API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation CompleteLifecycleActivity for usage and error information.

func (*AUTOSCALING) CompleteLifecycleActivityCommon ¶

func (c *AUTOSCALING) CompleteLifecycleActivityCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CompleteLifecycleActivityCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation CompleteLifecycleActivityCommon for usage and error information.

func (*AUTOSCALING) CompleteLifecycleActivityCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) CompleteLifecycleActivityCommonWithContext ¶

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

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

See CompleteLifecycleActivityCommon 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 (*AUTOSCALING) CompleteLifecycleActivityRequest ¶

func (c *AUTOSCALING) CompleteLifecycleActivityRequest(input *CompleteLifecycleActivityInput) (req *request.Request, output *CompleteLifecycleActivityOutput)

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

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

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

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

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

func (*AUTOSCALING) CompleteLifecycleActivityWithContext ¶

func (c *AUTOSCALING) CompleteLifecycleActivityWithContext(ctx byteplus.Context, input *CompleteLifecycleActivityInput, opts ...request.Option) (*CompleteLifecycleActivityOutput, error)

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

See CompleteLifecycleActivity 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 (*AUTOSCALING) CreateLifecycleHook ¶

func (c *AUTOSCALING) CreateLifecycleHook(input *CreateLifecycleHookInput) (*CreateLifecycleHookOutput, error)

CreateLifecycleHook API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation CreateLifecycleHook for usage and error information.

func (*AUTOSCALING) CreateLifecycleHookCommon ¶

func (c *AUTOSCALING) CreateLifecycleHookCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateLifecycleHookCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation CreateLifecycleHookCommon for usage and error information.

func (*AUTOSCALING) CreateLifecycleHookCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) CreateLifecycleHookCommonWithContext ¶

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

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

See CreateLifecycleHookCommon 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 (*AUTOSCALING) CreateLifecycleHookRequest ¶

func (c *AUTOSCALING) CreateLifecycleHookRequest(input *CreateLifecycleHookInput) (req *request.Request, output *CreateLifecycleHookOutput)

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

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

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

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

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

func (*AUTOSCALING) CreateLifecycleHookWithContext ¶

func (c *AUTOSCALING) CreateLifecycleHookWithContext(ctx byteplus.Context, input *CreateLifecycleHookInput, opts ...request.Option) (*CreateLifecycleHookOutput, error)

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

See CreateLifecycleHook 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 (*AUTOSCALING) CreateNotificationConfiguration ¶

func (c *AUTOSCALING) CreateNotificationConfiguration(input *CreateNotificationConfigurationInput) (*CreateNotificationConfigurationOutput, error)

CreateNotificationConfiguration API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation CreateNotificationConfiguration for usage and error information.

func (*AUTOSCALING) CreateNotificationConfigurationCommon ¶

func (c *AUTOSCALING) CreateNotificationConfigurationCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateNotificationConfigurationCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation CreateNotificationConfigurationCommon for usage and error information.

func (*AUTOSCALING) CreateNotificationConfigurationCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) CreateNotificationConfigurationCommonWithContext ¶

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

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

See CreateNotificationConfigurationCommon 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 (*AUTOSCALING) CreateNotificationConfigurationRequest ¶

func (c *AUTOSCALING) CreateNotificationConfigurationRequest(input *CreateNotificationConfigurationInput) (req *request.Request, output *CreateNotificationConfigurationOutput)

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

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

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

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

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

func (*AUTOSCALING) CreateNotificationConfigurationWithContext ¶

func (c *AUTOSCALING) CreateNotificationConfigurationWithContext(ctx byteplus.Context, input *CreateNotificationConfigurationInput, opts ...request.Option) (*CreateNotificationConfigurationOutput, error)

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

See CreateNotificationConfiguration 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 (*AUTOSCALING) CreateScalingConfiguration ¶

func (c *AUTOSCALING) CreateScalingConfiguration(input *CreateScalingConfigurationInput) (*CreateScalingConfigurationOutput, error)

CreateScalingConfiguration API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation CreateScalingConfiguration for usage and error information.

func (*AUTOSCALING) CreateScalingConfigurationCommon ¶

func (c *AUTOSCALING) CreateScalingConfigurationCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateScalingConfigurationCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation CreateScalingConfigurationCommon for usage and error information.

func (*AUTOSCALING) CreateScalingConfigurationCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) CreateScalingConfigurationCommonWithContext ¶

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

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

See CreateScalingConfigurationCommon 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 (*AUTOSCALING) CreateScalingConfigurationRequest ¶

func (c *AUTOSCALING) CreateScalingConfigurationRequest(input *CreateScalingConfigurationInput) (req *request.Request, output *CreateScalingConfigurationOutput)

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

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

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

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

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

func (*AUTOSCALING) CreateScalingConfigurationWithContext ¶

func (c *AUTOSCALING) CreateScalingConfigurationWithContext(ctx byteplus.Context, input *CreateScalingConfigurationInput, opts ...request.Option) (*CreateScalingConfigurationOutput, error)

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

See CreateScalingConfiguration 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 (*AUTOSCALING) CreateScalingGroup ¶

func (c *AUTOSCALING) CreateScalingGroup(input *CreateScalingGroupInput) (*CreateScalingGroupOutput, error)

CreateScalingGroup API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation CreateScalingGroup for usage and error information.

func (*AUTOSCALING) CreateScalingGroupCommon ¶

func (c *AUTOSCALING) CreateScalingGroupCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateScalingGroupCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation CreateScalingGroupCommon for usage and error information.

func (*AUTOSCALING) CreateScalingGroupCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) CreateScalingGroupCommonWithContext ¶

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

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

See CreateScalingGroupCommon 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 (*AUTOSCALING) CreateScalingGroupRequest ¶

func (c *AUTOSCALING) CreateScalingGroupRequest(input *CreateScalingGroupInput) (req *request.Request, output *CreateScalingGroupOutput)

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

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

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

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

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

func (*AUTOSCALING) CreateScalingGroupWithContext ¶

func (c *AUTOSCALING) CreateScalingGroupWithContext(ctx byteplus.Context, input *CreateScalingGroupInput, opts ...request.Option) (*CreateScalingGroupOutput, error)

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

See CreateScalingGroup 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 (*AUTOSCALING) CreateScalingPolicy ¶

func (c *AUTOSCALING) CreateScalingPolicy(input *CreateScalingPolicyInput) (*CreateScalingPolicyOutput, error)

CreateScalingPolicy API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation CreateScalingPolicy for usage and error information.

func (*AUTOSCALING) CreateScalingPolicyCommon ¶

func (c *AUTOSCALING) CreateScalingPolicyCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateScalingPolicyCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation CreateScalingPolicyCommon for usage and error information.

func (*AUTOSCALING) CreateScalingPolicyCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) CreateScalingPolicyCommonWithContext ¶

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

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

See CreateScalingPolicyCommon 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 (*AUTOSCALING) CreateScalingPolicyRequest ¶

func (c *AUTOSCALING) CreateScalingPolicyRequest(input *CreateScalingPolicyInput) (req *request.Request, output *CreateScalingPolicyOutput)

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

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

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

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

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

func (*AUTOSCALING) CreateScalingPolicyWithContext ¶

func (c *AUTOSCALING) CreateScalingPolicyWithContext(ctx byteplus.Context, input *CreateScalingPolicyInput, opts ...request.Option) (*CreateScalingPolicyOutput, error)

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

See CreateScalingPolicy 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 (*AUTOSCALING) DeleteLifecycleHook ¶

func (c *AUTOSCALING) DeleteLifecycleHook(input *DeleteLifecycleHookInput) (*DeleteLifecycleHookOutput, error)

DeleteLifecycleHook API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DeleteLifecycleHook for usage and error information.

func (*AUTOSCALING) DeleteLifecycleHookCommon ¶

func (c *AUTOSCALING) DeleteLifecycleHookCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteLifecycleHookCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DeleteLifecycleHookCommon for usage and error information.

func (*AUTOSCALING) DeleteLifecycleHookCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) DeleteLifecycleHookCommonWithContext ¶

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

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

See DeleteLifecycleHookCommon 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 (*AUTOSCALING) DeleteLifecycleHookRequest ¶

func (c *AUTOSCALING) DeleteLifecycleHookRequest(input *DeleteLifecycleHookInput) (req *request.Request, output *DeleteLifecycleHookOutput)

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

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

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

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

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

func (*AUTOSCALING) DeleteLifecycleHookWithContext ¶

func (c *AUTOSCALING) DeleteLifecycleHookWithContext(ctx byteplus.Context, input *DeleteLifecycleHookInput, opts ...request.Option) (*DeleteLifecycleHookOutput, error)

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

See DeleteLifecycleHook 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 (*AUTOSCALING) DeleteNotificationConfiguration ¶

func (c *AUTOSCALING) DeleteNotificationConfiguration(input *DeleteNotificationConfigurationInput) (*DeleteNotificationConfigurationOutput, error)

DeleteNotificationConfiguration API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DeleteNotificationConfiguration for usage and error information.

func (*AUTOSCALING) DeleteNotificationConfigurationCommon ¶

func (c *AUTOSCALING) DeleteNotificationConfigurationCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteNotificationConfigurationCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DeleteNotificationConfigurationCommon for usage and error information.

func (*AUTOSCALING) DeleteNotificationConfigurationCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) DeleteNotificationConfigurationCommonWithContext ¶

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

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

See DeleteNotificationConfigurationCommon 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 (*AUTOSCALING) DeleteNotificationConfigurationRequest ¶

func (c *AUTOSCALING) DeleteNotificationConfigurationRequest(input *DeleteNotificationConfigurationInput) (req *request.Request, output *DeleteNotificationConfigurationOutput)

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

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

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

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

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

func (*AUTOSCALING) DeleteNotificationConfigurationWithContext ¶

func (c *AUTOSCALING) DeleteNotificationConfigurationWithContext(ctx byteplus.Context, input *DeleteNotificationConfigurationInput, opts ...request.Option) (*DeleteNotificationConfigurationOutput, error)

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

See DeleteNotificationConfiguration 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 (*AUTOSCALING) DeleteScalingConfiguration ¶

func (c *AUTOSCALING) DeleteScalingConfiguration(input *DeleteScalingConfigurationInput) (*DeleteScalingConfigurationOutput, error)

DeleteScalingConfiguration API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DeleteScalingConfiguration for usage and error information.

func (*AUTOSCALING) DeleteScalingConfigurationCommon ¶

func (c *AUTOSCALING) DeleteScalingConfigurationCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteScalingConfigurationCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DeleteScalingConfigurationCommon for usage and error information.

func (*AUTOSCALING) DeleteScalingConfigurationCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) DeleteScalingConfigurationCommonWithContext ¶

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

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

See DeleteScalingConfigurationCommon 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 (*AUTOSCALING) DeleteScalingConfigurationRequest ¶

func (c *AUTOSCALING) DeleteScalingConfigurationRequest(input *DeleteScalingConfigurationInput) (req *request.Request, output *DeleteScalingConfigurationOutput)

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

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

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

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

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

func (*AUTOSCALING) DeleteScalingConfigurationWithContext ¶

func (c *AUTOSCALING) DeleteScalingConfigurationWithContext(ctx byteplus.Context, input *DeleteScalingConfigurationInput, opts ...request.Option) (*DeleteScalingConfigurationOutput, error)

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

See DeleteScalingConfiguration 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 (*AUTOSCALING) DeleteScalingGroup ¶

func (c *AUTOSCALING) DeleteScalingGroup(input *DeleteScalingGroupInput) (*DeleteScalingGroupOutput, error)

DeleteScalingGroup API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DeleteScalingGroup for usage and error information.

func (*AUTOSCALING) DeleteScalingGroupCommon ¶

func (c *AUTOSCALING) DeleteScalingGroupCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteScalingGroupCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DeleteScalingGroupCommon for usage and error information.

func (*AUTOSCALING) DeleteScalingGroupCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) DeleteScalingGroupCommonWithContext ¶

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

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

See DeleteScalingGroupCommon 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 (*AUTOSCALING) DeleteScalingGroupRequest ¶

func (c *AUTOSCALING) DeleteScalingGroupRequest(input *DeleteScalingGroupInput) (req *request.Request, output *DeleteScalingGroupOutput)

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

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

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

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

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

func (*AUTOSCALING) DeleteScalingGroupWithContext ¶

func (c *AUTOSCALING) DeleteScalingGroupWithContext(ctx byteplus.Context, input *DeleteScalingGroupInput, opts ...request.Option) (*DeleteScalingGroupOutput, error)

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

See DeleteScalingGroup 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 (*AUTOSCALING) DeleteScalingPolicy ¶

func (c *AUTOSCALING) DeleteScalingPolicy(input *DeleteScalingPolicyInput) (*DeleteScalingPolicyOutput, error)

DeleteScalingPolicy API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DeleteScalingPolicy for usage and error information.

func (*AUTOSCALING) DeleteScalingPolicyCommon ¶

func (c *AUTOSCALING) DeleteScalingPolicyCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteScalingPolicyCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DeleteScalingPolicyCommon for usage and error information.

func (*AUTOSCALING) DeleteScalingPolicyCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) DeleteScalingPolicyCommonWithContext ¶

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

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

See DeleteScalingPolicyCommon 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 (*AUTOSCALING) DeleteScalingPolicyRequest ¶

func (c *AUTOSCALING) DeleteScalingPolicyRequest(input *DeleteScalingPolicyInput) (req *request.Request, output *DeleteScalingPolicyOutput)

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

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

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

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

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

func (*AUTOSCALING) DeleteScalingPolicyWithContext ¶

func (c *AUTOSCALING) DeleteScalingPolicyWithContext(ctx byteplus.Context, input *DeleteScalingPolicyInput, opts ...request.Option) (*DeleteScalingPolicyOutput, error)

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

See DeleteScalingPolicy 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 (*AUTOSCALING) DescribeLifecycleActivities ¶

func (c *AUTOSCALING) DescribeLifecycleActivities(input *DescribeLifecycleActivitiesInput) (*DescribeLifecycleActivitiesOutput, error)

DescribeLifecycleActivities API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DescribeLifecycleActivities for usage and error information.

func (*AUTOSCALING) DescribeLifecycleActivitiesCommon ¶

func (c *AUTOSCALING) DescribeLifecycleActivitiesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeLifecycleActivitiesCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DescribeLifecycleActivitiesCommon for usage and error information.

func (*AUTOSCALING) DescribeLifecycleActivitiesCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) DescribeLifecycleActivitiesCommonWithContext ¶

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

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

See DescribeLifecycleActivitiesCommon 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 (*AUTOSCALING) DescribeLifecycleActivitiesRequest ¶

func (c *AUTOSCALING) DescribeLifecycleActivitiesRequest(input *DescribeLifecycleActivitiesInput) (req *request.Request, output *DescribeLifecycleActivitiesOutput)

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

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

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

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

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

func (*AUTOSCALING) DescribeLifecycleActivitiesWithContext ¶

func (c *AUTOSCALING) DescribeLifecycleActivitiesWithContext(ctx byteplus.Context, input *DescribeLifecycleActivitiesInput, opts ...request.Option) (*DescribeLifecycleActivitiesOutput, error)

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

See DescribeLifecycleActivities 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 (*AUTOSCALING) DescribeLifecycleHooks ¶

func (c *AUTOSCALING) DescribeLifecycleHooks(input *DescribeLifecycleHooksInput) (*DescribeLifecycleHooksOutput, error)

DescribeLifecycleHooks API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DescribeLifecycleHooks for usage and error information.

func (*AUTOSCALING) DescribeLifecycleHooksCommon ¶

func (c *AUTOSCALING) DescribeLifecycleHooksCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeLifecycleHooksCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DescribeLifecycleHooksCommon for usage and error information.

func (*AUTOSCALING) DescribeLifecycleHooksCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) DescribeLifecycleHooksCommonWithContext ¶

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

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

See DescribeLifecycleHooksCommon 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 (*AUTOSCALING) DescribeLifecycleHooksRequest ¶

func (c *AUTOSCALING) DescribeLifecycleHooksRequest(input *DescribeLifecycleHooksInput) (req *request.Request, output *DescribeLifecycleHooksOutput)

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

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

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

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

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

func (*AUTOSCALING) DescribeLifecycleHooksWithContext ¶

func (c *AUTOSCALING) DescribeLifecycleHooksWithContext(ctx byteplus.Context, input *DescribeLifecycleHooksInput, opts ...request.Option) (*DescribeLifecycleHooksOutput, error)

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

See DescribeLifecycleHooks 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 (*AUTOSCALING) DescribeNotificationConfigurations ¶

func (c *AUTOSCALING) DescribeNotificationConfigurations(input *DescribeNotificationConfigurationsInput) (*DescribeNotificationConfigurationsOutput, error)

DescribeNotificationConfigurations API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DescribeNotificationConfigurations for usage and error information.

func (*AUTOSCALING) DescribeNotificationConfigurationsCommon ¶

func (c *AUTOSCALING) DescribeNotificationConfigurationsCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeNotificationConfigurationsCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DescribeNotificationConfigurationsCommon for usage and error information.

func (*AUTOSCALING) DescribeNotificationConfigurationsCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) DescribeNotificationConfigurationsCommonWithContext ¶

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

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

See DescribeNotificationConfigurationsCommon 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 (*AUTOSCALING) DescribeNotificationConfigurationsRequest ¶

func (c *AUTOSCALING) DescribeNotificationConfigurationsRequest(input *DescribeNotificationConfigurationsInput) (req *request.Request, output *DescribeNotificationConfigurationsOutput)

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

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

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

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

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

func (*AUTOSCALING) DescribeNotificationConfigurationsWithContext ¶

func (c *AUTOSCALING) DescribeNotificationConfigurationsWithContext(ctx byteplus.Context, input *DescribeNotificationConfigurationsInput, opts ...request.Option) (*DescribeNotificationConfigurationsOutput, error)

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

See DescribeNotificationConfigurations 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 (*AUTOSCALING) DescribeScalingActivities ¶

func (c *AUTOSCALING) DescribeScalingActivities(input *DescribeScalingActivitiesInput) (*DescribeScalingActivitiesOutput, error)

DescribeScalingActivities API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DescribeScalingActivities for usage and error information.

func (*AUTOSCALING) DescribeScalingActivitiesCommon ¶

func (c *AUTOSCALING) DescribeScalingActivitiesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeScalingActivitiesCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DescribeScalingActivitiesCommon for usage and error information.

func (*AUTOSCALING) DescribeScalingActivitiesCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) DescribeScalingActivitiesCommonWithContext ¶

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

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

See DescribeScalingActivitiesCommon 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 (*AUTOSCALING) DescribeScalingActivitiesRequest ¶

func (c *AUTOSCALING) DescribeScalingActivitiesRequest(input *DescribeScalingActivitiesInput) (req *request.Request, output *DescribeScalingActivitiesOutput)

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

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

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

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

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

func (*AUTOSCALING) DescribeScalingActivitiesWithContext ¶

func (c *AUTOSCALING) DescribeScalingActivitiesWithContext(ctx byteplus.Context, input *DescribeScalingActivitiesInput, opts ...request.Option) (*DescribeScalingActivitiesOutput, error)

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

See DescribeScalingActivities 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 (*AUTOSCALING) DescribeScalingConfigurations ¶

func (c *AUTOSCALING) DescribeScalingConfigurations(input *DescribeScalingConfigurationsInput) (*DescribeScalingConfigurationsOutput, error)

DescribeScalingConfigurations API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DescribeScalingConfigurations for usage and error information.

func (*AUTOSCALING) DescribeScalingConfigurationsCommon ¶

func (c *AUTOSCALING) DescribeScalingConfigurationsCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeScalingConfigurationsCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DescribeScalingConfigurationsCommon for usage and error information.

func (*AUTOSCALING) DescribeScalingConfigurationsCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) DescribeScalingConfigurationsCommonWithContext ¶

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

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

See DescribeScalingConfigurationsCommon 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 (*AUTOSCALING) DescribeScalingConfigurationsRequest ¶

func (c *AUTOSCALING) DescribeScalingConfigurationsRequest(input *DescribeScalingConfigurationsInput) (req *request.Request, output *DescribeScalingConfigurationsOutput)

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

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

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

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

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

func (*AUTOSCALING) DescribeScalingConfigurationsWithContext ¶

func (c *AUTOSCALING) DescribeScalingConfigurationsWithContext(ctx byteplus.Context, input *DescribeScalingConfigurationsInput, opts ...request.Option) (*DescribeScalingConfigurationsOutput, error)

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

See DescribeScalingConfigurations 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 (*AUTOSCALING) DescribeScalingGroups ¶

func (c *AUTOSCALING) DescribeScalingGroups(input *DescribeScalingGroupsInput) (*DescribeScalingGroupsOutput, error)

DescribeScalingGroups API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DescribeScalingGroups for usage and error information.

func (*AUTOSCALING) DescribeScalingGroupsCommon ¶

func (c *AUTOSCALING) DescribeScalingGroupsCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeScalingGroupsCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DescribeScalingGroupsCommon for usage and error information.

func (*AUTOSCALING) DescribeScalingGroupsCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) DescribeScalingGroupsCommonWithContext ¶

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

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

See DescribeScalingGroupsCommon 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 (*AUTOSCALING) DescribeScalingGroupsRequest ¶

func (c *AUTOSCALING) DescribeScalingGroupsRequest(input *DescribeScalingGroupsInput) (req *request.Request, output *DescribeScalingGroupsOutput)

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

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

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

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

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

func (*AUTOSCALING) DescribeScalingGroupsWithContext ¶

func (c *AUTOSCALING) DescribeScalingGroupsWithContext(ctx byteplus.Context, input *DescribeScalingGroupsInput, opts ...request.Option) (*DescribeScalingGroupsOutput, error)

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

See DescribeScalingGroups 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 (*AUTOSCALING) DescribeScalingInstances ¶

func (c *AUTOSCALING) DescribeScalingInstances(input *DescribeScalingInstancesInput) (*DescribeScalingInstancesOutput, error)

DescribeScalingInstances API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DescribeScalingInstances for usage and error information.

func (*AUTOSCALING) DescribeScalingInstancesCommon ¶

func (c *AUTOSCALING) DescribeScalingInstancesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeScalingInstancesCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DescribeScalingInstancesCommon for usage and error information.

func (*AUTOSCALING) DescribeScalingInstancesCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) DescribeScalingInstancesCommonWithContext ¶

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

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

See DescribeScalingInstancesCommon 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 (*AUTOSCALING) DescribeScalingInstancesRequest ¶

func (c *AUTOSCALING) DescribeScalingInstancesRequest(input *DescribeScalingInstancesInput) (req *request.Request, output *DescribeScalingInstancesOutput)

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

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

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

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

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

func (*AUTOSCALING) DescribeScalingInstancesWithContext ¶

func (c *AUTOSCALING) DescribeScalingInstancesWithContext(ctx byteplus.Context, input *DescribeScalingInstancesInput, opts ...request.Option) (*DescribeScalingInstancesOutput, error)

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

See DescribeScalingInstances 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 (*AUTOSCALING) DescribeScalingPolicies ¶

func (c *AUTOSCALING) DescribeScalingPolicies(input *DescribeScalingPoliciesInput) (*DescribeScalingPoliciesOutput, error)

DescribeScalingPolicies API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DescribeScalingPolicies for usage and error information.

func (*AUTOSCALING) DescribeScalingPoliciesCommon ¶

func (c *AUTOSCALING) DescribeScalingPoliciesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeScalingPoliciesCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DescribeScalingPoliciesCommon for usage and error information.

func (*AUTOSCALING) DescribeScalingPoliciesCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) DescribeScalingPoliciesCommonWithContext ¶

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

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

See DescribeScalingPoliciesCommon 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 (*AUTOSCALING) DescribeScalingPoliciesRequest ¶

func (c *AUTOSCALING) DescribeScalingPoliciesRequest(input *DescribeScalingPoliciesInput) (req *request.Request, output *DescribeScalingPoliciesOutput)

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

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

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

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

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

func (*AUTOSCALING) DescribeScalingPoliciesWithContext ¶

func (c *AUTOSCALING) DescribeScalingPoliciesWithContext(ctx byteplus.Context, input *DescribeScalingPoliciesInput, opts ...request.Option) (*DescribeScalingPoliciesOutput, error)

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

See DescribeScalingPolicies 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 (*AUTOSCALING) DetachInstances ¶

func (c *AUTOSCALING) DetachInstances(input *DetachInstancesInput) (*DetachInstancesOutput, error)

DetachInstances API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DetachInstances for usage and error information.

func (*AUTOSCALING) DetachInstancesCommon ¶

func (c *AUTOSCALING) DetachInstancesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DetachInstancesCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DetachInstancesCommon for usage and error information.

func (*AUTOSCALING) DetachInstancesCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) DetachInstancesCommonWithContext ¶

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

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

See DetachInstancesCommon 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 (*AUTOSCALING) DetachInstancesRequest ¶

func (c *AUTOSCALING) DetachInstancesRequest(input *DetachInstancesInput) (req *request.Request, output *DetachInstancesOutput)

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

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

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

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

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

func (*AUTOSCALING) DetachInstancesWithContext ¶

func (c *AUTOSCALING) DetachInstancesWithContext(ctx byteplus.Context, input *DetachInstancesInput, opts ...request.Option) (*DetachInstancesOutput, error)

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

See DetachInstances 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 (*AUTOSCALING) DetachServerGroups ¶

func (c *AUTOSCALING) DetachServerGroups(input *DetachServerGroupsInput) (*DetachServerGroupsOutput, error)

DetachServerGroups API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DetachServerGroups for usage and error information.

func (*AUTOSCALING) DetachServerGroupsCommon ¶

func (c *AUTOSCALING) DetachServerGroupsCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DetachServerGroupsCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DetachServerGroupsCommon for usage and error information.

func (*AUTOSCALING) DetachServerGroupsCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) DetachServerGroupsCommonWithContext ¶

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

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

See DetachServerGroupsCommon 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 (*AUTOSCALING) DetachServerGroupsRequest ¶

func (c *AUTOSCALING) DetachServerGroupsRequest(input *DetachServerGroupsInput) (req *request.Request, output *DetachServerGroupsOutput)

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

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

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

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

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

func (*AUTOSCALING) DetachServerGroupsWithContext ¶

func (c *AUTOSCALING) DetachServerGroupsWithContext(ctx byteplus.Context, input *DetachServerGroupsInput, opts ...request.Option) (*DetachServerGroupsOutput, error)

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

See DetachServerGroups 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 (*AUTOSCALING) DisableScalingGroup ¶

func (c *AUTOSCALING) DisableScalingGroup(input *DisableScalingGroupInput) (*DisableScalingGroupOutput, error)

DisableScalingGroup API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DisableScalingGroup for usage and error information.

func (*AUTOSCALING) DisableScalingGroupCommon ¶

func (c *AUTOSCALING) DisableScalingGroupCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DisableScalingGroupCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DisableScalingGroupCommon for usage and error information.

func (*AUTOSCALING) DisableScalingGroupCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) DisableScalingGroupCommonWithContext ¶

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

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

See DisableScalingGroupCommon 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 (*AUTOSCALING) DisableScalingGroupRequest ¶

func (c *AUTOSCALING) DisableScalingGroupRequest(input *DisableScalingGroupInput) (req *request.Request, output *DisableScalingGroupOutput)

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

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

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

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

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

func (*AUTOSCALING) DisableScalingGroupWithContext ¶

func (c *AUTOSCALING) DisableScalingGroupWithContext(ctx byteplus.Context, input *DisableScalingGroupInput, opts ...request.Option) (*DisableScalingGroupOutput, error)

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

See DisableScalingGroup 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 (*AUTOSCALING) DisableScalingPolicy ¶

func (c *AUTOSCALING) DisableScalingPolicy(input *DisableScalingPolicyInput) (*DisableScalingPolicyOutput, error)

DisableScalingPolicy API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DisableScalingPolicy for usage and error information.

func (*AUTOSCALING) DisableScalingPolicyCommon ¶

func (c *AUTOSCALING) DisableScalingPolicyCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DisableScalingPolicyCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation DisableScalingPolicyCommon for usage and error information.

func (*AUTOSCALING) DisableScalingPolicyCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) DisableScalingPolicyCommonWithContext ¶

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

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

See DisableScalingPolicyCommon 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 (*AUTOSCALING) DisableScalingPolicyRequest ¶

func (c *AUTOSCALING) DisableScalingPolicyRequest(input *DisableScalingPolicyInput) (req *request.Request, output *DisableScalingPolicyOutput)

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

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

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

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

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

func (*AUTOSCALING) DisableScalingPolicyWithContext ¶

func (c *AUTOSCALING) DisableScalingPolicyWithContext(ctx byteplus.Context, input *DisableScalingPolicyInput, opts ...request.Option) (*DisableScalingPolicyOutput, error)

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

See DisableScalingPolicy 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 (*AUTOSCALING) EnableScalingConfiguration ¶

func (c *AUTOSCALING) EnableScalingConfiguration(input *EnableScalingConfigurationInput) (*EnableScalingConfigurationOutput, error)

EnableScalingConfiguration API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation EnableScalingConfiguration for usage and error information.

func (*AUTOSCALING) EnableScalingConfigurationCommon ¶

func (c *AUTOSCALING) EnableScalingConfigurationCommon(input *map[string]interface{}) (*map[string]interface{}, error)

EnableScalingConfigurationCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation EnableScalingConfigurationCommon for usage and error information.

func (*AUTOSCALING) EnableScalingConfigurationCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) EnableScalingConfigurationCommonWithContext ¶

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

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

See EnableScalingConfigurationCommon 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 (*AUTOSCALING) EnableScalingConfigurationRequest ¶

func (c *AUTOSCALING) EnableScalingConfigurationRequest(input *EnableScalingConfigurationInput) (req *request.Request, output *EnableScalingConfigurationOutput)

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

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

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

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

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

func (*AUTOSCALING) EnableScalingConfigurationWithContext ¶

func (c *AUTOSCALING) EnableScalingConfigurationWithContext(ctx byteplus.Context, input *EnableScalingConfigurationInput, opts ...request.Option) (*EnableScalingConfigurationOutput, error)

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

See EnableScalingConfiguration 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 (*AUTOSCALING) EnableScalingGroup ¶

func (c *AUTOSCALING) EnableScalingGroup(input *EnableScalingGroupInput) (*EnableScalingGroupOutput, error)

EnableScalingGroup API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation EnableScalingGroup for usage and error information.

func (*AUTOSCALING) EnableScalingGroupCommon ¶

func (c *AUTOSCALING) EnableScalingGroupCommon(input *map[string]interface{}) (*map[string]interface{}, error)

EnableScalingGroupCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation EnableScalingGroupCommon for usage and error information.

func (*AUTOSCALING) EnableScalingGroupCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) EnableScalingGroupCommonWithContext ¶

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

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

See EnableScalingGroupCommon 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 (*AUTOSCALING) EnableScalingGroupRequest ¶

func (c *AUTOSCALING) EnableScalingGroupRequest(input *EnableScalingGroupInput) (req *request.Request, output *EnableScalingGroupOutput)

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

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

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

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

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

func (*AUTOSCALING) EnableScalingGroupWithContext ¶

func (c *AUTOSCALING) EnableScalingGroupWithContext(ctx byteplus.Context, input *EnableScalingGroupInput, opts ...request.Option) (*EnableScalingGroupOutput, error)

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

See EnableScalingGroup 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 (*AUTOSCALING) EnableScalingPolicy ¶

func (c *AUTOSCALING) EnableScalingPolicy(input *EnableScalingPolicyInput) (*EnableScalingPolicyOutput, error)

EnableScalingPolicy API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation EnableScalingPolicy for usage and error information.

func (*AUTOSCALING) EnableScalingPolicyCommon ¶

func (c *AUTOSCALING) EnableScalingPolicyCommon(input *map[string]interface{}) (*map[string]interface{}, error)

EnableScalingPolicyCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation EnableScalingPolicyCommon for usage and error information.

func (*AUTOSCALING) EnableScalingPolicyCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) EnableScalingPolicyCommonWithContext ¶

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

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

See EnableScalingPolicyCommon 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 (*AUTOSCALING) EnableScalingPolicyRequest ¶

func (c *AUTOSCALING) EnableScalingPolicyRequest(input *EnableScalingPolicyInput) (req *request.Request, output *EnableScalingPolicyOutput)

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

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

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

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

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

func (*AUTOSCALING) EnableScalingPolicyWithContext ¶

func (c *AUTOSCALING) EnableScalingPolicyWithContext(ctx byteplus.Context, input *EnableScalingPolicyInput, opts ...request.Option) (*EnableScalingPolicyOutput, error)

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

See EnableScalingPolicy 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 (*AUTOSCALING) EnterStandby ¶

func (c *AUTOSCALING) EnterStandby(input *EnterStandbyInput) (*EnterStandbyOutput, error)

EnterStandby API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation EnterStandby for usage and error information.

func (*AUTOSCALING) EnterStandbyCommon ¶

func (c *AUTOSCALING) EnterStandbyCommon(input *map[string]interface{}) (*map[string]interface{}, error)

EnterStandbyCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation EnterStandbyCommon for usage and error information.

func (*AUTOSCALING) EnterStandbyCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) EnterStandbyCommonWithContext ¶

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

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

See EnterStandbyCommon 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 (*AUTOSCALING) EnterStandbyRequest ¶

func (c *AUTOSCALING) EnterStandbyRequest(input *EnterStandbyInput) (req *request.Request, output *EnterStandbyOutput)

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

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

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

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

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

func (*AUTOSCALING) EnterStandbyWithContext ¶

func (c *AUTOSCALING) EnterStandbyWithContext(ctx byteplus.Context, input *EnterStandbyInput, opts ...request.Option) (*EnterStandbyOutput, error)

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

See EnterStandby 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 (*AUTOSCALING) ExitStandby ¶

func (c *AUTOSCALING) ExitStandby(input *ExitStandbyInput) (*ExitStandbyOutput, error)

ExitStandby API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation ExitStandby for usage and error information.

func (*AUTOSCALING) ExitStandbyCommon ¶

func (c *AUTOSCALING) ExitStandbyCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ExitStandbyCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation ExitStandbyCommon for usage and error information.

func (*AUTOSCALING) ExitStandbyCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) ExitStandbyCommonWithContext ¶

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

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

See ExitStandbyCommon 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 (*AUTOSCALING) ExitStandbyRequest ¶

func (c *AUTOSCALING) ExitStandbyRequest(input *ExitStandbyInput) (req *request.Request, output *ExitStandbyOutput)

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

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

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

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

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

func (*AUTOSCALING) ExitStandbyWithContext ¶

func (c *AUTOSCALING) ExitStandbyWithContext(ctx byteplus.Context, input *ExitStandbyInput, opts ...request.Option) (*ExitStandbyOutput, error)

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

See ExitStandby 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 (*AUTOSCALING) ListTagResources ¶

func (c *AUTOSCALING) ListTagResources(input *ListTagResourcesInput) (*ListTagResourcesOutput, error)

ListTagResources API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation ListTagResources for usage and error information.

func (*AUTOSCALING) ListTagResourcesCommon ¶

func (c *AUTOSCALING) ListTagResourcesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ListTagResourcesCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation ListTagResourcesCommon for usage and error information.

func (*AUTOSCALING) ListTagResourcesCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) ListTagResourcesCommonWithContext ¶

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

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

See ListTagResourcesCommon 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 (*AUTOSCALING) ListTagResourcesRequest ¶

func (c *AUTOSCALING) ListTagResourcesRequest(input *ListTagResourcesInput) (req *request.Request, output *ListTagResourcesOutput)

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

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

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

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

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

func (*AUTOSCALING) ListTagResourcesWithContext ¶

func (c *AUTOSCALING) ListTagResourcesWithContext(ctx byteplus.Context, input *ListTagResourcesInput, opts ...request.Option) (*ListTagResourcesOutput, error)

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

See ListTagResources 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 (*AUTOSCALING) ModifyLifecycleHook ¶

func (c *AUTOSCALING) ModifyLifecycleHook(input *ModifyLifecycleHookInput) (*ModifyLifecycleHookOutput, error)

ModifyLifecycleHook API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation ModifyLifecycleHook for usage and error information.

func (*AUTOSCALING) ModifyLifecycleHookCommon ¶

func (c *AUTOSCALING) ModifyLifecycleHookCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyLifecycleHookCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation ModifyLifecycleHookCommon for usage and error information.

func (*AUTOSCALING) ModifyLifecycleHookCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) ModifyLifecycleHookCommonWithContext ¶

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

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

See ModifyLifecycleHookCommon 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 (*AUTOSCALING) ModifyLifecycleHookRequest ¶

func (c *AUTOSCALING) ModifyLifecycleHookRequest(input *ModifyLifecycleHookInput) (req *request.Request, output *ModifyLifecycleHookOutput)

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

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

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

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

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

func (*AUTOSCALING) ModifyLifecycleHookWithContext ¶

func (c *AUTOSCALING) ModifyLifecycleHookWithContext(ctx byteplus.Context, input *ModifyLifecycleHookInput, opts ...request.Option) (*ModifyLifecycleHookOutput, error)

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

See ModifyLifecycleHook 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 (*AUTOSCALING) ModifyNotificationConfiguration ¶

func (c *AUTOSCALING) ModifyNotificationConfiguration(input *ModifyNotificationConfigurationInput) (*ModifyNotificationConfigurationOutput, error)

ModifyNotificationConfiguration API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation ModifyNotificationConfiguration for usage and error information.

func (*AUTOSCALING) ModifyNotificationConfigurationCommon ¶

func (c *AUTOSCALING) ModifyNotificationConfigurationCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyNotificationConfigurationCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation ModifyNotificationConfigurationCommon for usage and error information.

func (*AUTOSCALING) ModifyNotificationConfigurationCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) ModifyNotificationConfigurationCommonWithContext ¶

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

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

See ModifyNotificationConfigurationCommon 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 (*AUTOSCALING) ModifyNotificationConfigurationRequest ¶

func (c *AUTOSCALING) ModifyNotificationConfigurationRequest(input *ModifyNotificationConfigurationInput) (req *request.Request, output *ModifyNotificationConfigurationOutput)

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

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

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

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

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

func (*AUTOSCALING) ModifyNotificationConfigurationWithContext ¶

func (c *AUTOSCALING) ModifyNotificationConfigurationWithContext(ctx byteplus.Context, input *ModifyNotificationConfigurationInput, opts ...request.Option) (*ModifyNotificationConfigurationOutput, error)

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

See ModifyNotificationConfiguration 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 (*AUTOSCALING) ModifyScalingConfiguration ¶

func (c *AUTOSCALING) ModifyScalingConfiguration(input *ModifyScalingConfigurationInput) (*ModifyScalingConfigurationOutput, error)

ModifyScalingConfiguration API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation ModifyScalingConfiguration for usage and error information.

func (*AUTOSCALING) ModifyScalingConfigurationCommon ¶

func (c *AUTOSCALING) ModifyScalingConfigurationCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyScalingConfigurationCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation ModifyScalingConfigurationCommon for usage and error information.

func (*AUTOSCALING) ModifyScalingConfigurationCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) ModifyScalingConfigurationCommonWithContext ¶

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

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

See ModifyScalingConfigurationCommon 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 (*AUTOSCALING) ModifyScalingConfigurationRequest ¶

func (c *AUTOSCALING) ModifyScalingConfigurationRequest(input *ModifyScalingConfigurationInput) (req *request.Request, output *ModifyScalingConfigurationOutput)

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

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

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

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

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

func (*AUTOSCALING) ModifyScalingConfigurationWithContext ¶

func (c *AUTOSCALING) ModifyScalingConfigurationWithContext(ctx byteplus.Context, input *ModifyScalingConfigurationInput, opts ...request.Option) (*ModifyScalingConfigurationOutput, error)

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

See ModifyScalingConfiguration 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 (*AUTOSCALING) ModifyScalingGroup ¶

func (c *AUTOSCALING) ModifyScalingGroup(input *ModifyScalingGroupInput) (*ModifyScalingGroupOutput, error)

ModifyScalingGroup API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation ModifyScalingGroup for usage and error information.

func (*AUTOSCALING) ModifyScalingGroupCommon ¶

func (c *AUTOSCALING) ModifyScalingGroupCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyScalingGroupCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation ModifyScalingGroupCommon for usage and error information.

func (*AUTOSCALING) ModifyScalingGroupCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) ModifyScalingGroupCommonWithContext ¶

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

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

See ModifyScalingGroupCommon 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 (*AUTOSCALING) ModifyScalingGroupRequest ¶

func (c *AUTOSCALING) ModifyScalingGroupRequest(input *ModifyScalingGroupInput) (req *request.Request, output *ModifyScalingGroupOutput)

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

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

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

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

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

func (*AUTOSCALING) ModifyScalingGroupWithContext ¶

func (c *AUTOSCALING) ModifyScalingGroupWithContext(ctx byteplus.Context, input *ModifyScalingGroupInput, opts ...request.Option) (*ModifyScalingGroupOutput, error)

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

See ModifyScalingGroup 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 (*AUTOSCALING) ModifyScalingPolicy ¶

func (c *AUTOSCALING) ModifyScalingPolicy(input *ModifyScalingPolicyInput) (*ModifyScalingPolicyOutput, error)

ModifyScalingPolicy API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation ModifyScalingPolicy for usage and error information.

func (*AUTOSCALING) ModifyScalingPolicyCommon ¶

func (c *AUTOSCALING) ModifyScalingPolicyCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyScalingPolicyCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation ModifyScalingPolicyCommon for usage and error information.

func (*AUTOSCALING) ModifyScalingPolicyCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) ModifyScalingPolicyCommonWithContext ¶

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

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

See ModifyScalingPolicyCommon 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 (*AUTOSCALING) ModifyScalingPolicyRequest ¶

func (c *AUTOSCALING) ModifyScalingPolicyRequest(input *ModifyScalingPolicyInput) (req *request.Request, output *ModifyScalingPolicyOutput)

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

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

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

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

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

func (*AUTOSCALING) ModifyScalingPolicyWithContext ¶

func (c *AUTOSCALING) ModifyScalingPolicyWithContext(ctx byteplus.Context, input *ModifyScalingPolicyInput, opts ...request.Option) (*ModifyScalingPolicyOutput, error)

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

See ModifyScalingPolicy 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 (*AUTOSCALING) RemoveInstances ¶

func (c *AUTOSCALING) RemoveInstances(input *RemoveInstancesInput) (*RemoveInstancesOutput, error)

RemoveInstances API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation RemoveInstances for usage and error information.

func (*AUTOSCALING) RemoveInstancesCommon ¶

func (c *AUTOSCALING) RemoveInstancesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

RemoveInstancesCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation RemoveInstancesCommon for usage and error information.

func (*AUTOSCALING) RemoveInstancesCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) RemoveInstancesCommonWithContext ¶

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

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

See RemoveInstancesCommon 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 (*AUTOSCALING) RemoveInstancesRequest ¶

func (c *AUTOSCALING) RemoveInstancesRequest(input *RemoveInstancesInput) (req *request.Request, output *RemoveInstancesOutput)

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

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

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

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

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

func (*AUTOSCALING) RemoveInstancesWithContext ¶

func (c *AUTOSCALING) RemoveInstancesWithContext(ctx byteplus.Context, input *RemoveInstancesInput, opts ...request.Option) (*RemoveInstancesOutput, error)

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

See RemoveInstances 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 (*AUTOSCALING) ResumeProcesses ¶

func (c *AUTOSCALING) ResumeProcesses(input *ResumeProcessesInput) (*ResumeProcessesOutput, error)

ResumeProcesses API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation ResumeProcesses for usage and error information.

func (*AUTOSCALING) ResumeProcessesCommon ¶

func (c *AUTOSCALING) ResumeProcessesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ResumeProcessesCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation ResumeProcessesCommon for usage and error information.

func (*AUTOSCALING) ResumeProcessesCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) ResumeProcessesCommonWithContext ¶

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

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

See ResumeProcessesCommon 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 (*AUTOSCALING) ResumeProcessesRequest ¶

func (c *AUTOSCALING) ResumeProcessesRequest(input *ResumeProcessesInput) (req *request.Request, output *ResumeProcessesOutput)

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

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

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

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

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

func (*AUTOSCALING) ResumeProcessesWithContext ¶

func (c *AUTOSCALING) ResumeProcessesWithContext(ctx byteplus.Context, input *ResumeProcessesInput, opts ...request.Option) (*ResumeProcessesOutput, error)

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

See ResumeProcesses 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 (*AUTOSCALING) SetInstancesProtection ¶

func (c *AUTOSCALING) SetInstancesProtection(input *SetInstancesProtectionInput) (*SetInstancesProtectionOutput, error)

SetInstancesProtection API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation SetInstancesProtection for usage and error information.

func (*AUTOSCALING) SetInstancesProtectionCommon ¶

func (c *AUTOSCALING) SetInstancesProtectionCommon(input *map[string]interface{}) (*map[string]interface{}, error)

SetInstancesProtectionCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation SetInstancesProtectionCommon for usage and error information.

func (*AUTOSCALING) SetInstancesProtectionCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) SetInstancesProtectionCommonWithContext ¶

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

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

See SetInstancesProtectionCommon 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 (*AUTOSCALING) SetInstancesProtectionRequest ¶

func (c *AUTOSCALING) SetInstancesProtectionRequest(input *SetInstancesProtectionInput) (req *request.Request, output *SetInstancesProtectionOutput)

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

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

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

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

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

func (*AUTOSCALING) SetInstancesProtectionWithContext ¶

func (c *AUTOSCALING) SetInstancesProtectionWithContext(ctx byteplus.Context, input *SetInstancesProtectionInput, opts ...request.Option) (*SetInstancesProtectionOutput, error)

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

See SetInstancesProtection 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 (*AUTOSCALING) SuspendProcesses ¶

func (c *AUTOSCALING) SuspendProcesses(input *SuspendProcessesInput) (*SuspendProcessesOutput, error)

SuspendProcesses API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation SuspendProcesses for usage and error information.

func (*AUTOSCALING) SuspendProcessesCommon ¶

func (c *AUTOSCALING) SuspendProcessesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

SuspendProcessesCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation SuspendProcessesCommon for usage and error information.

func (*AUTOSCALING) SuspendProcessesCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) SuspendProcessesCommonWithContext ¶

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

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

See SuspendProcessesCommon 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 (*AUTOSCALING) SuspendProcessesRequest ¶

func (c *AUTOSCALING) SuspendProcessesRequest(input *SuspendProcessesInput) (req *request.Request, output *SuspendProcessesOutput)

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

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

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

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

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

func (*AUTOSCALING) SuspendProcessesWithContext ¶

func (c *AUTOSCALING) SuspendProcessesWithContext(ctx byteplus.Context, input *SuspendProcessesInput, opts ...request.Option) (*SuspendProcessesOutput, error)

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

See SuspendProcesses 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 (*AUTOSCALING) TagResources ¶

func (c *AUTOSCALING) TagResources(input *TagResourcesInput) (*TagResourcesOutput, error)

TagResources API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation TagResources for usage and error information.

func (*AUTOSCALING) TagResourcesCommon ¶

func (c *AUTOSCALING) TagResourcesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

TagResourcesCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation TagResourcesCommon for usage and error information.

func (*AUTOSCALING) TagResourcesCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) TagResourcesCommonWithContext ¶

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

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

See TagResourcesCommon 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 (*AUTOSCALING) TagResourcesRequest ¶

func (c *AUTOSCALING) TagResourcesRequest(input *TagResourcesInput) (req *request.Request, output *TagResourcesOutput)

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

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

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

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

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

func (*AUTOSCALING) TagResourcesWithContext ¶

func (c *AUTOSCALING) TagResourcesWithContext(ctx byteplus.Context, input *TagResourcesInput, opts ...request.Option) (*TagResourcesOutput, error)

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

See TagResources 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 (*AUTOSCALING) UntagResources ¶

func (c *AUTOSCALING) UntagResources(input *UntagResourcesInput) (*UntagResourcesOutput, error)

UntagResources API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation UntagResources for usage and error information.

func (*AUTOSCALING) UntagResourcesCommon ¶

func (c *AUTOSCALING) UntagResourcesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

UntagResourcesCommon API operation for AUTO_SCALING.

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 AUTO_SCALING's API operation UntagResourcesCommon for usage and error information.

func (*AUTOSCALING) UntagResourcesCommonRequest ¶

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

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

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

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

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

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

func (*AUTOSCALING) UntagResourcesCommonWithContext ¶

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

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

See UntagResourcesCommon 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 (*AUTOSCALING) UntagResourcesRequest ¶

func (c *AUTOSCALING) UntagResourcesRequest(input *UntagResourcesInput) (req *request.Request, output *UntagResourcesOutput)

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

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

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

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

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

func (*AUTOSCALING) UntagResourcesWithContext ¶

func (c *AUTOSCALING) UntagResourcesWithContext(ctx byteplus.Context, input *UntagResourcesInput, opts ...request.Option) (*UntagResourcesOutput, error)

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

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