apig

func (AIProviderForCreateUpstreamInput) GoString ¶

func (s AIProviderForCreateUpstreamInput) GoString() string

GoString returns the string representation

func (*AIProviderForCreateUpstreamInput) SetBaseUrl ¶

func (s *AIProviderForCreateUpstreamInput) SetBaseUrl(v string) *AIProviderForCreateUpstreamInput

SetBaseUrl sets the BaseUrl field's value.

func (*AIProviderForCreateUpstreamInput) SetCustomBodyParams ¶

func (s *AIProviderForCreateUpstreamInput) SetCustomBodyParams(v *CustomBodyParamsForCreateUpstreamInput) *AIProviderForCreateUpstreamInput

SetCustomBodyParams sets the CustomBodyParams field's value.

func (*AIProviderForCreateUpstreamInput) SetCustomHeaderParams ¶

func (s *AIProviderForCreateUpstreamInput) SetCustomHeaderParams(v *CustomHeaderParamsForCreateUpstreamInput) *AIProviderForCreateUpstreamInput

SetCustomHeaderParams sets the CustomHeaderParams field's value.

func (*AIProviderForCreateUpstreamInput) SetCustomModelService ¶

func (s *AIProviderForCreateUpstreamInput) SetCustomModelService(v *CustomModelServiceForCreateUpstreamInput) *AIProviderForCreateUpstreamInput

SetCustomModelService sets the CustomModelService field's value.

func (*AIProviderForCreateUpstreamInput) SetName ¶

func (s *AIProviderForCreateUpstreamInput) SetName(v string) *AIProviderForCreateUpstreamInput

SetName sets the Name field's value.

func (*AIProviderForCreateUpstreamInput) SetToken ¶

func (s *AIProviderForCreateUpstreamInput) SetToken(v string) *AIProviderForCreateUpstreamInput

SetToken sets the Token field's value.

func (AIProviderForCreateUpstreamInput) String ¶

func (s AIProviderForCreateUpstreamInput) String() string

String returns the string representation

func (AIProviderForGetUpstreamOutput) GoString ¶

func (s AIProviderForGetUpstreamOutput) GoString() string

GoString returns the string representation

func (*AIProviderForGetUpstreamOutput) SetBaseUrl ¶

func (s *AIProviderForGetUpstreamOutput) SetBaseUrl(v string) *AIProviderForGetUpstreamOutput

SetBaseUrl sets the BaseUrl field's value.

func (*AIProviderForGetUpstreamOutput) SetCustomBodyParams ¶

func (s *AIProviderForGetUpstreamOutput) SetCustomBodyParams(v *CustomBodyParamsForGetUpstreamOutput) *AIProviderForGetUpstreamOutput

SetCustomBodyParams sets the CustomBodyParams field's value.

func (*AIProviderForGetUpstreamOutput) SetCustomHeaderParams ¶

func (s *AIProviderForGetUpstreamOutput) SetCustomHeaderParams(v *CustomHeaderParamsForGetUpstreamOutput) *AIProviderForGetUpstreamOutput

SetCustomHeaderParams sets the CustomHeaderParams field's value.

func (*AIProviderForGetUpstreamOutput) SetCustomModelService ¶

func (s *AIProviderForGetUpstreamOutput) SetCustomModelService(v *CustomModelServiceForGetUpstreamOutput) *AIProviderForGetUpstreamOutput

SetCustomModelService sets the CustomModelService field's value.

func (*AIProviderForGetUpstreamOutput) SetName ¶

func (s *AIProviderForGetUpstreamOutput) SetName(v string) *AIProviderForGetUpstreamOutput

SetName sets the Name field's value.

func (*AIProviderForGetUpstreamOutput) SetToken ¶

func (s *AIProviderForGetUpstreamOutput) SetToken(v string) *AIProviderForGetUpstreamOutput

SetToken sets the Token field's value.

func (AIProviderForGetUpstreamOutput) String ¶

func (s AIProviderForGetUpstreamOutput) String() string

String returns the string representation

func (AIProviderForListUpstreamsOutput) GoString ¶

func (s AIProviderForListUpstreamsOutput) GoString() string

GoString returns the string representation

func (*AIProviderForListUpstreamsOutput) SetBaseUrl ¶

func (s *AIProviderForListUpstreamsOutput) SetBaseUrl(v string) *AIProviderForListUpstreamsOutput

SetBaseUrl sets the BaseUrl field's value.

func (*AIProviderForListUpstreamsOutput) SetCustomBodyParams ¶

func (s *AIProviderForListUpstreamsOutput) SetCustomBodyParams(v *CustomBodyParamsForListUpstreamsOutput) *AIProviderForListUpstreamsOutput

SetCustomBodyParams sets the CustomBodyParams field's value.

func (*AIProviderForListUpstreamsOutput) SetCustomHeaderParams ¶

func (s *AIProviderForListUpstreamsOutput) SetCustomHeaderParams(v *CustomHeaderParamsForListUpstreamsOutput) *AIProviderForListUpstreamsOutput

SetCustomHeaderParams sets the CustomHeaderParams field's value.

func (*AIProviderForListUpstreamsOutput) SetCustomModelService ¶

func (s *AIProviderForListUpstreamsOutput) SetCustomModelService(v *CustomModelServiceForListUpstreamsOutput) *AIProviderForListUpstreamsOutput

SetCustomModelService sets the CustomModelService field's value.

func (*AIProviderForListUpstreamsOutput) SetName ¶

func (s *AIProviderForListUpstreamsOutput) SetName(v string) *AIProviderForListUpstreamsOutput

SetName sets the Name field's value.

func (*AIProviderForListUpstreamsOutput) SetToken ¶

func (s *AIProviderForListUpstreamsOutput) SetToken(v string) *AIProviderForListUpstreamsOutput

SetToken sets the Token field's value.

func (AIProviderForListUpstreamsOutput) String ¶

func (s AIProviderForListUpstreamsOutput) String() string

String returns the string representation

func (AIProviderForUpdateUpstreamInput) GoString ¶

func (s AIProviderForUpdateUpstreamInput) GoString() string

GoString returns the string representation

func (*AIProviderForUpdateUpstreamInput) SetBaseUrl ¶

func (s *AIProviderForUpdateUpstreamInput) SetBaseUrl(v string) *AIProviderForUpdateUpstreamInput

SetBaseUrl sets the BaseUrl field's value.

func (*AIProviderForUpdateUpstreamInput) SetCustomBodyParams ¶

func (s *AIProviderForUpdateUpstreamInput) SetCustomBodyParams(v *CustomBodyParamsForUpdateUpstreamInput) *AIProviderForUpdateUpstreamInput

SetCustomBodyParams sets the CustomBodyParams field's value.

func (*AIProviderForUpdateUpstreamInput) SetCustomHeaderParams ¶

func (s *AIProviderForUpdateUpstreamInput) SetCustomHeaderParams(v *CustomHeaderParamsForUpdateUpstreamInput) *AIProviderForUpdateUpstreamInput

SetCustomHeaderParams sets the CustomHeaderParams field's value.

func (*AIProviderForUpdateUpstreamInput) SetCustomModelService ¶

func (s *AIProviderForUpdateUpstreamInput) SetCustomModelService(v *CustomModelServiceForUpdateUpstreamInput) *AIProviderForUpdateUpstreamInput

SetCustomModelService sets the CustomModelService field's value.

func (*AIProviderForUpdateUpstreamInput) SetName ¶

func (s *AIProviderForUpdateUpstreamInput) SetName(v string) *AIProviderForUpdateUpstreamInput

SetName sets the Name field's value.

func (*AIProviderForUpdateUpstreamInput) SetToken ¶

func (s *AIProviderForUpdateUpstreamInput) SetToken(v string) *AIProviderForUpdateUpstreamInput

SetToken sets the Token field's value.

func (AIProviderForUpdateUpstreamInput) String ¶

func (s AIProviderForUpdateUpstreamInput) String() string

String returns the string representation

func (*APIG) CreateConsumer ¶

func (c *APIG) CreateConsumer(input *CreateConsumerInput) (*CreateConsumerOutput, error)

CreateConsumer API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation CreateConsumer for usage and error information.

func (*APIG) CreateConsumerCommon ¶

func (c *APIG) CreateConsumerCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateConsumerCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation CreateConsumerCommon for usage and error information.

func (*APIG) CreateConsumerCommonRequest ¶

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

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

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

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

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

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

func (*APIG) CreateConsumerCommonWithContext ¶

func (c *APIG) CreateConsumerCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateConsumerCommon 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 (*APIG) CreateConsumerCredential ¶

func (c *APIG) CreateConsumerCredential(input *CreateConsumerCredentialInput) (*CreateConsumerCredentialOutput, error)

CreateConsumerCredential API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation CreateConsumerCredential for usage and error information.

func (*APIG) CreateConsumerCredentialCommon ¶

func (c *APIG) CreateConsumerCredentialCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateConsumerCredentialCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation CreateConsumerCredentialCommon for usage and error information.

func (*APIG) CreateConsumerCredentialCommonRequest ¶

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

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

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

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

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

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

func (*APIG) CreateConsumerCredentialCommonWithContext ¶

func (c *APIG) CreateConsumerCredentialCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateConsumerCredentialCommon 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 (*APIG) CreateConsumerCredentialRequest ¶

func (c *APIG) CreateConsumerCredentialRequest(input *CreateConsumerCredentialInput) (req *request.Request, output *CreateConsumerCredentialOutput)

CreateConsumerCredentialRequest generates a "volcengine/request.Request" representing the client's request for the CreateConsumerCredential operation. The "output" return value will be populated with the CreateConsumerCredentialCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) CreateConsumerCredentialWithContext ¶

func (c *APIG) CreateConsumerCredentialWithContext(ctx volcengine.Context, input *CreateConsumerCredentialInput, opts ...request.Option) (*CreateConsumerCredentialOutput, error)

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

See CreateConsumerCredential 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 (*APIG) CreateConsumerRequest ¶

func (c *APIG) CreateConsumerRequest(input *CreateConsumerInput) (req *request.Request, output *CreateConsumerOutput)

CreateConsumerRequest generates a "volcengine/request.Request" representing the client's request for the CreateConsumer operation. The "output" return value will be populated with the CreateConsumerCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) CreateConsumerWithContext ¶

func (c *APIG) CreateConsumerWithContext(ctx volcengine.Context, input *CreateConsumerInput, opts ...request.Option) (*CreateConsumerOutput, error)

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

See CreateConsumer 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 (*APIG) CreateGateway ¶

func (c *APIG) CreateGateway(input *CreateGatewayInput) (*CreateGatewayOutput, error)

CreateGateway API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation CreateGateway for usage and error information.

func (*APIG) CreateGatewayCommon ¶

func (c *APIG) CreateGatewayCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateGatewayCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation CreateGatewayCommon for usage and error information.

func (*APIG) CreateGatewayCommonRequest ¶

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

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

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

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

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

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

func (*APIG) CreateGatewayCommonWithContext ¶

func (c *APIG) CreateGatewayCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateGatewayCommon 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 (*APIG) CreateGatewayRequest ¶

func (c *APIG) CreateGatewayRequest(input *CreateGatewayInput) (req *request.Request, output *CreateGatewayOutput)

CreateGatewayRequest generates a "volcengine/request.Request" representing the client's request for the CreateGateway operation. The "output" return value will be populated with the CreateGatewayCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) CreateGatewayService ¶

func (c *APIG) CreateGatewayService(input *CreateGatewayServiceInput) (*CreateGatewayServiceOutput, error)

CreateGatewayService API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation CreateGatewayService for usage and error information.

func (*APIG) CreateGatewayServiceCommon ¶

func (c *APIG) CreateGatewayServiceCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateGatewayServiceCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation CreateGatewayServiceCommon for usage and error information.

func (*APIG) CreateGatewayServiceCommonRequest ¶

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

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

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

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

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

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

func (*APIG) CreateGatewayServiceCommonWithContext ¶

func (c *APIG) CreateGatewayServiceCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateGatewayServiceCommon 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 (*APIG) CreateGatewayServiceRequest ¶

func (c *APIG) CreateGatewayServiceRequest(input *CreateGatewayServiceInput) (req *request.Request, output *CreateGatewayServiceOutput)

CreateGatewayServiceRequest generates a "volcengine/request.Request" representing the client's request for the CreateGatewayService operation. The "output" return value will be populated with the CreateGatewayServiceCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) CreateGatewayServiceWithContext ¶

func (c *APIG) CreateGatewayServiceWithContext(ctx volcengine.Context, input *CreateGatewayServiceInput, opts ...request.Option) (*CreateGatewayServiceOutput, error)

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

See CreateGatewayService 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 (*APIG) CreateGatewayWithContext ¶

func (c *APIG) CreateGatewayWithContext(ctx volcengine.Context, input *CreateGatewayInput, opts ...request.Option) (*CreateGatewayOutput, error)

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

See CreateGateway 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 (*APIG) CreatePluginBinding ¶

func (c *APIG) CreatePluginBinding(input *CreatePluginBindingInput) (*CreatePluginBindingOutput, error)

CreatePluginBinding API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation CreatePluginBinding for usage and error information.

func (*APIG) CreatePluginBindingCommon ¶

func (c *APIG) CreatePluginBindingCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreatePluginBindingCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation CreatePluginBindingCommon for usage and error information.

func (*APIG) CreatePluginBindingCommonRequest ¶

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

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

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

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

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

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

func (*APIG) CreatePluginBindingCommonWithContext ¶

func (c *APIG) CreatePluginBindingCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreatePluginBindingCommon 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 (*APIG) CreatePluginBindingRequest ¶

func (c *APIG) CreatePluginBindingRequest(input *CreatePluginBindingInput) (req *request.Request, output *CreatePluginBindingOutput)

CreatePluginBindingRequest generates a "volcengine/request.Request" representing the client's request for the CreatePluginBinding operation. The "output" return value will be populated with the CreatePluginBindingCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) CreatePluginBindingWithContext ¶

func (c *APIG) CreatePluginBindingWithContext(ctx volcengine.Context, input *CreatePluginBindingInput, opts ...request.Option) (*CreatePluginBindingOutput, error)

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

See CreatePluginBinding 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 (*APIG) CreateUpstream ¶

func (c *APIG) CreateUpstream(input *CreateUpstreamInput) (*CreateUpstreamOutput, error)

CreateUpstream API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation CreateUpstream for usage and error information.

func (*APIG) CreateUpstreamCommon ¶

func (c *APIG) CreateUpstreamCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateUpstreamCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation CreateUpstreamCommon for usage and error information.

func (*APIG) CreateUpstreamCommonRequest ¶

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

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

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

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

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

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

func (*APIG) CreateUpstreamCommonWithContext ¶

func (c *APIG) CreateUpstreamCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateUpstreamCommon 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 (*APIG) CreateUpstreamRequest ¶

func (c *APIG) CreateUpstreamRequest(input *CreateUpstreamInput) (req *request.Request, output *CreateUpstreamOutput)

CreateUpstreamRequest generates a "volcengine/request.Request" representing the client's request for the CreateUpstream operation. The "output" return value will be populated with the CreateUpstreamCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) CreateUpstreamSource ¶

func (c *APIG) CreateUpstreamSource(input *CreateUpstreamSourceInput) (*CreateUpstreamSourceOutput, error)

CreateUpstreamSource API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation CreateUpstreamSource for usage and error information.

func (*APIG) CreateUpstreamSourceCommon ¶

func (c *APIG) CreateUpstreamSourceCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateUpstreamSourceCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation CreateUpstreamSourceCommon for usage and error information.

func (*APIG) CreateUpstreamSourceCommonRequest ¶

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

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

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

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

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

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

func (*APIG) CreateUpstreamSourceCommonWithContext ¶

func (c *APIG) CreateUpstreamSourceCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateUpstreamSourceCommon 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 (*APIG) CreateUpstreamSourceRequest ¶

func (c *APIG) CreateUpstreamSourceRequest(input *CreateUpstreamSourceInput) (req *request.Request, output *CreateUpstreamSourceOutput)

CreateUpstreamSourceRequest generates a "volcengine/request.Request" representing the client's request for the CreateUpstreamSource operation. The "output" return value will be populated with the CreateUpstreamSourceCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) CreateUpstreamSourceWithContext ¶

func (c *APIG) CreateUpstreamSourceWithContext(ctx volcengine.Context, input *CreateUpstreamSourceInput, opts ...request.Option) (*CreateUpstreamSourceOutput, error)

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

See CreateUpstreamSource 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 (*APIG) CreateUpstreamWithContext ¶

func (c *APIG) CreateUpstreamWithContext(ctx volcengine.Context, input *CreateUpstreamInput, opts ...request.Option) (*CreateUpstreamOutput, error)

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

See CreateUpstream 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 (*APIG) DeleteConsumer ¶

func (c *APIG) DeleteConsumer(input *DeleteConsumerInput) (*DeleteConsumerOutput, error)

DeleteConsumer API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation DeleteConsumer for usage and error information.

func (*APIG) DeleteConsumerCommon ¶

func (c *APIG) DeleteConsumerCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteConsumerCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation DeleteConsumerCommon for usage and error information.

func (*APIG) DeleteConsumerCommonRequest ¶

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

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

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

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

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

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

func (*APIG) DeleteConsumerCommonWithContext ¶

func (c *APIG) DeleteConsumerCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteConsumerCommon 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 (*APIG) DeleteConsumerCredential ¶

func (c *APIG) DeleteConsumerCredential(input *DeleteConsumerCredentialInput) (*DeleteConsumerCredentialOutput, error)

DeleteConsumerCredential API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation DeleteConsumerCredential for usage and error information.

func (*APIG) DeleteConsumerCredentialCommon ¶

func (c *APIG) DeleteConsumerCredentialCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteConsumerCredentialCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation DeleteConsumerCredentialCommon for usage and error information.

func (*APIG) DeleteConsumerCredentialCommonRequest ¶

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

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

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

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

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

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

func (*APIG) DeleteConsumerCredentialCommonWithContext ¶

func (c *APIG) DeleteConsumerCredentialCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteConsumerCredentialCommon 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 (*APIG) DeleteConsumerCredentialRequest ¶

func (c *APIG) DeleteConsumerCredentialRequest(input *DeleteConsumerCredentialInput) (req *request.Request, output *DeleteConsumerCredentialOutput)

DeleteConsumerCredentialRequest generates a "volcengine/request.Request" representing the client's request for the DeleteConsumerCredential operation. The "output" return value will be populated with the DeleteConsumerCredentialCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) DeleteConsumerCredentialWithContext ¶

func (c *APIG) DeleteConsumerCredentialWithContext(ctx volcengine.Context, input *DeleteConsumerCredentialInput, opts ...request.Option) (*DeleteConsumerCredentialOutput, error)

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

See DeleteConsumerCredential 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 (*APIG) DeleteConsumerRequest ¶

func (c *APIG) DeleteConsumerRequest(input *DeleteConsumerInput) (req *request.Request, output *DeleteConsumerOutput)

DeleteConsumerRequest generates a "volcengine/request.Request" representing the client's request for the DeleteConsumer operation. The "output" return value will be populated with the DeleteConsumerCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) DeleteConsumerWithContext ¶

func (c *APIG) DeleteConsumerWithContext(ctx volcengine.Context, input *DeleteConsumerInput, opts ...request.Option) (*DeleteConsumerOutput, error)

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

See DeleteConsumer 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 (*APIG) DeleteGateway ¶

func (c *APIG) DeleteGateway(input *DeleteGatewayInput) (*DeleteGatewayOutput, error)

DeleteGateway API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation DeleteGateway for usage and error information.

func (*APIG) DeleteGatewayCommon ¶

func (c *APIG) DeleteGatewayCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteGatewayCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation DeleteGatewayCommon for usage and error information.

func (*APIG) DeleteGatewayCommonRequest ¶

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

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

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

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

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

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

func (*APIG) DeleteGatewayCommonWithContext ¶

func (c *APIG) DeleteGatewayCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteGatewayCommon 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 (*APIG) DeleteGatewayRequest ¶

func (c *APIG) DeleteGatewayRequest(input *DeleteGatewayInput) (req *request.Request, output *DeleteGatewayOutput)

DeleteGatewayRequest generates a "volcengine/request.Request" representing the client's request for the DeleteGateway operation. The "output" return value will be populated with the DeleteGatewayCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) DeleteGatewayService ¶

func (c *APIG) DeleteGatewayService(input *DeleteGatewayServiceInput) (*DeleteGatewayServiceOutput, error)

DeleteGatewayService API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation DeleteGatewayService for usage and error information.

func (*APIG) DeleteGatewayServiceCommon ¶

func (c *APIG) DeleteGatewayServiceCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteGatewayServiceCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation DeleteGatewayServiceCommon for usage and error information.

func (*APIG) DeleteGatewayServiceCommonRequest ¶

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

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

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

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

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

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

func (*APIG) DeleteGatewayServiceCommonWithContext ¶

func (c *APIG) DeleteGatewayServiceCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteGatewayServiceCommon 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 (*APIG) DeleteGatewayServiceRequest ¶

func (c *APIG) DeleteGatewayServiceRequest(input *DeleteGatewayServiceInput) (req *request.Request, output *DeleteGatewayServiceOutput)

DeleteGatewayServiceRequest generates a "volcengine/request.Request" representing the client's request for the DeleteGatewayService operation. The "output" return value will be populated with the DeleteGatewayServiceCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) DeleteGatewayServiceWithContext ¶

func (c *APIG) DeleteGatewayServiceWithContext(ctx volcengine.Context, input *DeleteGatewayServiceInput, opts ...request.Option) (*DeleteGatewayServiceOutput, error)

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

See DeleteGatewayService 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 (*APIG) DeleteGatewayWithContext ¶

func (c *APIG) DeleteGatewayWithContext(ctx volcengine.Context, input *DeleteGatewayInput, opts ...request.Option) (*DeleteGatewayOutput, error)

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

See DeleteGateway 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 (*APIG) DeletePluginBinding ¶

func (c *APIG) DeletePluginBinding(input *DeletePluginBindingInput) (*DeletePluginBindingOutput, error)

DeletePluginBinding API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation DeletePluginBinding for usage and error information.

func (*APIG) DeletePluginBindingCommon ¶

func (c *APIG) DeletePluginBindingCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeletePluginBindingCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation DeletePluginBindingCommon for usage and error information.

func (*APIG) DeletePluginBindingCommonRequest ¶

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

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

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

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

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

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

func (*APIG) DeletePluginBindingCommonWithContext ¶

func (c *APIG) DeletePluginBindingCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeletePluginBindingCommon 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 (*APIG) DeletePluginBindingRequest ¶

func (c *APIG) DeletePluginBindingRequest(input *DeletePluginBindingInput) (req *request.Request, output *DeletePluginBindingOutput)

DeletePluginBindingRequest generates a "volcengine/request.Request" representing the client's request for the DeletePluginBinding operation. The "output" return value will be populated with the DeletePluginBindingCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) DeletePluginBindingWithContext ¶

func (c *APIG) DeletePluginBindingWithContext(ctx volcengine.Context, input *DeletePluginBindingInput, opts ...request.Option) (*DeletePluginBindingOutput, error)

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

See DeletePluginBinding 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 (*APIG) DeleteUpstream ¶

func (c *APIG) DeleteUpstream(input *DeleteUpstreamInput) (*DeleteUpstreamOutput, error)

DeleteUpstream API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation DeleteUpstream for usage and error information.

func (*APIG) DeleteUpstreamCommon ¶

func (c *APIG) DeleteUpstreamCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteUpstreamCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation DeleteUpstreamCommon for usage and error information.

func (*APIG) DeleteUpstreamCommonRequest ¶

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

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

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

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

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

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

func (*APIG) DeleteUpstreamCommonWithContext ¶

func (c *APIG) DeleteUpstreamCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteUpstreamCommon 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 (*APIG) DeleteUpstreamRequest ¶

func (c *APIG) DeleteUpstreamRequest(input *DeleteUpstreamInput) (req *request.Request, output *DeleteUpstreamOutput)

DeleteUpstreamRequest generates a "volcengine/request.Request" representing the client's request for the DeleteUpstream operation. The "output" return value will be populated with the DeleteUpstreamCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) DeleteUpstreamSource ¶

func (c *APIG) DeleteUpstreamSource(input *DeleteUpstreamSourceInput) (*DeleteUpstreamSourceOutput, error)

DeleteUpstreamSource API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation DeleteUpstreamSource for usage and error information.

func (*APIG) DeleteUpstreamSourceCommon ¶

func (c *APIG) DeleteUpstreamSourceCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteUpstreamSourceCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation DeleteUpstreamSourceCommon for usage and error information.

func (*APIG) DeleteUpstreamSourceCommonRequest ¶

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

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

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

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

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

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

func (*APIG) DeleteUpstreamSourceCommonWithContext ¶

func (c *APIG) DeleteUpstreamSourceCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteUpstreamSourceCommon 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 (*APIG) DeleteUpstreamSourceRequest ¶

func (c *APIG) DeleteUpstreamSourceRequest(input *DeleteUpstreamSourceInput) (req *request.Request, output *DeleteUpstreamSourceOutput)

DeleteUpstreamSourceRequest generates a "volcengine/request.Request" representing the client's request for the DeleteUpstreamSource operation. The "output" return value will be populated with the DeleteUpstreamSourceCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) DeleteUpstreamSourceWithContext ¶

func (c *APIG) DeleteUpstreamSourceWithContext(ctx volcengine.Context, input *DeleteUpstreamSourceInput, opts ...request.Option) (*DeleteUpstreamSourceOutput, error)

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

See DeleteUpstreamSource 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 (*APIG) DeleteUpstreamWithContext ¶

func (c *APIG) DeleteUpstreamWithContext(ctx volcengine.Context, input *DeleteUpstreamInput, opts ...request.Option) (*DeleteUpstreamOutput, error)

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

See DeleteUpstream 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 (*APIG) GetConsumer ¶

func (c *APIG) GetConsumer(input *GetConsumerInput) (*GetConsumerOutput, error)

GetConsumer API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation GetConsumer for usage and error information.

func (*APIG) GetConsumerCommon ¶

func (c *APIG) GetConsumerCommon(input *map[string]interface{}) (*map[string]interface{}, error)

GetConsumerCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation GetConsumerCommon for usage and error information.

func (*APIG) GetConsumerCommonRequest ¶

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

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

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

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

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

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

func (*APIG) GetConsumerCommonWithContext ¶

func (c *APIG) GetConsumerCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See GetConsumerCommon 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 (*APIG) GetConsumerRequest ¶

func (c *APIG) GetConsumerRequest(input *GetConsumerInput) (req *request.Request, output *GetConsumerOutput)

GetConsumerRequest generates a "volcengine/request.Request" representing the client's request for the GetConsumer operation. The "output" return value will be populated with the GetConsumerCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) GetConsumerWithContext ¶

func (c *APIG) GetConsumerWithContext(ctx volcengine.Context, input *GetConsumerInput, opts ...request.Option) (*GetConsumerOutput, error)

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

See GetConsumer 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 (*APIG) GetGateway ¶

func (c *APIG) GetGateway(input *GetGatewayInput) (*GetGatewayOutput, error)

GetGateway API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation GetGateway for usage and error information.

func (*APIG) GetGatewayCommon ¶

func (c *APIG) GetGatewayCommon(input *map[string]interface{}) (*map[string]interface{}, error)

GetGatewayCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation GetGatewayCommon for usage and error information.

func (*APIG) GetGatewayCommonRequest ¶

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

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

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

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

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

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

func (*APIG) GetGatewayCommonWithContext ¶

func (c *APIG) GetGatewayCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See GetGatewayCommon 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 (*APIG) GetGatewayRequest ¶

func (c *APIG) GetGatewayRequest(input *GetGatewayInput) (req *request.Request, output *GetGatewayOutput)

GetGatewayRequest generates a "volcengine/request.Request" representing the client's request for the GetGateway operation. The "output" return value will be populated with the GetGatewayCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) GetGatewayService ¶

func (c *APIG) GetGatewayService(input *GetGatewayServiceInput) (*GetGatewayServiceOutput, error)

GetGatewayService API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation GetGatewayService for usage and error information.

func (*APIG) GetGatewayServiceCommon ¶

func (c *APIG) GetGatewayServiceCommon(input *map[string]interface{}) (*map[string]interface{}, error)

GetGatewayServiceCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation GetGatewayServiceCommon for usage and error information.

func (*APIG) GetGatewayServiceCommonRequest ¶

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

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

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

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

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

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

func (*APIG) GetGatewayServiceCommonWithContext ¶

func (c *APIG) GetGatewayServiceCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See GetGatewayServiceCommon 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 (*APIG) GetGatewayServiceRequest ¶

func (c *APIG) GetGatewayServiceRequest(input *GetGatewayServiceInput) (req *request.Request, output *GetGatewayServiceOutput)

GetGatewayServiceRequest generates a "volcengine/request.Request" representing the client's request for the GetGatewayService operation. The "output" return value will be populated with the GetGatewayServiceCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) GetGatewayServiceWithContext ¶

func (c *APIG) GetGatewayServiceWithContext(ctx volcengine.Context, input *GetGatewayServiceInput, opts ...request.Option) (*GetGatewayServiceOutput, error)

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

See GetGatewayService 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 (*APIG) GetGatewayWithContext ¶

func (c *APIG) GetGatewayWithContext(ctx volcengine.Context, input *GetGatewayInput, opts ...request.Option) (*GetGatewayOutput, error)

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

See GetGateway 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 (*APIG) GetPluginBinding ¶

func (c *APIG) GetPluginBinding(input *GetPluginBindingInput) (*GetPluginBindingOutput, error)

GetPluginBinding API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation GetPluginBinding for usage and error information.

func (*APIG) GetPluginBindingCommon ¶

func (c *APIG) GetPluginBindingCommon(input *map[string]interface{}) (*map[string]interface{}, error)

GetPluginBindingCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation GetPluginBindingCommon for usage and error information.

func (*APIG) GetPluginBindingCommonRequest ¶

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

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

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

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

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

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

func (*APIG) GetPluginBindingCommonWithContext ¶

func (c *APIG) GetPluginBindingCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See GetPluginBindingCommon 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 (*APIG) GetPluginBindingRequest ¶

func (c *APIG) GetPluginBindingRequest(input *GetPluginBindingInput) (req *request.Request, output *GetPluginBindingOutput)

GetPluginBindingRequest generates a "volcengine/request.Request" representing the client's request for the GetPluginBinding operation. The "output" return value will be populated with the GetPluginBindingCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) GetPluginBindingWithContext ¶

func (c *APIG) GetPluginBindingWithContext(ctx volcengine.Context, input *GetPluginBindingInput, opts ...request.Option) (*GetPluginBindingOutput, error)

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

See GetPluginBinding 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 (*APIG) GetUpstream ¶

func (c *APIG) GetUpstream(input *GetUpstreamInput) (*GetUpstreamOutput, error)

GetUpstream API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation GetUpstream for usage and error information.

func (*APIG) GetUpstreamCommon ¶

func (c *APIG) GetUpstreamCommon(input *map[string]interface{}) (*map[string]interface{}, error)

GetUpstreamCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation GetUpstreamCommon for usage and error information.

func (*APIG) GetUpstreamCommonRequest ¶

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

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

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

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

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

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

func (*APIG) GetUpstreamCommonWithContext ¶

func (c *APIG) GetUpstreamCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See GetUpstreamCommon 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 (*APIG) GetUpstreamRequest ¶

func (c *APIG) GetUpstreamRequest(input *GetUpstreamInput) (req *request.Request, output *GetUpstreamOutput)

GetUpstreamRequest generates a "volcengine/request.Request" representing the client's request for the GetUpstream operation. The "output" return value will be populated with the GetUpstreamCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) GetUpstreamSource ¶

func (c *APIG) GetUpstreamSource(input *GetUpstreamSourceInput) (*GetUpstreamSourceOutput, error)

GetUpstreamSource API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation GetUpstreamSource for usage and error information.

func (*APIG) GetUpstreamSourceCommon ¶

func (c *APIG) GetUpstreamSourceCommon(input *map[string]interface{}) (*map[string]interface{}, error)

GetUpstreamSourceCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation GetUpstreamSourceCommon for usage and error information.

func (*APIG) GetUpstreamSourceCommonRequest ¶

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

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

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

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

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

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

func (*APIG) GetUpstreamSourceCommonWithContext ¶

func (c *APIG) GetUpstreamSourceCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See GetUpstreamSourceCommon 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 (*APIG) GetUpstreamSourceRequest ¶

func (c *APIG) GetUpstreamSourceRequest(input *GetUpstreamSourceInput) (req *request.Request, output *GetUpstreamSourceOutput)

GetUpstreamSourceRequest generates a "volcengine/request.Request" representing the client's request for the GetUpstreamSource operation. The "output" return value will be populated with the GetUpstreamSourceCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) GetUpstreamSourceWithContext ¶

func (c *APIG) GetUpstreamSourceWithContext(ctx volcengine.Context, input *GetUpstreamSourceInput, opts ...request.Option) (*GetUpstreamSourceOutput, error)

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

See GetUpstreamSource 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 (*APIG) GetUpstreamWithContext ¶

func (c *APIG) GetUpstreamWithContext(ctx volcengine.Context, input *GetUpstreamInput, opts ...request.Option) (*GetUpstreamOutput, error)

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

See GetUpstream 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 (*APIG) ListConsumerCredentials ¶

func (c *APIG) ListConsumerCredentials(input *ListConsumerCredentialsInput) (*ListConsumerCredentialsOutput, error)

ListConsumerCredentials API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation ListConsumerCredentials for usage and error information.

func (*APIG) ListConsumerCredentialsCommon ¶

func (c *APIG) ListConsumerCredentialsCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ListConsumerCredentialsCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation ListConsumerCredentialsCommon for usage and error information.

func (*APIG) ListConsumerCredentialsCommonRequest ¶

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

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

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

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

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

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

func (*APIG) ListConsumerCredentialsCommonWithContext ¶

func (c *APIG) ListConsumerCredentialsCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See ListConsumerCredentialsCommon 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 (*APIG) ListConsumerCredentialsRequest ¶

func (c *APIG) ListConsumerCredentialsRequest(input *ListConsumerCredentialsInput) (req *request.Request, output *ListConsumerCredentialsOutput)

ListConsumerCredentialsRequest generates a "volcengine/request.Request" representing the client's request for the ListConsumerCredentials operation. The "output" return value will be populated with the ListConsumerCredentialsCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) ListConsumerCredentialsWithContext ¶

func (c *APIG) ListConsumerCredentialsWithContext(ctx volcengine.Context, input *ListConsumerCredentialsInput, opts ...request.Option) (*ListConsumerCredentialsOutput, error)

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

See ListConsumerCredentials 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 (*APIG) ListConsumers ¶

func (c *APIG) ListConsumers(input *ListConsumersInput) (*ListConsumersOutput, error)

ListConsumers API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation ListConsumers for usage and error information.

func (*APIG) ListConsumersCommon ¶

func (c *APIG) ListConsumersCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ListConsumersCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation ListConsumersCommon for usage and error information.

func (*APIG) ListConsumersCommonRequest ¶

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

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

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

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

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

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

func (*APIG) ListConsumersCommonWithContext ¶

func (c *APIG) ListConsumersCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See ListConsumersCommon 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 (*APIG) ListConsumersRequest ¶

func (c *APIG) ListConsumersRequest(input *ListConsumersInput) (req *request.Request, output *ListConsumersOutput)

ListConsumersRequest generates a "volcengine/request.Request" representing the client's request for the ListConsumers operation. The "output" return value will be populated with the ListConsumersCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) ListConsumersWithContext ¶

func (c *APIG) ListConsumersWithContext(ctx volcengine.Context, input *ListConsumersInput, opts ...request.Option) (*ListConsumersOutput, error)

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

See ListConsumers 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 (*APIG) ListGatewayServices ¶

func (c *APIG) ListGatewayServices(input *ListGatewayServicesInput) (*ListGatewayServicesOutput, error)

ListGatewayServices API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation ListGatewayServices for usage and error information.

func (*APIG) ListGatewayServicesCommon ¶

func (c *APIG) ListGatewayServicesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ListGatewayServicesCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation ListGatewayServicesCommon for usage and error information.

func (*APIG) ListGatewayServicesCommonRequest ¶

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

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

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

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

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

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

func (*APIG) ListGatewayServicesCommonWithContext ¶

func (c *APIG) ListGatewayServicesCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See ListGatewayServicesCommon 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 (*APIG) ListGatewayServicesRequest ¶

func (c *APIG) ListGatewayServicesRequest(input *ListGatewayServicesInput) (req *request.Request, output *ListGatewayServicesOutput)

ListGatewayServicesRequest generates a "volcengine/request.Request" representing the client's request for the ListGatewayServices operation. The "output" return value will be populated with the ListGatewayServicesCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) ListGatewayServicesWithContext ¶

func (c *APIG) ListGatewayServicesWithContext(ctx volcengine.Context, input *ListGatewayServicesInput, opts ...request.Option) (*ListGatewayServicesOutput, error)

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

See ListGatewayServices 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 (*APIG) ListGateways ¶

func (c *APIG) ListGateways(input *ListGatewaysInput) (*ListGatewaysOutput, error)

ListGateways API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation ListGateways for usage and error information.

func (*APIG) ListGatewaysCommon ¶

func (c *APIG) ListGatewaysCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ListGatewaysCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation ListGatewaysCommon for usage and error information.

func (*APIG) ListGatewaysCommonRequest ¶

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

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

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

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

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

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

func (*APIG) ListGatewaysCommonWithContext ¶

func (c *APIG) ListGatewaysCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See ListGatewaysCommon 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 (*APIG) ListGatewaysRequest ¶

func (c *APIG) ListGatewaysRequest(input *ListGatewaysInput) (req *request.Request, output *ListGatewaysOutput)

ListGatewaysRequest generates a "volcengine/request.Request" representing the client's request for the ListGateways operation. The "output" return value will be populated with the ListGatewaysCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) ListGatewaysWithContext ¶

func (c *APIG) ListGatewaysWithContext(ctx volcengine.Context, input *ListGatewaysInput, opts ...request.Option) (*ListGatewaysOutput, error)

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

See ListGateways 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 (*APIG) ListPluginBindings ¶

func (c *APIG) ListPluginBindings(input *ListPluginBindingsInput) (*ListPluginBindingsOutput, error)

ListPluginBindings API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation ListPluginBindings for usage and error information.

func (*APIG) ListPluginBindingsCommon ¶

func (c *APIG) ListPluginBindingsCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ListPluginBindingsCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation ListPluginBindingsCommon for usage and error information.

func (*APIG) ListPluginBindingsCommonRequest ¶

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

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

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

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

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

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

func (*APIG) ListPluginBindingsCommonWithContext ¶

func (c *APIG) ListPluginBindingsCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See ListPluginBindingsCommon 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 (*APIG) ListPluginBindingsRequest ¶

func (c *APIG) ListPluginBindingsRequest(input *ListPluginBindingsInput) (req *request.Request, output *ListPluginBindingsOutput)

ListPluginBindingsRequest generates a "volcengine/request.Request" representing the client's request for the ListPluginBindings operation. The "output" return value will be populated with the ListPluginBindingsCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) ListPluginBindingsWithContext ¶

func (c *APIG) ListPluginBindingsWithContext(ctx volcengine.Context, input *ListPluginBindingsInput, opts ...request.Option) (*ListPluginBindingsOutput, error)

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

See ListPluginBindings 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 (*APIG) ListUpstreamSources ¶

func (c *APIG) ListUpstreamSources(input *ListUpstreamSourcesInput) (*ListUpstreamSourcesOutput, error)

ListUpstreamSources API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation ListUpstreamSources for usage and error information.

func (*APIG) ListUpstreamSourcesCommon ¶

func (c *APIG) ListUpstreamSourcesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ListUpstreamSourcesCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation ListUpstreamSourcesCommon for usage and error information.

func (*APIG) ListUpstreamSourcesCommonRequest ¶

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

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

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

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

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

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

func (*APIG) ListUpstreamSourcesCommonWithContext ¶

func (c *APIG) ListUpstreamSourcesCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See ListUpstreamSourcesCommon 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 (*APIG) ListUpstreamSourcesRequest ¶

func (c *APIG) ListUpstreamSourcesRequest(input *ListUpstreamSourcesInput) (req *request.Request, output *ListUpstreamSourcesOutput)

ListUpstreamSourcesRequest generates a "volcengine/request.Request" representing the client's request for the ListUpstreamSources operation. The "output" return value will be populated with the ListUpstreamSourcesCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) ListUpstreamSourcesWithContext ¶

func (c *APIG) ListUpstreamSourcesWithContext(ctx volcengine.Context, input *ListUpstreamSourcesInput, opts ...request.Option) (*ListUpstreamSourcesOutput, error)

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

See ListUpstreamSources 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 (*APIG) ListUpstreams ¶

func (c *APIG) ListUpstreams(input *ListUpstreamsInput) (*ListUpstreamsOutput, error)

ListUpstreams API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation ListUpstreams for usage and error information.

func (*APIG) ListUpstreamsCommon ¶

func (c *APIG) ListUpstreamsCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ListUpstreamsCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation ListUpstreamsCommon for usage and error information.

func (*APIG) ListUpstreamsCommonRequest ¶

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

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

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

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

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

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

func (*APIG) ListUpstreamsCommonWithContext ¶

func (c *APIG) ListUpstreamsCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See ListUpstreamsCommon 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 (*APIG) ListUpstreamsRequest ¶

func (c *APIG) ListUpstreamsRequest(input *ListUpstreamsInput) (req *request.Request, output *ListUpstreamsOutput)

ListUpstreamsRequest generates a "volcengine/request.Request" representing the client's request for the ListUpstreams operation. The "output" return value will be populated with the ListUpstreamsCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) ListUpstreamsWithContext ¶

func (c *APIG) ListUpstreamsWithContext(ctx volcengine.Context, input *ListUpstreamsInput, opts ...request.Option) (*ListUpstreamsOutput, error)

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

See ListUpstreams 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 (*APIG) UpdateConsumer ¶

func (c *APIG) UpdateConsumer(input *UpdateConsumerInput) (*UpdateConsumerOutput, error)

UpdateConsumer API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation UpdateConsumer for usage and error information.

func (*APIG) UpdateConsumerCommon ¶

func (c *APIG) UpdateConsumerCommon(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateConsumerCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation UpdateConsumerCommon for usage and error information.

func (*APIG) UpdateConsumerCommonRequest ¶

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

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

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

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

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

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

func (*APIG) UpdateConsumerCommonWithContext ¶

func (c *APIG) UpdateConsumerCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See UpdateConsumerCommon 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 (*APIG) UpdateConsumerRequest ¶

func (c *APIG) UpdateConsumerRequest(input *UpdateConsumerInput) (req *request.Request, output *UpdateConsumerOutput)

UpdateConsumerRequest generates a "volcengine/request.Request" representing the client's request for the UpdateConsumer operation. The "output" return value will be populated with the UpdateConsumerCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) UpdateConsumerWithContext ¶

func (c *APIG) UpdateConsumerWithContext(ctx volcengine.Context, input *UpdateConsumerInput, opts ...request.Option) (*UpdateConsumerOutput, error)

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

See UpdateConsumer 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 (*APIG) UpdateGateway ¶

func (c *APIG) UpdateGateway(input *UpdateGatewayInput) (*UpdateGatewayOutput, error)

UpdateGateway API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation UpdateGateway for usage and error information.

func (*APIG) UpdateGatewayCommon ¶

func (c *APIG) UpdateGatewayCommon(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateGatewayCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation UpdateGatewayCommon for usage and error information.

func (*APIG) UpdateGatewayCommonRequest ¶

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

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

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

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

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

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

func (*APIG) UpdateGatewayCommonWithContext ¶

func (c *APIG) UpdateGatewayCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See UpdateGatewayCommon 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 (*APIG) UpdateGatewayCustomLog ¶

func (c *APIG) UpdateGatewayCustomLog(input *UpdateGatewayCustomLogInput) (*UpdateGatewayCustomLogOutput, error)

UpdateGatewayCustomLog API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation UpdateGatewayCustomLog for usage and error information.

func (*APIG) UpdateGatewayCustomLogCommon ¶

func (c *APIG) UpdateGatewayCustomLogCommon(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateGatewayCustomLogCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation UpdateGatewayCustomLogCommon for usage and error information.

func (*APIG) UpdateGatewayCustomLogCommonRequest ¶

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

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

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

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

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

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

func (*APIG) UpdateGatewayCustomLogCommonWithContext ¶

func (c *APIG) UpdateGatewayCustomLogCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See UpdateGatewayCustomLogCommon 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 (*APIG) UpdateGatewayCustomLogRequest ¶

func (c *APIG) UpdateGatewayCustomLogRequest(input *UpdateGatewayCustomLogInput) (req *request.Request, output *UpdateGatewayCustomLogOutput)

UpdateGatewayCustomLogRequest generates a "volcengine/request.Request" representing the client's request for the UpdateGatewayCustomLog operation. The "output" return value will be populated with the UpdateGatewayCustomLogCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) UpdateGatewayCustomLogWithContext ¶

func (c *APIG) UpdateGatewayCustomLogWithContext(ctx volcengine.Context, input *UpdateGatewayCustomLogInput, opts ...request.Option) (*UpdateGatewayCustomLogOutput, error)

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

See UpdateGatewayCustomLog 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 (*APIG) UpdateGatewayLog ¶

func (c *APIG) UpdateGatewayLog(input *UpdateGatewayLogInput) (*UpdateGatewayLogOutput, error)

UpdateGatewayLog API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation UpdateGatewayLog for usage and error information.

func (*APIG) UpdateGatewayLogCommon ¶

func (c *APIG) UpdateGatewayLogCommon(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateGatewayLogCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation UpdateGatewayLogCommon for usage and error information.

func (*APIG) UpdateGatewayLogCommonRequest ¶

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

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

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

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

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

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

func (*APIG) UpdateGatewayLogCommonWithContext ¶

func (c *APIG) UpdateGatewayLogCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See UpdateGatewayLogCommon 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 (*APIG) UpdateGatewayLogRequest ¶

func (c *APIG) UpdateGatewayLogRequest(input *UpdateGatewayLogInput) (req *request.Request, output *UpdateGatewayLogOutput)

UpdateGatewayLogRequest generates a "volcengine/request.Request" representing the client's request for the UpdateGatewayLog operation. The "output" return value will be populated with the UpdateGatewayLogCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) UpdateGatewayLogWithContext ¶

func (c *APIG) UpdateGatewayLogWithContext(ctx volcengine.Context, input *UpdateGatewayLogInput, opts ...request.Option) (*UpdateGatewayLogOutput, error)

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

See UpdateGatewayLog 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 (*APIG) UpdateGatewayRequest ¶

func (c *APIG) UpdateGatewayRequest(input *UpdateGatewayInput) (req *request.Request, output *UpdateGatewayOutput)

UpdateGatewayRequest generates a "volcengine/request.Request" representing the client's request for the UpdateGateway operation. The "output" return value will be populated with the UpdateGatewayCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) UpdateGatewayService ¶

func (c *APIG) UpdateGatewayService(input *UpdateGatewayServiceInput) (*UpdateGatewayServiceOutput, error)

UpdateGatewayService API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation UpdateGatewayService for usage and error information.

func (*APIG) UpdateGatewayServiceCommon ¶

func (c *APIG) UpdateGatewayServiceCommon(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateGatewayServiceCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation UpdateGatewayServiceCommon for usage and error information.

func (*APIG) UpdateGatewayServiceCommonRequest ¶

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

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

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

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

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

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

func (*APIG) UpdateGatewayServiceCommonWithContext ¶

func (c *APIG) UpdateGatewayServiceCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See UpdateGatewayServiceCommon 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 (*APIG) UpdateGatewayServiceRequest ¶

func (c *APIG) UpdateGatewayServiceRequest(input *UpdateGatewayServiceInput) (req *request.Request, output *UpdateGatewayServiceOutput)

UpdateGatewayServiceRequest generates a "volcengine/request.Request" representing the client's request for the UpdateGatewayService operation. The "output" return value will be populated with the UpdateGatewayServiceCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) UpdateGatewayServiceWithContext ¶

func (c *APIG) UpdateGatewayServiceWithContext(ctx volcengine.Context, input *UpdateGatewayServiceInput, opts ...request.Option) (*UpdateGatewayServiceOutput, error)

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

See UpdateGatewayService 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 (*APIG) UpdateGatewaySpec ¶

func (c *APIG) UpdateGatewaySpec(input *UpdateGatewaySpecInput) (*UpdateGatewaySpecOutput, error)

UpdateGatewaySpec API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation UpdateGatewaySpec for usage and error information.

func (*APIG) UpdateGatewaySpecCommon ¶

func (c *APIG) UpdateGatewaySpecCommon(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateGatewaySpecCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation UpdateGatewaySpecCommon for usage and error information.

func (*APIG) UpdateGatewaySpecCommonRequest ¶

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

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

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

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

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

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

func (*APIG) UpdateGatewaySpecCommonWithContext ¶

func (c *APIG) UpdateGatewaySpecCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See UpdateGatewaySpecCommon 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 (*APIG) UpdateGatewaySpecRequest ¶

func (c *APIG) UpdateGatewaySpecRequest(input *UpdateGatewaySpecInput) (req *request.Request, output *UpdateGatewaySpecOutput)

UpdateGatewaySpecRequest generates a "volcengine/request.Request" representing the client's request for the UpdateGatewaySpec operation. The "output" return value will be populated with the UpdateGatewaySpecCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) UpdateGatewaySpecWithContext ¶

func (c *APIG) UpdateGatewaySpecWithContext(ctx volcengine.Context, input *UpdateGatewaySpecInput, opts ...request.Option) (*UpdateGatewaySpecOutput, error)

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

See UpdateGatewaySpec 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 (*APIG) UpdateGatewayWithContext ¶

func (c *APIG) UpdateGatewayWithContext(ctx volcengine.Context, input *UpdateGatewayInput, opts ...request.Option) (*UpdateGatewayOutput, error)

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

See UpdateGateway 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 (*APIG) UpdatePluginBinding ¶

func (c *APIG) UpdatePluginBinding(input *UpdatePluginBindingInput) (*UpdatePluginBindingOutput, error)

UpdatePluginBinding API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation UpdatePluginBinding for usage and error information.

func (*APIG) UpdatePluginBindingCommon ¶

func (c *APIG) UpdatePluginBindingCommon(input *map[string]interface{}) (*map[string]interface{}, error)

UpdatePluginBindingCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation UpdatePluginBindingCommon for usage and error information.

func (*APIG) UpdatePluginBindingCommonRequest ¶

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

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

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

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

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

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

func (*APIG) UpdatePluginBindingCommonWithContext ¶

func (c *APIG) UpdatePluginBindingCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See UpdatePluginBindingCommon 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 (*APIG) UpdatePluginBindingRequest ¶

func (c *APIG) UpdatePluginBindingRequest(input *UpdatePluginBindingInput) (req *request.Request, output *UpdatePluginBindingOutput)

UpdatePluginBindingRequest generates a "volcengine/request.Request" representing the client's request for the UpdatePluginBinding operation. The "output" return value will be populated with the UpdatePluginBindingCommon request's response once the request completes successfully.

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

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

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

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

func (*APIG) UpdatePluginBindingWithContext ¶

func (c *APIG) UpdatePluginBindingWithContext(ctx volcengine.Context, input *UpdatePluginBindingInput, opts ...request.Option) (*UpdatePluginBindingOutput, error)

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

See UpdatePluginBinding 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 (*APIG) UpdateUpstream ¶

func (c *APIG) UpdateUpstream(input *UpdateUpstreamInput) (*UpdateUpstreamOutput, error)

UpdateUpstream API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation UpdateUpstream for usage and error information.

func (*APIG) UpdateUpstreamCommon ¶

func (c *APIG) UpdateUpstreamCommon(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateUpstreamCommon API operation for APIG.

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

See the VOLCENGINE API reference guide for APIG's API operation UpdateUpstreamCommon for usage and error information.

func (*APIG) UpdateUpstreamCommonRequest ¶

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

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

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

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

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

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

func (*APIG) UpdateUpstreamCommonWithContext ¶

func (c *APIG) UpdateUpstreamCommonWithContext(ctx volcengine.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)