kcrs

package

v0.4.0 Latest Latest Go to latest Published: Apr 15, 2024 License: Apache-2.0 Imports: 9 Imported by: 0

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/KscSDK/ksc-sdk-go

Links

Open Source Insights

Documentation ¶

Constants ¶

View Source

const (
	ServiceName = "kcrs"      // Name of service.
	EndpointsID = ServiceName // ID to lookup a service endpoint with.
	ServiceID   = "kcrs"      // ServiceID is a unique identifer of a specific service.
)

Service information constants

Variables ¶

This section is empty.

Functions ¶

This section is empty.

Types ¶

type Kcrs ¶

type Kcrs struct {
	*client.Client
}

Kcrs provides the API operation methods for making requests to kcrs. See this package's package overview docs for details on the service.

Kcrs methods are safe to use concurrently. It is not safe to modify mutate any of the struct's properties though.

func ExtraNew ¶

func ExtraNew(info *utils.UrlInfo, p client.ConfigProvider, cfgs ...*aws.Config) *Kcrs

extraNew create int can support ssl or region locate set

func New ¶

func New(p client.ConfigProvider, cfgs ...*aws.Config) *Kcrs

New creates a new instance of the Kcrs client with a session. If additional configuration is needed for the client instance use the optional ksc.Config parameter to add your extra config.

Example:

// Create a Kcrs client from just a session.
svc := kcrs.New(mySession)

// Create a Kcrs client with additional configuration
svc := kcrs.New(mySession, aws.NewConfig().WithRegion("us-west-2"))

func SdkNew ¶

func SdkNew(p client.ConfigProvider, cfgs *ksc.Config, info ...*utils.UrlInfo) *Kcrs

SdkNew create int can support ssl or region locate set

func (*Kcrs) CloseExternalEndpoint ¶ added in v0.3.0

func (c *Kcrs) CloseExternalEndpoint(input *map[string]interface{}) (*map[string]interface{}, error)

CloseExternalEndpoint API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation CloseExternalEndpoint for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/CloseExternalEndpoint

func (*Kcrs) CloseExternalEndpointRequest ¶ added in v0.3.0

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) CloseExternalEndpointWithContext ¶ added in v0.3.0

func (c *Kcrs) CloseExternalEndpointWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CloseExternalEndpoint 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 (*Kcrs) CreateExternalEndpointPolicy ¶ added in v0.3.0

func (c *Kcrs) CreateExternalEndpointPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

CreateExternalEndpointPolicy API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation CreateExternalEndpointPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/CreateExternalEndpointPolicy

func (*Kcrs) CreateExternalEndpointPolicyRequest ¶ added in v0.3.0

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) CreateExternalEndpointPolicyWithContext ¶ added in v0.3.0

func (c *Kcrs) CreateExternalEndpointPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateExternalEndpointPolicy 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 (*Kcrs) CreateInstance ¶

func (c *Kcrs) CreateInstance(input *map[string]interface{}) (*map[string]interface{}, error)

CreateInstance API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation CreateInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/CreateInstance

func (*Kcrs) CreateInstanceRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) CreateInstanceToken ¶

func (c *Kcrs) CreateInstanceToken(input *map[string]interface{}) (*map[string]interface{}, error)

CreateInstanceToken API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation CreateInstanceToken for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/CreateInstanceToken

func (*Kcrs) CreateInstanceTokenRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) CreateInstanceTokenWithContext ¶

func (c *Kcrs) CreateInstanceTokenWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateInstanceToken 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 (*Kcrs) CreateInstanceWithContext ¶

func (c *Kcrs) CreateInstanceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateInstance 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 (*Kcrs) CreateInternalEndpoint ¶

func (c *Kcrs) CreateInternalEndpoint(input *map[string]interface{}) (*map[string]interface{}, error)

CreateInternalEndpoint API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation CreateInternalEndpoint for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/CreateInternalEndpoint

func (*Kcrs) CreateInternalEndpointDns ¶

func (c *Kcrs) CreateInternalEndpointDns(input *map[string]interface{}) (*map[string]interface{}, error)

CreateInternalEndpointDns API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation CreateInternalEndpointDns for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/CreateInternalEndpointDns

func (*Kcrs) CreateInternalEndpointDnsRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) CreateInternalEndpointDnsWithContext ¶

func (c *Kcrs) CreateInternalEndpointDnsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateInternalEndpointDns 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 (*Kcrs) CreateInternalEndpointRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) CreateInternalEndpointWithContext ¶

func (c *Kcrs) CreateInternalEndpointWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateInternalEndpoint 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 (*Kcrs) CreateNamespace ¶

func (c *Kcrs) CreateNamespace(input *map[string]interface{}) (*map[string]interface{}, error)

CreateNamespace API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation CreateNamespace for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/CreateNamespace

func (*Kcrs) CreateNamespaceRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) CreateNamespaceWithContext ¶

func (c *Kcrs) CreateNamespaceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateNamespace 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 (*Kcrs) CreateRetentionRule ¶ added in v0.3.0

func (c *Kcrs) CreateRetentionRule(input *map[string]interface{}) (*map[string]interface{}, error)

CreateRetentionRule API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation CreateRetentionRule for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/CreateRetentionRule

func (*Kcrs) CreateRetentionRuleRequest ¶ added in v0.3.0

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) CreateRetentionRuleWithContext ¶ added in v0.3.0

func (c *Kcrs) CreateRetentionRuleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateRetentionRule 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 (*Kcrs) CreateWebhookTrigger ¶

func (c *Kcrs) CreateWebhookTrigger(input *map[string]interface{}) (*map[string]interface{}, error)

CreateWebhookTrigger API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation CreateWebhookTrigger for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/CreateWebhookTrigger

func (*Kcrs) CreateWebhookTriggerRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) CreateWebhookTriggerWithContext ¶

func (c *Kcrs) CreateWebhookTriggerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See CreateWebhookTrigger 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 (*Kcrs) DeleteExternalEndpointPolicy ¶ added in v0.3.0

func (c *Kcrs) DeleteExternalEndpointPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteExternalEndpointPolicy API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DeleteExternalEndpointPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DeleteExternalEndpointPolicy

func (*Kcrs) DeleteExternalEndpointPolicyRequest ¶ added in v0.3.0

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DeleteExternalEndpointPolicyWithContext ¶ added in v0.3.0

func (c *Kcrs) DeleteExternalEndpointPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteExternalEndpointPolicy 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 (*Kcrs) DeleteImages ¶

func (c *Kcrs) DeleteImages(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteImages API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DeleteImages for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DeleteImages

func (*Kcrs) DeleteImagesRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DeleteImagesWithContext ¶

func (c *Kcrs) DeleteImagesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteImages 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 (*Kcrs) DeleteInstance ¶

func (c *Kcrs) DeleteInstance(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteInstance API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DeleteInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DeleteInstance

func (*Kcrs) DeleteInstanceRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DeleteInstanceToken ¶

func (c *Kcrs) DeleteInstanceToken(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteInstanceToken API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DeleteInstanceToken for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DeleteInstanceToken

func (*Kcrs) DeleteInstanceTokenRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DeleteInstanceTokenWithContext ¶

func (c *Kcrs) DeleteInstanceTokenWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteInstanceToken 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 (*Kcrs) DeleteInstanceWithContext ¶

func (c *Kcrs) DeleteInstanceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteInstance 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 (*Kcrs) DeleteInternalEndpoint ¶

func (c *Kcrs) DeleteInternalEndpoint(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteInternalEndpoint API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DeleteInternalEndpoint for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DeleteInternalEndpoint

func (*Kcrs) DeleteInternalEndpointDns ¶

func (c *Kcrs) DeleteInternalEndpointDns(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteInternalEndpointDns API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DeleteInternalEndpointDns for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DeleteInternalEndpointDns

func (*Kcrs) DeleteInternalEndpointDnsRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DeleteInternalEndpointDnsWithContext ¶

func (c *Kcrs) DeleteInternalEndpointDnsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteInternalEndpointDns 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 (*Kcrs) DeleteInternalEndpointRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DeleteInternalEndpointWithContext ¶

func (c *Kcrs) DeleteInternalEndpointWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteInternalEndpoint 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 (*Kcrs) DeleteNamespace ¶

func (c *Kcrs) DeleteNamespace(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteNamespace API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DeleteNamespace for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DeleteNamespace

func (*Kcrs) DeleteNamespaceRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DeleteNamespaceWithContext ¶

func (c *Kcrs) DeleteNamespaceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteNamespace 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 (*Kcrs) DeleteRepoTag ¶

func (c *Kcrs) DeleteRepoTag(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteRepoTag API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DeleteRepoTag for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DeleteRepoTag

func (*Kcrs) DeleteRepoTagRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DeleteRepoTagWithContext ¶

func (c *Kcrs) DeleteRepoTagWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteRepoTag 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 (*Kcrs) DeleteRepository ¶

func (c *Kcrs) DeleteRepository(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteRepository API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DeleteRepository for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DeleteRepository

func (*Kcrs) DeleteRepositoryRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DeleteRepositoryWithContext ¶

func (c *Kcrs) DeleteRepositoryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteRepository 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 (*Kcrs) DeleteRetentionRule ¶ added in v0.3.0

func (c *Kcrs) DeleteRetentionRule(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteRetentionRule API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DeleteRetentionRule for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DeleteRetentionRule

func (*Kcrs) DeleteRetentionRuleRequest ¶ added in v0.3.0

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DeleteRetentionRuleWithContext ¶ added in v0.3.0

func (c *Kcrs) DeleteRetentionRuleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteRetentionRule 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 (*Kcrs) DeleteWebhookTrigger ¶

func (c *Kcrs) DeleteWebhookTrigger(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteWebhookTrigger API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DeleteWebhookTrigger for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DeleteWebhookTrigger

func (*Kcrs) DeleteWebhookTriggerRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DeleteWebhookTriggerWithContext ¶

func (c *Kcrs) DeleteWebhookTriggerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DeleteWebhookTrigger 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 (*Kcrs) DescribeExternalEndpoint ¶ added in v0.3.0

func (c *Kcrs) DescribeExternalEndpoint(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeExternalEndpoint API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DescribeExternalEndpoint for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DescribeExternalEndpoint

func (*Kcrs) DescribeExternalEndpointRequest ¶ added in v0.3.0

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DescribeExternalEndpointWithContext ¶ added in v0.3.0

func (c *Kcrs) DescribeExternalEndpointWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DescribeExternalEndpoint 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 (*Kcrs) DescribeImageScan ¶

func (c *Kcrs) DescribeImageScan(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeImageScan API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DescribeImageScan for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DescribeImageScan

func (*Kcrs) DescribeImageScanRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DescribeImageScanWithContext ¶

func (c *Kcrs) DescribeImageScanWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DescribeImageScan 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 (*Kcrs) DescribeImages ¶

func (c *Kcrs) DescribeImages(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeImages API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DescribeImages for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DescribeImages

func (*Kcrs) DescribeImagesRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DescribeImagesWithContext ¶

func (c *Kcrs) DescribeImagesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DescribeImages 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 (*Kcrs) DescribeInstance ¶

func (c *Kcrs) DescribeInstance(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeInstance API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DescribeInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DescribeInstance

func (*Kcrs) DescribeInstanceRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DescribeInstanceToken ¶

func (c *Kcrs) DescribeInstanceToken(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeInstanceToken API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DescribeInstanceToken for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DescribeInstanceToken

func (*Kcrs) DescribeInstanceTokenRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DescribeInstanceTokenWithContext ¶

func (c *Kcrs) DescribeInstanceTokenWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DescribeInstanceToken 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 (*Kcrs) DescribeInstanceUsage ¶

func (c *Kcrs) DescribeInstanceUsage(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeInstanceUsage API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DescribeInstanceUsage for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DescribeInstanceUsage

func (*Kcrs) DescribeInstanceUsageRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DescribeInstanceUsageWithContext ¶

func (c *Kcrs) DescribeInstanceUsageWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DescribeInstanceUsage 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 (*Kcrs) DescribeInstanceWithContext ¶

func (c *Kcrs) DescribeInstanceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DescribeInstance 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 (*Kcrs) DescribeInternalEndpoint ¶

func (c *Kcrs) DescribeInternalEndpoint(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeInternalEndpoint API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DescribeInternalEndpoint for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DescribeInternalEndpoint

func (*Kcrs) DescribeInternalEndpointDns ¶

func (c *Kcrs) DescribeInternalEndpointDns(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeInternalEndpointDns API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DescribeInternalEndpointDns for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DescribeInternalEndpointDns

func (*Kcrs) DescribeInternalEndpointDnsRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DescribeInternalEndpointDnsWithContext ¶

func (c *Kcrs) DescribeInternalEndpointDnsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DescribeInternalEndpointDns 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 (*Kcrs) DescribeInternalEndpointRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DescribeInternalEndpointWithContext ¶

func (c *Kcrs) DescribeInternalEndpointWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DescribeInternalEndpoint 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 (*Kcrs) DescribeNamespace ¶

func (c *Kcrs) DescribeNamespace(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeNamespace API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DescribeNamespace for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DescribeNamespace

func (*Kcrs) DescribeNamespaceRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DescribeNamespaceWithContext ¶

func (c *Kcrs) DescribeNamespaceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DescribeNamespace 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 (*Kcrs) DescribeRepository ¶

func (c *Kcrs) DescribeRepository(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeRepository API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DescribeRepository for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DescribeRepository

func (*Kcrs) DescribeRepositoryRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DescribeRepositoryWithContext ¶

func (c *Kcrs) DescribeRepositoryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DescribeRepository 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 (*Kcrs) DescribeRetentionRule ¶ added in v0.3.0

func (c *Kcrs) DescribeRetentionRule(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeRetentionRule API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DescribeRetentionRule for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DescribeRetentionRule

func (*Kcrs) DescribeRetentionRuleRequest ¶ added in v0.3.0

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DescribeRetentionRuleWithContext ¶ added in v0.3.0

func (c *Kcrs) DescribeRetentionRuleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DescribeRetentionRule 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 (*Kcrs) DescribeWebhookTrigger ¶

func (c *Kcrs) DescribeWebhookTrigger(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeWebhookTrigger API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation DescribeWebhookTrigger for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/DescribeWebhookTrigger

func (*Kcrs) DescribeWebhookTriggerRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) DescribeWebhookTriggerWithContext ¶

func (c *Kcrs) DescribeWebhookTriggerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See DescribeWebhookTrigger 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 (*Kcrs) ModifyInstanceTokenInformation ¶

func (c *Kcrs) ModifyInstanceTokenInformation(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyInstanceTokenInformation API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation ModifyInstanceTokenInformation for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/ModifyInstanceTokenInformation

func (*Kcrs) ModifyInstanceTokenInformationRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) ModifyInstanceTokenInformationWithContext ¶

func (c *Kcrs) ModifyInstanceTokenInformationWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See ModifyInstanceTokenInformation 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 (*Kcrs) ModifyInstanceTokenStatus ¶

func (c *Kcrs) ModifyInstanceTokenStatus(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyInstanceTokenStatus API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation ModifyInstanceTokenStatus for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/ModifyInstanceTokenStatus

func (*Kcrs) ModifyInstanceTokenStatusRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) ModifyInstanceTokenStatusWithContext ¶

func (c *Kcrs) ModifyInstanceTokenStatusWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See ModifyInstanceTokenStatus 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 (*Kcrs) ModifyNamespaceType ¶

func (c *Kcrs) ModifyNamespaceType(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyNamespaceType API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation ModifyNamespaceType for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/ModifyNamespaceType

func (*Kcrs) ModifyNamespaceTypeRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) ModifyNamespaceTypeWithContext ¶

func (c *Kcrs) ModifyNamespaceTypeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See ModifyNamespaceType 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 (*Kcrs) ModifyRepoDesc ¶

func (c *Kcrs) ModifyRepoDesc(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyRepoDesc API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation ModifyRepoDesc for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/ModifyRepoDesc

func (*Kcrs) ModifyRepoDescRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) ModifyRepoDescWithContext ¶

func (c *Kcrs) ModifyRepoDescWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See ModifyRepoDesc 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 (*Kcrs) ModifyWebhookTrigger ¶

func (c *Kcrs) ModifyWebhookTrigger(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyWebhookTrigger API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation ModifyWebhookTrigger for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/ModifyWebhookTrigger

func (*Kcrs) ModifyWebhookTriggerRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) ModifyWebhookTriggerWithContext ¶

func (c *Kcrs) ModifyWebhookTriggerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See ModifyWebhookTrigger 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 (*Kcrs) OpenExternalEndpoint ¶ added in v0.3.0

func (c *Kcrs) OpenExternalEndpoint(input *map[string]interface{}) (*map[string]interface{}, error)

OpenExternalEndpoint API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation OpenExternalEndpoint for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/OpenExternalEndpoint

func (*Kcrs) OpenExternalEndpointRequest ¶ added in v0.3.0

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) OpenExternalEndpointWithContext ¶ added in v0.3.0

func (c *Kcrs) OpenExternalEndpointWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See OpenExternalEndpoint 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 (*Kcrs) RunRetentionPolicy ¶ added in v0.3.0

func (c *Kcrs) RunRetentionPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

RunRetentionPolicy API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation RunRetentionPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/RunRetentionPolicy

func (*Kcrs) RunRetentionPolicyRequest ¶ added in v0.3.0

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) RunRetentionPolicyWithContext ¶ added in v0.3.0

func (c *Kcrs) RunRetentionPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See RunRetentionPolicy 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 (*Kcrs) StartImageScan ¶

func (c *Kcrs) StartImageScan(input *map[string]interface{}) (*map[string]interface{}, error)

StartImageScan API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation StartImageScan for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/StartImageScan

func (*Kcrs) StartImageScanRequest ¶

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) StartImageScanWithContext ¶

func (c *Kcrs) StartImageScanWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See StartImageScan 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 (*Kcrs) UpdateExternalEndpointPolicy ¶ added in v0.3.0

func (c *Kcrs) UpdateExternalEndpointPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateExternalEndpointPolicy API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation UpdateExternalEndpointPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/UpdateExternalEndpointPolicy

func (*Kcrs) UpdateExternalEndpointPolicyRequest ¶ added in v0.3.0

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) UpdateExternalEndpointPolicyWithContext ¶ added in v0.3.0

func (c *Kcrs) UpdateExternalEndpointPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See UpdateExternalEndpointPolicy 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 (*Kcrs) UpdateRetentionRule ¶ added in v0.3.0

func (c *Kcrs) UpdateRetentionRule(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateRetentionRule API operation for kcrs.

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

See the KSC API reference guide for kcrs's API operation UpdateRetentionRule for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcrs-2021-11-09/UpdateRetentionRule

func (*Kcrs) UpdateRetentionRuleRequest ¶ added in v0.3.0

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

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

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

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

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

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

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

func (*Kcrs) UpdateRetentionRuleWithContext ¶ added in v0.3.0

func (c *Kcrs) UpdateRetentionRuleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

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

See UpdateRetentionRule 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.

Source Files ¶

View all Source files

Directories ¶

Path	Synopsis
kcrsiface Package kcrsiface provides an interface to enable mocking the kcrs service client for testing your code.	Package kcrsiface provides an interface to enable mocking the kcrs service client for testing your code.

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL