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) AttachGatewayLB ¶

func (c *APIG) AttachGatewayLB(input *AttachGatewayLBInput) (*AttachGatewayLBOutput, error)

AttachGatewayLB API operation for APIG.

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

See the BYTEPLUS API reference guide for APIG's API operation AttachGatewayLB for usage and error information.

func (*APIG) AttachGatewayLBCommon ¶

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

AttachGatewayLBCommon API operation for APIG.

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

See the BYTEPLUS API reference guide for APIG's API operation AttachGatewayLBCommon for usage and error information.

func (*APIG) AttachGatewayLBCommonRequest ¶

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

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

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

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

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

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

func (*APIG) AttachGatewayLBCommonWithContext ¶

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

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

See AttachGatewayLBCommon 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) AttachGatewayLBRequest ¶

func (c *APIG) AttachGatewayLBRequest(input *AttachGatewayLBInput) (req *request.Request, output *AttachGatewayLBOutput)

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

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

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

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

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

func (*APIG) AttachGatewayLBWithContext ¶

func (c *APIG) AttachGatewayLBWithContext(ctx byteplus.Context, input *AttachGatewayLBInput, opts ...request.Option) (*AttachGatewayLBOutput, error)

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

See AttachGatewayLB 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) CreateConsumer ¶

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

CreateConsumer API operation for APIG.

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

See the BYTEPLUS API reference guide for 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 "byteplus/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 byteplus.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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 "byteplus/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 byteplus.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 "byteplus/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 byteplus.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 "byteplus/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 byteplus.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) CreateCustomDomain ¶

func (c *APIG) CreateCustomDomain(input *CreateCustomDomainInput) (*CreateCustomDomainOutput, error)

CreateCustomDomain API operation for APIG.

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

See the BYTEPLUS API reference guide for APIG's API operation CreateCustomDomain for usage and error information.

func (*APIG) CreateCustomDomainCommon ¶

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

CreateCustomDomainCommon API operation for APIG.

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

See the BYTEPLUS API reference guide for APIG's API operation CreateCustomDomainCommon for usage and error information.

func (*APIG) CreateCustomDomainCommonRequest ¶

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

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

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

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

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

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

func (*APIG) CreateCustomDomainCommonWithContext ¶

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

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

See CreateCustomDomainCommon 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) CreateCustomDomainRequest ¶

func (c *APIG) CreateCustomDomainRequest(input *CreateCustomDomainInput) (req *request.Request, output *CreateCustomDomainOutput)

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

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

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

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

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

func (*APIG) CreateCustomDomainWithContext ¶

func (c *APIG) CreateCustomDomainWithContext(ctx byteplus.Context, input *CreateCustomDomainInput, opts ...request.Option) (*CreateCustomDomainOutput, error)

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

See CreateCustomDomain 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 "byteplus/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 byteplus.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 "byteplus/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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 "byteplus/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 byteplus.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 "byteplus/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 byteplus.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 byteplus.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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 "byteplus/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 byteplus.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 "byteplus/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 byteplus.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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 "byteplus/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 byteplus.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 "byteplus/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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 "byteplus/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 byteplus.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 "byteplus/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 byteplus.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) CreateUpstreamVersion ¶

func (c *APIG) CreateUpstreamVersion(input *CreateUpstreamVersionInput) (*CreateUpstreamVersionOutput, error)

CreateUpstreamVersion API operation for APIG.

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

See the BYTEPLUS API reference guide for APIG's API operation CreateUpstreamVersion for usage and error information.

func (*APIG) CreateUpstreamVersionCommon ¶

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

CreateUpstreamVersionCommon API operation for APIG.

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

See the BYTEPLUS API reference guide for APIG's API operation CreateUpstreamVersionCommon for usage and error information.

func (*APIG) CreateUpstreamVersionCommonRequest ¶

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

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

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

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

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

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

func (*APIG) CreateUpstreamVersionCommonWithContext ¶

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

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

See CreateUpstreamVersionCommon 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) CreateUpstreamVersionRequest ¶

func (c *APIG) CreateUpstreamVersionRequest(input *CreateUpstreamVersionInput) (req *request.Request, output *CreateUpstreamVersionOutput)

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

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

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

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

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

func (*APIG) CreateUpstreamVersionWithContext ¶

func (c *APIG) CreateUpstreamVersionWithContext(ctx byteplus.Context, input *CreateUpstreamVersionInput, opts ...request.Option) (*CreateUpstreamVersionOutput, error)

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

See CreateUpstreamVersion 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 byteplus.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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 "byteplus/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 byteplus.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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 "byteplus/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 byteplus.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 "byteplus/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 byteplus.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 "byteplus/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 byteplus.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) DeleteCustomDomain ¶

func (c *APIG) DeleteCustomDomain(input *DeleteCustomDomainInput) (*DeleteCustomDomainOutput, error)

DeleteCustomDomain API operation for APIG.

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

See the BYTEPLUS API reference guide for APIG's API operation DeleteCustomDomain for usage and error information.

func (*APIG) DeleteCustomDomainCommon ¶

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

DeleteCustomDomainCommon API operation for APIG.

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

See the BYTEPLUS API reference guide for APIG's API operation DeleteCustomDomainCommon for usage and error information.

func (*APIG) DeleteCustomDomainCommonRequest ¶

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

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

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

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

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

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

func (*APIG) DeleteCustomDomainCommonWithContext ¶

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

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

See DeleteCustomDomainCommon 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) DeleteCustomDomainRequest ¶

func (c *APIG) DeleteCustomDomainRequest(input *DeleteCustomDomainInput) (req *request.Request, output *DeleteCustomDomainOutput)

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

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

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

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

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

func (*APIG) DeleteCustomDomainWithContext ¶

func (c *APIG) DeleteCustomDomainWithContext(ctx byteplus.Context, input *DeleteCustomDomainInput, opts ...request.Option) (*DeleteCustomDomainOutput, error)

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

See DeleteCustomDomain 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 "byteplus/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 byteplus.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 "byteplus/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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 "byteplus/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 byteplus.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 "byteplus/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 byteplus.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 byteplus.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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 "byteplus/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 byteplus.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 "byteplus/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 byteplus.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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 "byteplus/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 byteplus.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 "byteplus/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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 "byteplus/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 byteplus.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 "byteplus/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 byteplus.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) DeleteUpstreamVersion ¶

func (c *APIG) DeleteUpstreamVersion(input *DeleteUpstreamVersionInput) (*DeleteUpstreamVersionOutput, error)

DeleteUpstreamVersion API operation for APIG.

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

See the BYTEPLUS API reference guide for APIG's API operation DeleteUpstreamVersion for usage and error information.

func (*APIG) DeleteUpstreamVersionCommon ¶

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

DeleteUpstreamVersionCommon API operation for APIG.

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

See the BYTEPLUS API reference guide for APIG's API operation DeleteUpstreamVersionCommon for usage and error information.

func (*APIG) DeleteUpstreamVersionCommonRequest ¶

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

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

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

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

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

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

func (*APIG) DeleteUpstreamVersionCommonWithContext ¶

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

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

See DeleteUpstreamVersionCommon 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) DeleteUpstreamVersionRequest ¶

func (c *APIG) DeleteUpstreamVersionRequest(input *DeleteUpstreamVersionInput) (req *request.Request, output *DeleteUpstreamVersionOutput)

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

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

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

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

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

func (*APIG) DeleteUpstreamVersionWithContext ¶

func (c *APIG) DeleteUpstreamVersionWithContext(ctx byteplus.Context, input *DeleteUpstreamVersionInput, opts ...request.Option) (*DeleteUpstreamVersionOutput, error)

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

See DeleteUpstreamVersion 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 byteplus.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) DetachGatewayLB ¶

func (c *APIG) DetachGatewayLB(input *DetachGatewayLBInput) (*DetachGatewayLBOutput, error)

DetachGatewayLB API operation for APIG.

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

See the BYTEPLUS API reference guide for APIG's API operation DetachGatewayLB for usage and error information.

func (*APIG) DetachGatewayLBCommon ¶

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

DetachGatewayLBCommon API operation for APIG.

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

See the BYTEPLUS API reference guide for APIG's API operation DetachGatewayLBCommon for usage and error information.

func (*APIG) DetachGatewayLBCommonRequest ¶

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

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

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

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

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

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

func (*APIG) DetachGatewayLBCommonWithContext ¶

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

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

See DetachGatewayLBCommon 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) DetachGatewayLBRequest ¶

func (c *APIG) DetachGatewayLBRequest(input *DetachGatewayLBInput) (req *request.Request, output *DetachGatewayLBOutput)

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

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

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

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

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

func (*APIG) DetachGatewayLBWithContext ¶

func (c *APIG) DetachGatewayLBWithContext(ctx byteplus.Context, input *DetachGatewayLBInput, opts ...request.Option) (*DetachGatewayLBOutput, error)

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

See DetachGatewayLB 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 "byteplus/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 byteplus.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 "byteplus/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 byteplus.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) GetCustomDomain ¶

func (c *APIG) GetCustomDomain(input *GetCustomDomainInput) (*GetCustomDomainOutput, error)

GetCustomDomain API operation for APIG.

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

See the BYTEPLUS API reference guide for APIG's API operation GetCustomDomain for usage and error information.

func (*APIG) GetCustomDomainCommon ¶

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

GetCustomDomainCommon API operation for APIG.

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

See the BYTEPLUS API reference guide for APIG's API operation GetCustomDomainCommon for usage and error information.

func (*APIG) GetCustomDomainCommonRequest ¶

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

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

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

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

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

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

func (*APIG) GetCustomDomainCommonWithContext ¶

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

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

See GetCustomDomainCommon 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) GetCustomDomainRequest ¶

func (c *APIG) GetCustomDomainRequest(input *GetCustomDomainInput) (req *request.Request, output *GetCustomDomainOutput)

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

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

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

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

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

func (*APIG) GetCustomDomainWithContext ¶

func (c *APIG) GetCustomDomainWithContext(ctx byteplus.Context, input *GetCustomDomainInput, opts ...request.Option) (*GetCustomDomainOutput, error)

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

See GetCustomDomain 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 "byteplus/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 byteplus.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 "byteplus/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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 "byteplus/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 byteplus.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 "byteplus/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 byteplus.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 byteplus.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) GetJwtToken ¶

func (c *APIG) GetJwtToken(input *GetJwtTokenInput) (*GetJwtTokenOutput, error)

GetJwtToken API operation for APIG.

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

See the BYTEPLUS API reference guide for APIG's API operation GetJwtToken for usage and error information.

func (*APIG) GetJwtTokenCommon ¶

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

GetJwtTokenCommon API operation for APIG.

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

See the BYTEPLUS API reference guide for APIG's API operation GetJwtTokenCommon for usage and error information.

func (*APIG) GetJwtTokenCommonRequest ¶

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

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

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

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

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

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

func (*APIG) GetJwtTokenCommonWithContext ¶

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

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

See GetJwtTokenCommon 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) GetJwtTokenRequest ¶

func (c *APIG) GetJwtTokenRequest(input *GetJwtTokenInput) (req *request.Request, output *GetJwtTokenOutput)

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

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

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

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

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

func (*APIG) GetJwtTokenWithContext ¶

func (c *APIG) GetJwtTokenWithContext(ctx byteplus.Context, input *GetJwtTokenInput, opts ...request.Option) (*GetJwtTokenOutput, error)

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

See GetJwtToken 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 "byteplus/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 byteplus.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 "byteplus/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 byteplus.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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 "byteplus/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 byteplus.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 "byteplus/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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 bytepluserr.Error for service API and SDK errors. Use runtime type assertions with bytepluserr.Error's Code and Message methods to get detailed information about the error.

See the BYTEPLUS API reference guide for 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 "byteplus/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 byteplus.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 "byteplus/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 byteplus.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.