cp

func (*CP) CancelPipelineRun ¶

func (c *CP) CancelPipelineRun(input *CancelPipelineRunInput) (*CancelPipelineRunOutput, error)

CancelPipelineRun API operation for CP.

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

func (*CP) CancelPipelineRunCommon ¶

func (c *CP) CancelPipelineRunCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CancelPipelineRunCommon API operation for CP.

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

func (*CP) CancelPipelineRunCommonRequest ¶

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

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

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

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

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

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

func (*CP) CancelPipelineRunCommonWithContext ¶

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

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

See CancelPipelineRunCommon 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 (*CP) CancelPipelineRunRequest ¶

func (c *CP) CancelPipelineRunRequest(input *CancelPipelineRunInput) (req *request.Request, output *CancelPipelineRunOutput)

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

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

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

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

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

func (*CP) CancelPipelineRunWithContext ¶

func (c *CP) CancelPipelineRunWithContext(ctx byteplus.Context, input *CancelPipelineRunInput, opts ...request.Option) (*CancelPipelineRunOutput, error)

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

See CancelPipelineRun 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 (*CP) CreateComponentStep ¶

func (c *CP) CreateComponentStep(input *CreateComponentStepInput) (*CreateComponentStepOutput, error)

CreateComponentStep API operation for CP.

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

func (*CP) CreateComponentStepCommon ¶

func (c *CP) CreateComponentStepCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateComponentStepCommon API operation for CP.

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

func (*CP) CreateComponentStepCommonRequest ¶

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

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

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

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

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

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

func (*CP) CreateComponentStepCommonWithContext ¶

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

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

See CreateComponentStepCommon 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 (*CP) CreateComponentStepRequest ¶

func (c *CP) CreateComponentStepRequest(input *CreateComponentStepInput) (req *request.Request, output *CreateComponentStepOutput)

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

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

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

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

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

func (*CP) CreateComponentStepWithContext ¶

func (c *CP) CreateComponentStepWithContext(ctx byteplus.Context, input *CreateComponentStepInput, opts ...request.Option) (*CreateComponentStepOutput, error)

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

See CreateComponentStep 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 (*CP) CreatePipelineWebhookURL ¶

func (c *CP) CreatePipelineWebhookURL(input *CreatePipelineWebhookURLInput) (*CreatePipelineWebhookURLOutput, error)

CreatePipelineWebhookURL API operation for CP.

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

func (*CP) CreatePipelineWebhookURLCommon ¶

func (c *CP) CreatePipelineWebhookURLCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreatePipelineWebhookURLCommon API operation for CP.

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

func (*CP) CreatePipelineWebhookURLCommonRequest ¶

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

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

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

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

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

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

func (*CP) CreatePipelineWebhookURLCommonWithContext ¶

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

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

See CreatePipelineWebhookURLCommon 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 (*CP) CreatePipelineWebhookURLRequest ¶

func (c *CP) CreatePipelineWebhookURLRequest(input *CreatePipelineWebhookURLInput) (req *request.Request, output *CreatePipelineWebhookURLOutput)

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

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

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

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

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

func (*CP) CreatePipelineWebhookURLWithContext ¶

func (c *CP) CreatePipelineWebhookURLWithContext(ctx byteplus.Context, input *CreatePipelineWebhookURLInput, opts ...request.Option) (*CreatePipelineWebhookURLOutput, error)

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

See CreatePipelineWebhookURL 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 (*CP) CreateResource ¶

func (c *CP) CreateResource(input *CreateResourceInput) (*CreateResourceOutput, error)

CreateResource API operation for CP.

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

func (*CP) CreateResourceCommon ¶

func (c *CP) CreateResourceCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateResourceCommon API operation for CP.

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

func (*CP) CreateResourceCommonRequest ¶

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

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

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

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

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

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

func (*CP) CreateResourceCommonWithContext ¶

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

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

See CreateResourceCommon 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 (*CP) CreateResourceRequest ¶

func (c *CP) CreateResourceRequest(input *CreateResourceInput) (req *request.Request, output *CreateResourceOutput)

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

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

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

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

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

func (*CP) CreateResourceWithContext ¶

func (c *CP) CreateResourceWithContext(ctx byteplus.Context, input *CreateResourceInput, opts ...request.Option) (*CreateResourceOutput, error)

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

See CreateResource 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 (*CP) CreateServiceConnection ¶

func (c *CP) CreateServiceConnection(input *CreateServiceConnectionInput) (*CreateServiceConnectionOutput, error)

CreateServiceConnection API operation for CP.

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

func (*CP) CreateServiceConnectionCommon ¶

func (c *CP) CreateServiceConnectionCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateServiceConnectionCommon API operation for CP.

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

func (*CP) CreateServiceConnectionCommonRequest ¶

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

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

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

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

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

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

func (*CP) CreateServiceConnectionCommonWithContext ¶

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

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

See CreateServiceConnectionCommon 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 (*CP) CreateServiceConnectionRequest ¶

func (c *CP) CreateServiceConnectionRequest(input *CreateServiceConnectionInput) (req *request.Request, output *CreateServiceConnectionOutput)

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

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

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

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

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

func (*CP) CreateServiceConnectionWithContext ¶

func (c *CP) CreateServiceConnectionWithContext(ctx byteplus.Context, input *CreateServiceConnectionInput, opts ...request.Option) (*CreateServiceConnectionOutput, error)

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

See CreateServiceConnection 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 (*CP) CreateTrigger ¶

func (c *CP) CreateTrigger(input *CreateTriggerInput) (*CreateTriggerOutput, error)

CreateTrigger API operation for CP.

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

func (*CP) CreateTriggerCommon ¶

func (c *CP) CreateTriggerCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateTriggerCommon API operation for CP.

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

func (*CP) CreateTriggerCommonRequest ¶

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

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

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

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

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

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

func (*CP) CreateTriggerCommonWithContext ¶

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

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

See CreateTriggerCommon 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 (*CP) CreateTriggerRequest ¶

func (c *CP) CreateTriggerRequest(input *CreateTriggerInput) (req *request.Request, output *CreateTriggerOutput)

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

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

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

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

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

func (*CP) CreateTriggerWithContext ¶

func (c *CP) CreateTriggerWithContext(ctx byteplus.Context, input *CreateTriggerInput, opts ...request.Option) (*CreateTriggerOutput, error)

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

See CreateTrigger 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 (*CP) CreateWorkspace ¶

func (c *CP) CreateWorkspace(input *CreateWorkspaceInput) (*CreateWorkspaceOutput, error)

CreateWorkspace API operation for CP.

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

func (*CP) CreateWorkspaceCommon ¶

func (c *CP) CreateWorkspaceCommon(input *map[string]interface{}) (*map[string]interface{}, error)

CreateWorkspaceCommon API operation for CP.

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

func (*CP) CreateWorkspaceCommonRequest ¶

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

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

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

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

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

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

func (*CP) CreateWorkspaceCommonWithContext ¶

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

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

See CreateWorkspaceCommon 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 (*CP) CreateWorkspaceRequest ¶

func (c *CP) CreateWorkspaceRequest(input *CreateWorkspaceInput) (req *request.Request, output *CreateWorkspaceOutput)

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

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

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

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

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

func (*CP) CreateWorkspaceWithContext ¶

func (c *CP) CreateWorkspaceWithContext(ctx byteplus.Context, input *CreateWorkspaceInput, opts ...request.Option) (*CreateWorkspaceOutput, error)

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

See CreateWorkspace 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 (*CP) DeleteComponentStep ¶

func (c *CP) DeleteComponentStep(input *DeleteComponentStepInput) (*DeleteComponentStepOutput, error)

DeleteComponentStep API operation for CP.

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

func (*CP) DeleteComponentStepCommon ¶

func (c *CP) DeleteComponentStepCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteComponentStepCommon API operation for CP.

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

func (*CP) DeleteComponentStepCommonRequest ¶

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

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

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

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

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

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

func (*CP) DeleteComponentStepCommonWithContext ¶

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

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

See DeleteComponentStepCommon 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 (*CP) DeleteComponentStepRequest ¶

func (c *CP) DeleteComponentStepRequest(input *DeleteComponentStepInput) (req *request.Request, output *DeleteComponentStepOutput)

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

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

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

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

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

func (*CP) DeleteComponentStepWithContext ¶

func (c *CP) DeleteComponentStepWithContext(ctx byteplus.Context, input *DeleteComponentStepInput, opts ...request.Option) (*DeleteComponentStepOutput, error)

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

See DeleteComponentStep 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 (*CP) DeletePipeline ¶

func (c *CP) DeletePipeline(input *DeletePipelineInput) (*DeletePipelineOutput, error)

DeletePipeline API operation for CP.

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

func (*CP) DeletePipelineCommon ¶

func (c *CP) DeletePipelineCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeletePipelineCommon API operation for CP.

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

func (*CP) DeletePipelineCommonRequest ¶

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

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

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

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

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

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

func (*CP) DeletePipelineCommonWithContext ¶

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

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

See DeletePipelineCommon 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 (*CP) DeletePipelineRequest ¶

func (c *CP) DeletePipelineRequest(input *DeletePipelineInput) (req *request.Request, output *DeletePipelineOutput)

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

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

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

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

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

func (*CP) DeletePipelineWithContext ¶

func (c *CP) DeletePipelineWithContext(ctx byteplus.Context, input *DeletePipelineInput, opts ...request.Option) (*DeletePipelineOutput, error)

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

See DeletePipeline 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 (*CP) DeleteResource ¶

func (c *CP) DeleteResource(input *DeleteResourceInput) (*DeleteResourceOutput, error)

DeleteResource API operation for CP.

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

func (*CP) DeleteResourceCommon ¶

func (c *CP) DeleteResourceCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteResourceCommon API operation for CP.

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

func (*CP) DeleteResourceCommonRequest ¶

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

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

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

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

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

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

func (*CP) DeleteResourceCommonWithContext ¶

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

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

See DeleteResourceCommon 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 (*CP) DeleteResourceRequest ¶

func (c *CP) DeleteResourceRequest(input *DeleteResourceInput) (req *request.Request, output *DeleteResourceOutput)

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

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

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

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

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

func (*CP) DeleteResourceWithContext ¶

func (c *CP) DeleteResourceWithContext(ctx byteplus.Context, input *DeleteResourceInput, opts ...request.Option) (*DeleteResourceOutput, error)

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

See DeleteResource 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 (*CP) DeleteServiceConnection ¶

func (c *CP) DeleteServiceConnection(input *DeleteServiceConnectionInput) (*DeleteServiceConnectionOutput, error)

DeleteServiceConnection API operation for CP.

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

func (*CP) DeleteServiceConnectionCommon ¶

func (c *CP) DeleteServiceConnectionCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteServiceConnectionCommon API operation for CP.

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

func (*CP) DeleteServiceConnectionCommonRequest ¶

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

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

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

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

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

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

func (*CP) DeleteServiceConnectionCommonWithContext ¶

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

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

See DeleteServiceConnectionCommon 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 (*CP) DeleteServiceConnectionRequest ¶

func (c *CP) DeleteServiceConnectionRequest(input *DeleteServiceConnectionInput) (req *request.Request, output *DeleteServiceConnectionOutput)

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

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

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

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

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

func (*CP) DeleteServiceConnectionWithContext ¶

func (c *CP) DeleteServiceConnectionWithContext(ctx byteplus.Context, input *DeleteServiceConnectionInput, opts ...request.Option) (*DeleteServiceConnectionOutput, error)

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

See DeleteServiceConnection 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 (*CP) DeleteTrigger ¶

func (c *CP) DeleteTrigger(input *DeleteTriggerInput) (*DeleteTriggerOutput, error)

DeleteTrigger API operation for CP.

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

func (*CP) DeleteTriggerCommon ¶

func (c *CP) DeleteTriggerCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteTriggerCommon API operation for CP.

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

func (*CP) DeleteTriggerCommonRequest ¶

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

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

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

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

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

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

func (*CP) DeleteTriggerCommonWithContext ¶

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

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

See DeleteTriggerCommon 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 (*CP) DeleteTriggerRequest ¶

func (c *CP) DeleteTriggerRequest(input *DeleteTriggerInput) (req *request.Request, output *DeleteTriggerOutput)

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

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

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

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

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

func (*CP) DeleteTriggerWithContext ¶

func (c *CP) DeleteTriggerWithContext(ctx byteplus.Context, input *DeleteTriggerInput, opts ...request.Option) (*DeleteTriggerOutput, error)

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

See DeleteTrigger 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 (*CP) DeleteWorkspace ¶

func (c *CP) DeleteWorkspace(input *DeleteWorkspaceInput) (*DeleteWorkspaceOutput, error)

DeleteWorkspace API operation for CP.

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

func (*CP) DeleteWorkspaceCommon ¶

func (c *CP) DeleteWorkspaceCommon(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteWorkspaceCommon API operation for CP.

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

func (*CP) DeleteWorkspaceCommonRequest ¶

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

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

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

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

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

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

func (*CP) DeleteWorkspaceCommonWithContext ¶

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

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

See DeleteWorkspaceCommon 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 (*CP) DeleteWorkspaceRequest ¶

func (c *CP) DeleteWorkspaceRequest(input *DeleteWorkspaceInput) (req *request.Request, output *DeleteWorkspaceOutput)

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

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

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

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

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

func (*CP) DeleteWorkspaceWithContext ¶

func (c *CP) DeleteWorkspaceWithContext(ctx byteplus.Context, input *DeleteWorkspaceInput, opts ...request.Option) (*DeleteWorkspaceOutput, error)

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

See DeleteWorkspace 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 (*CP) GetServiceConnection ¶

func (c *CP) GetServiceConnection(input *GetServiceConnectionInput) (*GetServiceConnectionOutput, error)

GetServiceConnection API operation for CP.

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

func (*CP) GetServiceConnectionCommon ¶

func (c *CP) GetServiceConnectionCommon(input *map[string]interface{}) (*map[string]interface{}, error)

GetServiceConnectionCommon API operation for CP.

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

func (*CP) GetServiceConnectionCommonRequest ¶

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

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

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

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

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

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

func (*CP) GetServiceConnectionCommonWithContext ¶

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

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

See GetServiceConnectionCommon 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 (*CP) GetServiceConnectionRequest ¶

func (c *CP) GetServiceConnectionRequest(input *GetServiceConnectionInput) (req *request.Request, output *GetServiceConnectionOutput)

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

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

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

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

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

func (*CP) GetServiceConnectionWithContext ¶

func (c *CP) GetServiceConnectionWithContext(ctx byteplus.Context, input *GetServiceConnectionInput, opts ...request.Option) (*GetServiceConnectionOutput, error)

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

See GetServiceConnection 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 (*CP) GetTaskRunLog ¶

func (c *CP) GetTaskRunLog(input *GetTaskRunLogInput) (*GetTaskRunLogOutput, error)

GetTaskRunLog API operation for CP.

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

func (*CP) GetTaskRunLogCommon ¶

func (c *CP) GetTaskRunLogCommon(input *map[string]interface{}) (*map[string]interface{}, error)

GetTaskRunLogCommon API operation for CP.

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

func (*CP) GetTaskRunLogCommonRequest ¶

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

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

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

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

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

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

func (*CP) GetTaskRunLogCommonWithContext ¶

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

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

See GetTaskRunLogCommon 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 (*CP) GetTaskRunLogDownloadURI ¶

func (c *CP) GetTaskRunLogDownloadURI(input *GetTaskRunLogDownloadURIInput) (*GetTaskRunLogDownloadURIOutput, error)

GetTaskRunLogDownloadURI API operation for CP.

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

func (*CP) GetTaskRunLogDownloadURICommon ¶

func (c *CP) GetTaskRunLogDownloadURICommon(input *map[string]interface{}) (*map[string]interface{}, error)

GetTaskRunLogDownloadURICommon API operation for CP.

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

func (*CP) GetTaskRunLogDownloadURICommonRequest ¶

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

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

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

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

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

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

func (*CP) GetTaskRunLogDownloadURICommonWithContext ¶

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

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

See GetTaskRunLogDownloadURICommon 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 (*CP) GetTaskRunLogDownloadURIRequest ¶

func (c *CP) GetTaskRunLogDownloadURIRequest(input *GetTaskRunLogDownloadURIInput) (req *request.Request, output *GetTaskRunLogDownloadURIOutput)

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

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

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

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

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

func (*CP) GetTaskRunLogDownloadURIWithContext ¶

func (c *CP) GetTaskRunLogDownloadURIWithContext(ctx byteplus.Context, input *GetTaskRunLogDownloadURIInput, opts ...request.Option) (*GetTaskRunLogDownloadURIOutput, error)

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

See GetTaskRunLogDownloadURI 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 (*CP) GetTaskRunLogRequest ¶

func (c *CP) GetTaskRunLogRequest(input *GetTaskRunLogInput) (req *request.Request, output *GetTaskRunLogOutput)

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

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

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

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

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

func (*CP) GetTaskRunLogWithContext ¶

func (c *CP) GetTaskRunLogWithContext(ctx byteplus.Context, input *GetTaskRunLogInput, opts ...request.Option) (*GetTaskRunLogOutput, error)

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

See GetTaskRunLog 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 (*CP) ListComponentStep ¶

func (c *CP) ListComponentStep(input *ListComponentStepInput) (*ListComponentStepOutput, error)

ListComponentStep API operation for CP.

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

func (*CP) ListComponentStepCommon ¶

func (c *CP) ListComponentStepCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ListComponentStepCommon API operation for CP.

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

func (*CP) ListComponentStepCommonRequest ¶

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

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

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

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

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

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

func (*CP) ListComponentStepCommonWithContext ¶

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

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

See ListComponentStepCommon 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 (*CP) ListComponentStepRequest ¶

func (c *CP) ListComponentStepRequest(input *ListComponentStepInput) (req *request.Request, output *ListComponentStepOutput)

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

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

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

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

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

func (*CP) ListComponentStepWithContext ¶

func (c *CP) ListComponentStepWithContext(ctx byteplus.Context, input *ListComponentStepInput, opts ...request.Option) (*ListComponentStepOutput, error)

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

See ListComponentStep 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 (*CP) ListPipelineRuns ¶

func (c *CP) ListPipelineRuns(input *ListPipelineRunsInput) (*ListPipelineRunsOutput, error)

ListPipelineRuns API operation for CP.

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

func (*CP) ListPipelineRunsCommon ¶

func (c *CP) ListPipelineRunsCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ListPipelineRunsCommon API operation for CP.

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

func (*CP) ListPipelineRunsCommonRequest ¶

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

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

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

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

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

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

func (*CP) ListPipelineRunsCommonWithContext ¶

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

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

See ListPipelineRunsCommon 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 (*CP) ListPipelineRunsRequest ¶

func (c *CP) ListPipelineRunsRequest(input *ListPipelineRunsInput) (req *request.Request, output *ListPipelineRunsOutput)

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

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

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

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

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

func (*CP) ListPipelineRunsWithContext ¶

func (c *CP) ListPipelineRunsWithContext(ctx byteplus.Context, input *ListPipelineRunsInput, opts ...request.Option) (*ListPipelineRunsOutput, error)

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

See ListPipelineRuns 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 (*CP) ListPipelines ¶

func (c *CP) ListPipelines(input *ListPipelinesInput) (*ListPipelinesOutput, error)

ListPipelines API operation for CP.

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

func (*CP) ListPipelinesCommon ¶

func (c *CP) ListPipelinesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ListPipelinesCommon API operation for CP.

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

func (*CP) ListPipelinesCommonRequest ¶

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

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

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

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

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

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

func (*CP) ListPipelinesCommonWithContext ¶

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

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

See ListPipelinesCommon 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 (*CP) ListPipelinesRequest ¶

func (c *CP) ListPipelinesRequest(input *ListPipelinesInput) (req *request.Request, output *ListPipelinesOutput)

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

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

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

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

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

func (*CP) ListPipelinesWithContext ¶

func (c *CP) ListPipelinesWithContext(ctx byteplus.Context, input *ListPipelinesInput, opts ...request.Option) (*ListPipelinesOutput, error)

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

See ListPipelines 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 (*CP) ListResources ¶

func (c *CP) ListResources(input *ListResourcesInput) (*ListResourcesOutput, error)

ListResources API operation for CP.

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

func (*CP) ListResourcesCommon ¶

func (c *CP) ListResourcesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ListResourcesCommon API operation for CP.

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

func (*CP) ListResourcesCommonRequest ¶

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

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

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

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

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

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

func (*CP) ListResourcesCommonWithContext ¶

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

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

See ListResourcesCommon 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 (*CP) ListResourcesRequest ¶

func (c *CP) ListResourcesRequest(input *ListResourcesInput) (req *request.Request, output *ListResourcesOutput)

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

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

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

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

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

func (*CP) ListResourcesWithContext ¶

func (c *CP) ListResourcesWithContext(ctx byteplus.Context, input *ListResourcesInput, opts ...request.Option) (*ListResourcesOutput, error)

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

See ListResources 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 (*CP) ListServiceConnections ¶

func (c *CP) ListServiceConnections(input *ListServiceConnectionsInput) (*ListServiceConnectionsOutput, error)

ListServiceConnections API operation for CP.

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

func (*CP) ListServiceConnectionsCommon ¶

func (c *CP) ListServiceConnectionsCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ListServiceConnectionsCommon API operation for CP.

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

func (*CP) ListServiceConnectionsCommonRequest ¶

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

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

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

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

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

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

func (*CP) ListServiceConnectionsCommonWithContext ¶

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

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

See ListServiceConnectionsCommon 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 (*CP) ListServiceConnectionsRequest ¶

func (c *CP) ListServiceConnectionsRequest(input *ListServiceConnectionsInput) (req *request.Request, output *ListServiceConnectionsOutput)

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

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

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

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

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

func (*CP) ListServiceConnectionsWithContext ¶

func (c *CP) ListServiceConnectionsWithContext(ctx byteplus.Context, input *ListServiceConnectionsInput, opts ...request.Option) (*ListServiceConnectionsOutput, error)

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

See ListServiceConnections 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 (*CP) ListTaskRuns ¶

func (c *CP) ListTaskRuns(input *ListTaskRunsInput) (*ListTaskRunsOutput, error)

ListTaskRuns API operation for CP.

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

func (*CP) ListTaskRunsCommon ¶

func (c *CP) ListTaskRunsCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ListTaskRunsCommon API operation for CP.

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

func (*CP) ListTaskRunsCommonRequest ¶

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

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

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

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

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

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

func (*CP) ListTaskRunsCommonWithContext ¶

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

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

See ListTaskRunsCommon 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 (*CP) ListTaskRunsRequest ¶

func (c *CP) ListTaskRunsRequest(input *ListTaskRunsInput) (req *request.Request, output *ListTaskRunsOutput)

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

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

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

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

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

func (*CP) ListTaskRunsWithContext ¶

func (c *CP) ListTaskRunsWithContext(ctx byteplus.Context, input *ListTaskRunsInput, opts ...request.Option) (*ListTaskRunsOutput, error)

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

See ListTaskRuns 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 (*CP) ListTriggers ¶

func (c *CP) ListTriggers(input *ListTriggersInput) (*ListTriggersOutput, error)

ListTriggers API operation for CP.

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

func (*CP) ListTriggersCommon ¶

func (c *CP) ListTriggersCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ListTriggersCommon API operation for CP.

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

func (*CP) ListTriggersCommonRequest ¶

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

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

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

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

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

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

func (*CP) ListTriggersCommonWithContext ¶

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

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

See ListTriggersCommon 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 (*CP) ListTriggersRequest ¶

func (c *CP) ListTriggersRequest(input *ListTriggersInput) (req *request.Request, output *ListTriggersOutput)

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

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

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

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

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

func (*CP) ListTriggersWithContext ¶

func (c *CP) ListTriggersWithContext(ctx byteplus.Context, input *ListTriggersInput, opts ...request.Option) (*ListTriggersOutput, error)

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

See ListTriggers 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 (*CP) ListWorkspaces ¶

func (c *CP) ListWorkspaces(input *ListWorkspacesInput) (*ListWorkspacesOutput, error)

ListWorkspaces API operation for CP.

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

func (*CP) ListWorkspacesCommon ¶

func (c *CP) ListWorkspacesCommon(input *map[string]interface{}) (*map[string]interface{}, error)

ListWorkspacesCommon API operation for CP.

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

func (*CP) ListWorkspacesCommonRequest ¶

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

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

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

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

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

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

func (*CP) ListWorkspacesCommonWithContext ¶

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

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

See ListWorkspacesCommon 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 (*CP) ListWorkspacesRequest ¶

func (c *CP) ListWorkspacesRequest(input *ListWorkspacesInput) (req *request.Request, output *ListWorkspacesOutput)

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

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

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

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

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

func (*CP) ListWorkspacesWithContext ¶

func (c *CP) ListWorkspacesWithContext(ctx byteplus.Context, input *ListWorkspacesInput, opts ...request.Option) (*ListWorkspacesOutput, error)

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

See ListWorkspaces 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 (*CP) RunPipeline ¶

func (c *CP) RunPipeline(input *RunPipelineInput) (*RunPipelineOutput, error)

RunPipeline API operation for CP.

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

func (*CP) RunPipelineCommon ¶

func (c *CP) RunPipelineCommon(input *map[string]interface{}) (*map[string]interface{}, error)

RunPipelineCommon API operation for CP.

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

func (*CP) RunPipelineCommonRequest ¶

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

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

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

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

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

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

func (*CP) RunPipelineCommonWithContext ¶

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

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

See RunPipelineCommon 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 (*CP) RunPipelineRequest ¶

func (c *CP) RunPipelineRequest(input *RunPipelineInput) (req *request.Request, output *RunPipelineOutput)

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

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

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

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

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

func (*CP) RunPipelineWithContext ¶

func (c *CP) RunPipelineWithContext(ctx byteplus.Context, input *RunPipelineInput, opts ...request.Option) (*RunPipelineOutput, error)

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

See RunPipeline 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 (*CP) UpdateComponentStep ¶

func (c *CP) UpdateComponentStep(input *UpdateComponentStepInput) (*UpdateComponentStepOutput, error)

UpdateComponentStep API operation for CP.

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

func (*CP) UpdateComponentStepCommon ¶

func (c *CP) UpdateComponentStepCommon(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateComponentStepCommon API operation for CP.

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

func (*CP) UpdateComponentStepCommonRequest ¶

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

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

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

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

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

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

func (*CP) UpdateComponentStepCommonWithContext ¶

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

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

See UpdateComponentStepCommon 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 (*CP) UpdateComponentStepRequest ¶

func (c *CP) UpdateComponentStepRequest(input *UpdateComponentStepInput) (req *request.Request, output *UpdateComponentStepOutput)

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

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

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

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

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

func (*CP) UpdateComponentStepWithContext ¶

func (c *CP) UpdateComponentStepWithContext(ctx byteplus.Context, input *UpdateComponentStepInput, opts ...request.Option) (*UpdateComponentStepOutput, error)

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

See UpdateComponentStep 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 (*CP) UpdateResource ¶

func (c *CP) UpdateResource(input *UpdateResourceInput) (*UpdateResourceOutput, error)

UpdateResource API operation for CP.

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

func (*CP) UpdateResourceCommon ¶

func (c *CP) UpdateResourceCommon(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateResourceCommon API operation for CP.

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

func (*CP) UpdateResourceCommonRequest ¶

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

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

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

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

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

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

func (*CP) UpdateResourceCommonWithContext ¶

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

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

See UpdateResourceCommon 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 (*CP) UpdateResourceRequest ¶

func (c *CP) UpdateResourceRequest(input *UpdateResourceInput) (req *request.Request, output *UpdateResourceOutput)

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

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

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

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

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

func (*CP) UpdateResourceWithContext ¶

func (c *CP) UpdateResourceWithContext(ctx byteplus.Context, input *UpdateResourceInput, opts ...request.Option) (*UpdateResourceOutput, error)

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

See UpdateResource 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 (*CP) UpdateServiceConnection ¶

func (c *CP) UpdateServiceConnection(input *UpdateServiceConnectionInput) (*UpdateServiceConnectionOutput, error)

UpdateServiceConnection API operation for CP.

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

func (*CP) UpdateServiceConnectionCommon ¶

func (c *CP) UpdateServiceConnectionCommon(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateServiceConnectionCommon API operation for CP.

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

func (*CP) UpdateServiceConnectionCommonRequest ¶

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

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

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

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

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

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

func (*CP) UpdateServiceConnectionCommonWithContext ¶

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

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

See UpdateServiceConnectionCommon 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 (*CP) UpdateServiceConnectionRequest ¶

func (c *CP) UpdateServiceConnectionRequest(input *UpdateServiceConnectionInput) (req *request.Request, output *UpdateServiceConnectionOutput)

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

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

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

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

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

func (*CP) UpdateServiceConnectionWithContext ¶

func (c *CP) UpdateServiceConnectionWithContext(ctx byteplus.Context, input *UpdateServiceConnectionInput, opts ...request.Option) (*UpdateServiceConnectionOutput, error)

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

See UpdateServiceConnection 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 (*CP) UpdateTrigger ¶

func (c *CP) UpdateTrigger(input *UpdateTriggerInput) (*UpdateTriggerOutput, error)

UpdateTrigger API operation for CP.

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

func (*CP) UpdateTriggerCommon ¶

func (c *CP) UpdateTriggerCommon(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateTriggerCommon API operation for CP.

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

func (*CP) UpdateTriggerCommonRequest ¶

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

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

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

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

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

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

func (*CP) UpdateTriggerCommonWithContext ¶

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

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

See UpdateTriggerCommon 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 (*CP) UpdateTriggerRequest ¶

func (c *CP) UpdateTriggerRequest(input *UpdateTriggerInput) (req *request.Request, output *UpdateTriggerOutput)

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

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

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

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

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

func (*CP) UpdateTriggerWithContext ¶

func (c *CP) UpdateTriggerWithContext(ctx byteplus.Context, input *UpdateTriggerInput, opts ...request.Option) (*UpdateTriggerOutput, error)

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

See UpdateTrigger 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 (*CP) UpdateWorkspace ¶

func (c *CP) UpdateWorkspace(input *UpdateWorkspaceInput) (*UpdateWorkspaceOutput, error)

UpdateWorkspace API operation for CP.

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

func (*CP) UpdateWorkspaceCommon ¶

func (c *CP) UpdateWorkspaceCommon(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateWorkspaceCommon API operation for CP.

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

func (*CP) UpdateWorkspaceCommonRequest ¶

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

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

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

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

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

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

func (*CP) UpdateWorkspaceCommonWithContext ¶

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

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

See UpdateWorkspaceCommon 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 (*CP) UpdateWorkspaceRequest ¶

func (c *CP) UpdateWorkspaceRequest(input *UpdateWorkspaceInput) (req *request.Request, output *UpdateWorkspaceOutput)

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

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

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

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

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

func (*CP) UpdateWorkspaceWithContext ¶

func (c *CP) UpdateWorkspaceWithContext(ctx byteplus.Context, input *UpdateWorkspaceInput, opts ...request.Option) (*UpdateWorkspaceOutput, error)

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

See UpdateWorkspace 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 (*CP) UpgradeComponentStep ¶

func (c *CP) UpgradeComponentStep(input *UpgradeComponentStepInput) (*UpgradeComponentStepOutput, error)

UpgradeComponentStep API operation for CP.

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

func (*CP) UpgradeComponentStepCommon ¶

func (c *CP) UpgradeComponentStepCommon(input *map[string]interface{}) (*map[string]interface{}, error)

UpgradeComponentStepCommon API operation for CP.

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

func (*CP) UpgradeComponentStepCommonRequest ¶

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

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

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

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

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

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

func (*CP) UpgradeComponentStepCommonWithContext ¶

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

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

See UpgradeComponentStepCommon 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 (*CP) UpgradeComponentStepRequest ¶

func (c *CP) UpgradeComponentStepRequest(input *UpgradeComponentStepInput) (req *request.Request, output *UpgradeComponentStepOutput)

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

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

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

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

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

func (*CP) UpgradeComponentStepWithContext ¶

func (c *CP) UpgradeComponentStepWithContext(ctx byteplus.Context, input *UpgradeComponentStepInput, opts ...request.Option) (*UpgradeComponentStepOutput, error)

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

See UpgradeComponentStep 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 (CRForCreateTriggerInput) GoString ¶

func (s CRForCreateTriggerInput) GoString() string

GoString returns the string representation

func (*CRForCreateTriggerInput) SetFilter ¶

func (s *CRForCreateTriggerInput) SetFilter(v *FilterForCreateTriggerInput) *CRForCreateTriggerInput

SetFilter sets the Filter field's value.

func (CRForCreateTriggerInput) String ¶

func (s CRForCreateTriggerInput) String() string

String returns the string representation

func (CRForListTriggersOutput) GoString ¶

func (s CRForListTriggersOutput) GoString() string

GoString returns the string representation

func (*CRForListTriggersOutput) SetFilter ¶

func (s *CRForListTriggersOutput) SetFilter(v *FilterForListTriggersOutput) *CRForListTriggersOutput

SetFilter sets the Filter field's value.

func (CRForListTriggersOutput) String ¶

func (s CRForListTriggersOutput) String() string

String returns the string representation

func (CRForUpdateTriggerInput) GoString ¶

func (s CRForUpdateTriggerInput) GoString() string

GoString returns the string representation

func (*CRForUpdateTriggerInput) SetFilter ¶

func (s *CRForUpdateTriggerInput) SetFilter(v *FilterForUpdateTriggerInput) *CRForUpdateTriggerInput

SetFilter sets the Filter field's value.

func (CRForUpdateTriggerInput) String ¶

func (s CRForUpdateTriggerInput) String() string

String returns the string representation

func (CachForListPipelinesOutput) GoString ¶

func (s CachForListPipelinesOutput) GoString() string

GoString returns the string representation

func (*CachForListPipelinesOutput) SetDescription ¶

func (s *CachForListPipelinesOutput) SetDescription(v string) *CachForListPipelinesOutput

SetDescription sets the Description field's value.

func (*CachForListPipelinesOutput) SetKey ¶

func (s *CachForListPipelinesOutput) SetKey(v string) *CachForListPipelinesOutput

SetKey sets the Key field's value.

func (*CachForListPipelinesOutput) SetPath ¶

func (s *CachForListPipelinesOutput) SetPath(v string) *CachForListPipelinesOutput

SetPath sets the Path field's value.

func (CachForListPipelinesOutput) String ¶

func (s CachForListPipelinesOutput) String() string

String returns the string representation

func (CancelPipelineRunInput) GoString ¶

func (s CancelPipelineRunInput) GoString() string

GoString returns the string representation

func (*CancelPipelineRunInput) SetId ¶

func (s *CancelPipelineRunInput) SetId(v string) *CancelPipelineRunInput

SetId sets the Id field's value.

func (*CancelPipelineRunInput) SetPipelineId ¶

func (s *CancelPipelineRunInput) SetPipelineId(v string) *CancelPipelineRunInput

SetPipelineId sets the PipelineId field's value.

func (*CancelPipelineRunInput) SetWorkspaceId ¶

func (s *CancelPipelineRunInput) SetWorkspaceId(v string) *CancelPipelineRunInput

SetWorkspaceId sets the WorkspaceId field's value.

func (CancelPipelineRunInput) String ¶

func (s CancelPipelineRunInput) String() string

String returns the string representation

func (*CancelPipelineRunInput) Validate ¶

func (s *CancelPipelineRunInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

func (CancelPipelineRunOutput) GoString ¶

func (s CancelPipelineRunOutput) GoString() string

GoString returns the string representation

func (CancelPipelineRunOutput) String ¶

func (s CancelPipelineRunOutput) String() string

String returns the string representation

func (ConfigForCreateTriggerInput) GoString ¶

func (s ConfigForCreateTriggerInput) GoString() string

GoString returns the string representation

func (*ConfigForCreateTriggerInput) SetReferences ¶

func (s *ConfigForCreateTriggerInput) SetReferences(v []*string) *ConfigForCreateTriggerInput

SetReferences sets the References field's value.

func (ConfigForCreateTriggerInput) String ¶

func (s ConfigForCreateTriggerInput) String() string

String returns the string representation

func (ConfigForListTriggersOutput) GoString ¶

func (s ConfigForListTriggersOutput) GoString() string

GoString returns the string representation

func (*ConfigForListTriggersOutput) SetReferences ¶

func (s *ConfigForListTriggersOutput) SetReferences(v []*string) *ConfigForListTriggersOutput

SetReferences sets the References field's value.

func (ConfigForListTriggersOutput) String ¶

func (s ConfigForListTriggersOutput) String() string

String returns the string representation

func (ConfigForUpdateTriggerInput) GoString ¶

func (s ConfigForUpdateTriggerInput) GoString() string

GoString returns the string representation

func (*ConfigForUpdateTriggerInput) SetReferences ¶

func (s *ConfigForUpdateTriggerInput) SetReferences(v []*string) *ConfigForUpdateTriggerInput

SetReferences sets the References field's value.

func (ConfigForUpdateTriggerInput) String ¶

func (s ConfigForUpdateTriggerInput) String() string

String returns the string representation

func (ConfigurationForCreateResourceInput) GoString ¶

func (s ConfigurationForCreateResourceInput) GoString() string

GoString returns the string representation

func (*ConfigurationForCreateResourceInput) SetGit ¶

func (s *ConfigurationForCreateResourceInput) SetGit(v *GitForCreateResourceInput) *ConfigurationForCreateResourceInput

SetGit sets the Git field's value.

func (ConfigurationForCreateResourceInput) String ¶

func (s ConfigurationForCreateResourceInput) String() string

String returns the string representation

func (ConfigurationForCreateTriggerInput) GoString ¶

func (s ConfigurationForCreateTriggerInput) GoString() string

GoString returns the string representation

func (*ConfigurationForCreateTriggerInput) SetSchedule ¶

func (s *ConfigurationForCreateTriggerInput) SetSchedule(v *ScheduleForCreateTriggerInput) *ConfigurationForCreateTriggerInput

SetSchedule sets the Schedule field's value.

func (*ConfigurationForCreateTriggerInput) SetWebhook ¶

func (s *ConfigurationForCreateTriggerInput) SetWebhook(v *WebhookForCreateTriggerInput) *ConfigurationForCreateTriggerInput

SetWebhook sets the Webhook field's value.

func (ConfigurationForCreateTriggerInput) String ¶

func (s ConfigurationForCreateTriggerInput) String() string

String returns the string representation

func (ConfigurationForListPipelineRunsOutput) GoString ¶

func (s ConfigurationForListPipelineRunsOutput) GoString() string

GoString returns the string representation

func (*ConfigurationForListPipelineRunsOutput) SetGitResource ¶

func (s *ConfigurationForListPipelineRunsOutput) SetGitResource(v *GitResourceForListPipelineRunsOutput) *ConfigurationForListPipelineRunsOutput

SetGitResource sets the GitResource field's value.

func (ConfigurationForListPipelineRunsOutput) String ¶

func (s ConfigurationForListPipelineRunsOutput) String() string

String returns the string representation

func (ConfigurationForListPipelinesOutput) GoString ¶

func (s ConfigurationForListPipelinesOutput) GoString() string

GoString returns the string representation

func (*ConfigurationForListPipelinesOutput) SetGit ¶

func (s *ConfigurationForListPipelinesOutput) SetGit(v *GitForListPipelinesOutput) *ConfigurationForListPipelinesOutput

SetGit sets the Git field's value.

func (ConfigurationForListPipelinesOutput) String ¶

func (s ConfigurationForListPipelinesOutput) String() string

String returns the string representation

func (ConfigurationForListResourcesOutput) GoString ¶

func (s ConfigurationForListResourcesOutput) GoString() string

GoString returns the string representation

func (*ConfigurationForListResourcesOutput) SetGit ¶

func (s *ConfigurationForListResourcesOutput) SetGit(v *GitForListResourcesOutput) *ConfigurationForListResourcesOutput

SetGit sets the Git field's value.

func (ConfigurationForListResourcesOutput) String ¶

func (s ConfigurationForListResourcesOutput) String() string

String returns the string representation

func (ConfigurationForListTriggersOutput) GoString ¶

func (s ConfigurationForListTriggersOutput) GoString() string

GoString returns the string representation

func (*ConfigurationForListTriggersOutput) SetSchedule ¶

func (s *ConfigurationForListTriggersOutput) SetSchedule(v *ScheduleForListTriggersOutput) *ConfigurationForListTriggersOutput

SetSchedule sets the Schedule field's value.

func (*ConfigurationForListTriggersOutput) SetWebhook ¶

func (s *ConfigurationForListTriggersOutput) SetWebhook(v *WebhookForListTriggersOutput) *ConfigurationForListTriggersOutput

SetWebhook sets the Webhook field's value.

func (ConfigurationForListTriggersOutput) String ¶

func (s ConfigurationForListTriggersOutput) String() string

String returns the string representation

func (ConfigurationForUpdateResourceInput) GoString ¶

func (s ConfigurationForUpdateResourceInput) GoString() string

GoString returns the string representation

func (*ConfigurationForUpdateResourceInput) SetGit ¶

func (s *ConfigurationForUpdateResourceInput) SetGit(v *GitForUpdateResourceInput) *ConfigurationForUpdateResourceInput

SetGit sets the Git field's value.

func (ConfigurationForUpdateResourceInput) String ¶

func (s ConfigurationForUpdateResourceInput) String() string

String returns the string representation

func (ConfigurationForUpdateTriggerInput) GoString ¶

func (s ConfigurationForUpdateTriggerInput) GoString() string

GoString returns the string representation