kcsv1

package

v1.0.3 Latest Latest Go to latest Published: Feb 20, 2025 License: Apache-2.0 Imports: 8 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/gexue/galaxy-sdk-go-test

Documentation ¶

Index ¶

Constants
type Kcsv1

Constants ¶

View Source

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

Service information constants

Variables ¶

This section is empty.

Functions ¶

This section is empty.

Types ¶

type Kcsv1 ¶

type Kcsv1 struct {
	*client.Client
}

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

Kcsv1 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) *Kcsv1

extraNew create int can support ssl or region locate set

func New ¶

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

New creates a new instance of the Kcsv1 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 Kcsv1 client from just a session.
svc := kcsv1.New(mySession)

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

func SdkNew ¶

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

SdkNew create int can support ssl or region locate set

func (*Kcsv1) CreateCacheCluster ¶

func (c *Kcsv1) CreateCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)

CreateCacheCluster API operation for kcsv1.

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 kcsv1's API operation CreateCacheCluster for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/CreateCacheCluster

func (*Kcsv1) CreateCacheClusterRequest ¶

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

CreateCacheClusterRequest generates a "ksc/request.Request" representing the client's request for the CreateCacheCluster 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 CreateCacheCluster for more information on using the CreateCacheCluster 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 CreateCacheClusterRequest method.
req, resp := client.CreateCacheClusterRequest(params)

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

func (*Kcsv1) CreateCacheClusterWithContext ¶

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

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

See CreateCacheCluster 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 (*Kcsv1) CreateCacheParameterGroup ¶

func (c *Kcsv1) CreateCacheParameterGroup(input *map[string]interface{}) (*map[string]interface{}, error)

CreateCacheParameterGroup API operation for kcsv1.

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 kcsv1's API operation CreateCacheParameterGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/CreateCacheParameterGroup

func (*Kcsv1) CreateCacheParameterGroupRequest ¶

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

CreateCacheParameterGroupRequest generates a "ksc/request.Request" representing the client's request for the CreateCacheParameterGroup 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 CreateCacheParameterGroup for more information on using the CreateCacheParameterGroup 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 CreateCacheParameterGroupRequest method.
req, resp := client.CreateCacheParameterGroupRequest(params)

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

func (*Kcsv1) CreateCacheParameterGroupWithContext ¶

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

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

See CreateCacheParameterGroup 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 (*Kcsv1) CreateCacheSecurityGroup ¶

func (c *Kcsv1) CreateCacheSecurityGroup(input *map[string]interface{}) (*map[string]interface{}, error)

CreateCacheSecurityGroup API operation for kcsv1.

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 kcsv1's API operation CreateCacheSecurityGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/CreateCacheSecurityGroup

func (*Kcsv1) CreateCacheSecurityGroupRequest ¶

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

CreateCacheSecurityGroupRequest generates a "ksc/request.Request" representing the client's request for the CreateCacheSecurityGroup 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 CreateCacheSecurityGroup for more information on using the CreateCacheSecurityGroup 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 CreateCacheSecurityGroupRequest method.
req, resp := client.CreateCacheSecurityGroupRequest(params)

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

func (*Kcsv1) CreateCacheSecurityGroupWithContext ¶

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

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

See CreateCacheSecurityGroup 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 (*Kcsv1) CreateSnapshot ¶

func (c *Kcsv1) CreateSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)

CreateSnapshot API operation for kcsv1.

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 kcsv1's API operation CreateSnapshot for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/CreateSnapshot

func (*Kcsv1) CreateSnapshotRequest ¶

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

CreateSnapshotRequest generates a "ksc/request.Request" representing the client's request for the CreateSnapshot 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 CreateSnapshot for more information on using the CreateSnapshot 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 CreateSnapshotRequest method.
req, resp := client.CreateSnapshotRequest(params)

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

func (*Kcsv1) CreateSnapshotWithContext ¶

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

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

See CreateSnapshot 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 (*Kcsv1) DeleteCacheCluster ¶

func (c *Kcsv1) DeleteCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteCacheCluster API operation for kcsv1.

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 kcsv1's API operation DeleteCacheCluster for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DeleteCacheCluster

func (*Kcsv1) DeleteCacheClusterRequest ¶

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

DeleteCacheClusterRequest generates a "ksc/request.Request" representing the client's request for the DeleteCacheCluster 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 DeleteCacheCluster for more information on using the DeleteCacheCluster 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 DeleteCacheClusterRequest method.
req, resp := client.DeleteCacheClusterRequest(params)

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

func (*Kcsv1) DeleteCacheClusterWithContext ¶

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

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

See DeleteCacheCluster 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 (*Kcsv1) DeleteCacheParameterGroup ¶

func (c *Kcsv1) DeleteCacheParameterGroup(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteCacheParameterGroup API operation for kcsv1.

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 kcsv1's API operation DeleteCacheParameterGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DeleteCacheParameterGroup

func (*Kcsv1) DeleteCacheParameterGroupRequest ¶

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

DeleteCacheParameterGroupRequest generates a "ksc/request.Request" representing the client's request for the DeleteCacheParameterGroup 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 DeleteCacheParameterGroup for more information on using the DeleteCacheParameterGroup 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 DeleteCacheParameterGroupRequest method.
req, resp := client.DeleteCacheParameterGroupRequest(params)

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

func (*Kcsv1) DeleteCacheParameterGroupWithContext ¶

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

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

See DeleteCacheParameterGroup 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 (*Kcsv1) DeleteCacheSecurityGroup ¶

func (c *Kcsv1) DeleteCacheSecurityGroup(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteCacheSecurityGroup API operation for kcsv1.

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 kcsv1's API operation DeleteCacheSecurityGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DeleteCacheSecurityGroup

func (*Kcsv1) DeleteCacheSecurityGroupRequest ¶

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

DeleteCacheSecurityGroupRequest generates a "ksc/request.Request" representing the client's request for the DeleteCacheSecurityGroup 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 DeleteCacheSecurityGroup for more information on using the DeleteCacheSecurityGroup 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 DeleteCacheSecurityGroupRequest method.
req, resp := client.DeleteCacheSecurityGroupRequest(params)

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

func (*Kcsv1) DeleteCacheSecurityGroupRule ¶

func (c *Kcsv1) DeleteCacheSecurityGroupRule(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteCacheSecurityGroupRule API operation for kcsv1.

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 kcsv1's API operation DeleteCacheSecurityGroupRule for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DeleteCacheSecurityGroupRule

func (*Kcsv1) DeleteCacheSecurityGroupRuleRequest ¶

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

DeleteCacheSecurityGroupRuleRequest generates a "ksc/request.Request" representing the client's request for the DeleteCacheSecurityGroupRule 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 DeleteCacheSecurityGroupRule for more information on using the DeleteCacheSecurityGroupRule 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 DeleteCacheSecurityGroupRuleRequest method.
req, resp := client.DeleteCacheSecurityGroupRuleRequest(params)

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

func (*Kcsv1) DeleteCacheSecurityGroupRuleWithContext ¶

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

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

See DeleteCacheSecurityGroupRule 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 (*Kcsv1) DeleteCacheSecurityGroupWithContext ¶

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

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

See DeleteCacheSecurityGroup 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 (*Kcsv1) DeleteCacheSecurityRule ¶

func (c *Kcsv1) DeleteCacheSecurityRule(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteCacheSecurityRule API operation for kcsv1.

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 kcsv1's API operation DeleteCacheSecurityRule for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DeleteCacheSecurityRule

func (*Kcsv1) DeleteCacheSecurityRuleRequest ¶

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

DeleteCacheSecurityRuleRequest generates a "ksc/request.Request" representing the client's request for the DeleteCacheSecurityRule 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 DeleteCacheSecurityRule for more information on using the DeleteCacheSecurityRule 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 DeleteCacheSecurityRuleRequest method.
req, resp := client.DeleteCacheSecurityRuleRequest(params)

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

func (*Kcsv1) DeleteCacheSecurityRuleWithContext ¶

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

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

See DeleteCacheSecurityRule 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 (*Kcsv1) DeleteSnapshot ¶

func (c *Kcsv1) DeleteSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteSnapshot API operation for kcsv1.

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 kcsv1's API operation DeleteSnapshot for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DeleteSnapshot

func (*Kcsv1) DeleteSnapshotRequest ¶

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

DeleteSnapshotRequest generates a "ksc/request.Request" representing the client's request for the DeleteSnapshot 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 DeleteSnapshot for more information on using the DeleteSnapshot 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 DeleteSnapshotRequest method.
req, resp := client.DeleteSnapshotRequest(params)

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

func (*Kcsv1) DeleteSnapshotWithContext ¶

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

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

See DeleteSnapshot 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 (*Kcsv1) DescribeAvailabilityZones ¶

func (c *Kcsv1) DescribeAvailabilityZones(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeAvailabilityZones API operation for kcsv1.

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 kcsv1's API operation DescribeAvailabilityZones for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeAvailabilityZones

func (*Kcsv1) DescribeAvailabilityZonesRequest ¶

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

DescribeAvailabilityZonesRequest generates a "ksc/request.Request" representing the client's request for the DescribeAvailabilityZones 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 DescribeAvailabilityZones for more information on using the DescribeAvailabilityZones 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 DescribeAvailabilityZonesRequest method.
req, resp := client.DescribeAvailabilityZonesRequest(params)

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

func (*Kcsv1) DescribeAvailabilityZonesWithContext ¶

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

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

See DescribeAvailabilityZones 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 (*Kcsv1) DescribeCacheCluster ¶

func (c *Kcsv1) DescribeCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeCacheCluster API operation for kcsv1.

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 kcsv1's API operation DescribeCacheCluster for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeCacheCluster

func (*Kcsv1) DescribeCacheClusterRequest ¶

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

DescribeCacheClusterRequest generates a "ksc/request.Request" representing the client's request for the DescribeCacheCluster 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 DescribeCacheCluster for more information on using the DescribeCacheCluster 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 DescribeCacheClusterRequest method.
req, resp := client.DescribeCacheClusterRequest(params)

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

func (*Kcsv1) DescribeCacheClusterWithContext ¶

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

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

See DescribeCacheCluster 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 (*Kcsv1) DescribeCacheClusters ¶

func (c *Kcsv1) DescribeCacheClusters(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeCacheClusters API operation for kcsv1.

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 kcsv1's API operation DescribeCacheClusters for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeCacheClusters

func (*Kcsv1) DescribeCacheClustersRequest ¶

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

DescribeCacheClustersRequest generates a "ksc/request.Request" representing the client's request for the DescribeCacheClusters 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 DescribeCacheClusters for more information on using the DescribeCacheClusters 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 DescribeCacheClustersRequest method.
req, resp := client.DescribeCacheClustersRequest(params)

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

func (*Kcsv1) DescribeCacheClustersWithContext ¶

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

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

See DescribeCacheClusters 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 (*Kcsv1) DescribeCacheDefaultParameters ¶

func (c *Kcsv1) DescribeCacheDefaultParameters(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeCacheDefaultParameters API operation for kcsv1.

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 kcsv1's API operation DescribeCacheDefaultParameters for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeCacheDefaultParameters

func (*Kcsv1) DescribeCacheDefaultParametersRequest ¶

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

DescribeCacheDefaultParametersRequest generates a "ksc/request.Request" representing the client's request for the DescribeCacheDefaultParameters 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 DescribeCacheDefaultParameters for more information on using the DescribeCacheDefaultParameters 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 DescribeCacheDefaultParametersRequest method.
req, resp := client.DescribeCacheDefaultParametersRequest(params)

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

func (*Kcsv1) DescribeCacheDefaultParametersWithContext ¶

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

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

See DescribeCacheDefaultParameters 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 (*Kcsv1) DescribeCacheParameterGroup ¶

func (c *Kcsv1) DescribeCacheParameterGroup(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeCacheParameterGroup API operation for kcsv1.

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 kcsv1's API operation DescribeCacheParameterGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeCacheParameterGroup

func (*Kcsv1) DescribeCacheParameterGroupRequest ¶

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

DescribeCacheParameterGroupRequest generates a "ksc/request.Request" representing the client's request for the DescribeCacheParameterGroup 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 DescribeCacheParameterGroup for more information on using the DescribeCacheParameterGroup 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 DescribeCacheParameterGroupRequest method.
req, resp := client.DescribeCacheParameterGroupRequest(params)

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

func (*Kcsv1) DescribeCacheParameterGroupWithContext ¶

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

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

See DescribeCacheParameterGroup 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 (*Kcsv1) DescribeCacheParameterGroups ¶

func (c *Kcsv1) DescribeCacheParameterGroups(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeCacheParameterGroups API operation for kcsv1.

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 kcsv1's API operation DescribeCacheParameterGroups for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeCacheParameterGroups

func (*Kcsv1) DescribeCacheParameterGroupsRequest ¶

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

DescribeCacheParameterGroupsRequest generates a "ksc/request.Request" representing the client's request for the DescribeCacheParameterGroups 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 DescribeCacheParameterGroups for more information on using the DescribeCacheParameterGroups 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 DescribeCacheParameterGroupsRequest method.
req, resp := client.DescribeCacheParameterGroupsRequest(params)

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

func (*Kcsv1) DescribeCacheParameterGroupsWithContext ¶

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

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

See DescribeCacheParameterGroups 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 (*Kcsv1) DescribeCacheParameters ¶

func (c *Kcsv1) DescribeCacheParameters(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeCacheParameters API operation for kcsv1.

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 kcsv1's API operation DescribeCacheParameters for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeCacheParameters

func (*Kcsv1) DescribeCacheParametersRequest ¶

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

DescribeCacheParametersRequest generates a "ksc/request.Request" representing the client's request for the DescribeCacheParameters 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 DescribeCacheParameters for more information on using the DescribeCacheParameters 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 DescribeCacheParametersRequest method.
req, resp := client.DescribeCacheParametersRequest(params)

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

func (*Kcsv1) DescribeCacheParametersWithContext ¶

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

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

See DescribeCacheParameters 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 (*Kcsv1) DescribeCacheSecurityGroup ¶

func (c *Kcsv1) DescribeCacheSecurityGroup(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeCacheSecurityGroup API operation for kcsv1.

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 kcsv1's API operation DescribeCacheSecurityGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeCacheSecurityGroup

func (*Kcsv1) DescribeCacheSecurityGroupRequest ¶

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

DescribeCacheSecurityGroupRequest generates a "ksc/request.Request" representing the client's request for the DescribeCacheSecurityGroup 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 DescribeCacheSecurityGroup for more information on using the DescribeCacheSecurityGroup 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 DescribeCacheSecurityGroupRequest method.
req, resp := client.DescribeCacheSecurityGroupRequest(params)

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

func (*Kcsv1) DescribeCacheSecurityGroupWithContext ¶

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

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

See DescribeCacheSecurityGroup 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 (*Kcsv1) DescribeCacheSecurityGroups ¶

func (c *Kcsv1) DescribeCacheSecurityGroups(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeCacheSecurityGroups API operation for kcsv1.

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 kcsv1's API operation DescribeCacheSecurityGroups for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeCacheSecurityGroups

func (*Kcsv1) DescribeCacheSecurityGroupsRequest ¶

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

DescribeCacheSecurityGroupsRequest generates a "ksc/request.Request" representing the client's request for the DescribeCacheSecurityGroups 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 DescribeCacheSecurityGroups for more information on using the DescribeCacheSecurityGroups 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 DescribeCacheSecurityGroupsRequest method.
req, resp := client.DescribeCacheSecurityGroupsRequest(params)

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

func (*Kcsv1) DescribeCacheSecurityGroupsWithContext ¶

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

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

See DescribeCacheSecurityGroups 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 (*Kcsv1) DescribeCacheSecurityRules ¶

func (c *Kcsv1) DescribeCacheSecurityRules(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeCacheSecurityRules API operation for kcsv1.

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 kcsv1's API operation DescribeCacheSecurityRules for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeCacheSecurityRules

func (*Kcsv1) DescribeCacheSecurityRulesRequest ¶

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

DescribeCacheSecurityRulesRequest generates a "ksc/request.Request" representing the client's request for the DescribeCacheSecurityRules 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 DescribeCacheSecurityRules for more information on using the DescribeCacheSecurityRules 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 DescribeCacheSecurityRulesRequest method.
req, resp := client.DescribeCacheSecurityRulesRequest(params)

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

func (*Kcsv1) DescribeCacheSecurityRulesWithContext ¶

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

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

See DescribeCacheSecurityRules 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 (*Kcsv1) DescribeRegions ¶

func (c *Kcsv1) DescribeRegions(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeRegions API operation for kcsv1.

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 kcsv1's API operation DescribeRegions for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeRegions

func (*Kcsv1) DescribeRegionsRequest ¶

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

DescribeRegionsRequest generates a "ksc/request.Request" representing the client's request for the DescribeRegions 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 DescribeRegions for more information on using the DescribeRegions 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 DescribeRegionsRequest method.
req, resp := client.DescribeRegionsRequest(params)

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

func (*Kcsv1) DescribeRegionsWithContext ¶

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

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

See DescribeRegions 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 (*Kcsv1) DescribeSnapshots ¶

func (c *Kcsv1) DescribeSnapshots(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeSnapshots API operation for kcsv1.

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 kcsv1's API operation DescribeSnapshots for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeSnapshots

func (*Kcsv1) DescribeSnapshotsRequest ¶

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

DescribeSnapshotsRequest generates a "ksc/request.Request" representing the client's request for the DescribeSnapshots 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 DescribeSnapshots for more information on using the DescribeSnapshots 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 DescribeSnapshotsRequest method.
req, resp := client.DescribeSnapshotsRequest(params)

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

func (*Kcsv1) DescribeSnapshotsWithContext ¶

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

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

See DescribeSnapshots 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 (*Kcsv1) DownloadSnapshot ¶

func (c *Kcsv1) DownloadSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)

DownloadSnapshot API operation for kcsv1.

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 kcsv1's API operation DownloadSnapshot for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DownloadSnapshot

func (*Kcsv1) DownloadSnapshotRequest ¶

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

DownloadSnapshotRequest generates a "ksc/request.Request" representing the client's request for the DownloadSnapshot 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 DownloadSnapshot for more information on using the DownloadSnapshot 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 DownloadSnapshotRequest method.
req, resp := client.DownloadSnapshotRequest(params)

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

func (*Kcsv1) DownloadSnapshotWithContext ¶

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

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

See DownloadSnapshot 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 (*Kcsv1) ExportSnapshot ¶

func (c *Kcsv1) ExportSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)

ExportSnapshot API operation for kcsv1.

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 kcsv1's API operation ExportSnapshot for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/ExportSnapshot

func (*Kcsv1) ExportSnapshotRequest ¶

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

ExportSnapshotRequest generates a "ksc/request.Request" representing the client's request for the ExportSnapshot 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 ExportSnapshot for more information on using the ExportSnapshot 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 ExportSnapshotRequest method.
req, resp := client.ExportSnapshotRequest(params)

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

func (*Kcsv1) ExportSnapshotWithContext ¶

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

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

See ExportSnapshot 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 (*Kcsv1) FlushCacheCluster ¶

func (c *Kcsv1) FlushCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)

FlushCacheCluster API operation for kcsv1.

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 kcsv1's API operation FlushCacheCluster for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/FlushCacheCluster

func (*Kcsv1) FlushCacheClusterRequest ¶

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

FlushCacheClusterRequest generates a "ksc/request.Request" representing the client's request for the FlushCacheCluster 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 FlushCacheCluster for more information on using the FlushCacheCluster 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 FlushCacheClusterRequest method.
req, resp := client.FlushCacheClusterRequest(params)

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

func (*Kcsv1) FlushCacheClusterWithContext ¶

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

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

See FlushCacheCluster 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 (*Kcsv1) ModifyCacheParameterGroup ¶

func (c *Kcsv1) ModifyCacheParameterGroup(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyCacheParameterGroup API operation for kcsv1.

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 kcsv1's API operation ModifyCacheParameterGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/ModifyCacheParameterGroup

func (*Kcsv1) ModifyCacheParameterGroupRequest ¶

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

ModifyCacheParameterGroupRequest generates a "ksc/request.Request" representing the client's request for the ModifyCacheParameterGroup 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 ModifyCacheParameterGroup for more information on using the ModifyCacheParameterGroup 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 ModifyCacheParameterGroupRequest method.
req, resp := client.ModifyCacheParameterGroupRequest(params)

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

func (*Kcsv1) ModifyCacheParameterGroupWithContext ¶

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

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

See ModifyCacheParameterGroup 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 (*Kcsv1) ModifyCacheSecurityGroup ¶

func (c *Kcsv1) ModifyCacheSecurityGroup(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyCacheSecurityGroup API operation for kcsv1.

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 kcsv1's API operation ModifyCacheSecurityGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/ModifyCacheSecurityGroup

func (*Kcsv1) ModifyCacheSecurityGroupRequest ¶

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

ModifyCacheSecurityGroupRequest generates a "ksc/request.Request" representing the client's request for the ModifyCacheSecurityGroup 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 ModifyCacheSecurityGroup for more information on using the ModifyCacheSecurityGroup 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 ModifyCacheSecurityGroupRequest method.
req, resp := client.ModifyCacheSecurityGroupRequest(params)

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

func (*Kcsv1) ModifyCacheSecurityGroupWithContext ¶

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

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

See ModifyCacheSecurityGroup 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 (*Kcsv1) RenameCacheCluster ¶

func (c *Kcsv1) RenameCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)

RenameCacheCluster API operation for kcsv1.

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 kcsv1's API operation RenameCacheCluster for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/RenameCacheCluster

func (*Kcsv1) RenameCacheClusterRequest ¶

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

RenameCacheClusterRequest generates a "ksc/request.Request" representing the client's request for the RenameCacheCluster 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 RenameCacheCluster for more information on using the RenameCacheCluster 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 RenameCacheClusterRequest method.
req, resp := client.RenameCacheClusterRequest(params)

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

func (*Kcsv1) RenameCacheClusterWithContext ¶

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

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

See RenameCacheCluster 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 (*Kcsv1) RenameSnapshot ¶

func (c *Kcsv1) RenameSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)

RenameSnapshot API operation for kcsv1.

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 kcsv1's API operation RenameSnapshot for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/RenameSnapshot

func (*Kcsv1) RenameSnapshotRequest ¶

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

RenameSnapshotRequest generates a "ksc/request.Request" representing the client's request for the RenameSnapshot 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 RenameSnapshot for more information on using the RenameSnapshot 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 RenameSnapshotRequest method.
req, resp := client.RenameSnapshotRequest(params)

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

func (*Kcsv1) RenameSnapshotWithContext ¶

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

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

See RenameSnapshot 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 (*Kcsv1) ResizeCacheCluster ¶

func (c *Kcsv1) ResizeCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)

ResizeCacheCluster API operation for kcsv1.

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 kcsv1's API operation ResizeCacheCluster for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/ResizeCacheCluster

func (*Kcsv1) ResizeCacheClusterRequest ¶

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

ResizeCacheClusterRequest generates a "ksc/request.Request" representing the client's request for the ResizeCacheCluster 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 ResizeCacheCluster for more information on using the ResizeCacheCluster 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 ResizeCacheClusterRequest method.
req, resp := client.ResizeCacheClusterRequest(params)

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

func (*Kcsv1) ResizeCacheClusterWithContext ¶

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

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

See ResizeCacheCluster 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 (*Kcsv1) RestoreSnapshot ¶

func (c *Kcsv1) RestoreSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)

RestoreSnapshot API operation for kcsv1.

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 kcsv1's API operation RestoreSnapshot for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/RestoreSnapshot

func (*Kcsv1) RestoreSnapshotRequest ¶

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

RestoreSnapshotRequest generates a "ksc/request.Request" representing the client's request for the RestoreSnapshot 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 RestoreSnapshot for more information on using the RestoreSnapshot 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 RestoreSnapshotRequest method.
req, resp := client.RestoreSnapshotRequest(params)

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

func (*Kcsv1) RestoreSnapshotWithContext ¶

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

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

See RestoreSnapshot 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 (*Kcsv1) SetCacheParameterGroup ¶

func (c *Kcsv1) SetCacheParameterGroup(input *map[string]interface{}) (*map[string]interface{}, error)

SetCacheParameterGroup API operation for kcsv1.

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 kcsv1's API operation SetCacheParameterGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/SetCacheParameterGroup

func (*Kcsv1) SetCacheParameterGroupRequest ¶

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

SetCacheParameterGroupRequest generates a "ksc/request.Request" representing the client's request for the SetCacheParameterGroup 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 SetCacheParameterGroup for more information on using the SetCacheParameterGroup 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 SetCacheParameterGroupRequest method.
req, resp := client.SetCacheParameterGroupRequest(params)

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

func (*Kcsv1) SetCacheParameterGroupWithContext ¶

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

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

See SetCacheParameterGroup 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 (*Kcsv1) SetCacheParameters ¶

func (c *Kcsv1) SetCacheParameters(input *map[string]interface{}) (*map[string]interface{}, error)

SetCacheParameters API operation for kcsv1.

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 kcsv1's API operation SetCacheParameters for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/SetCacheParameters

func (*Kcsv1) SetCacheParametersRequest ¶

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

SetCacheParametersRequest generates a "ksc/request.Request" representing the client's request for the SetCacheParameters 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 SetCacheParameters for more information on using the SetCacheParameters 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 SetCacheParametersRequest method.
req, resp := client.SetCacheParametersRequest(params)

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

func (*Kcsv1) SetCacheParametersWithContext ¶

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

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

See SetCacheParameters 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 (*Kcsv1) SetCacheSecurityGroup ¶

func (c *Kcsv1) SetCacheSecurityGroup(input *map[string]interface{}) (*map[string]interface{}, error)

SetCacheSecurityGroup API operation for kcsv1.

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 kcsv1's API operation SetCacheSecurityGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/SetCacheSecurityGroup

func (*Kcsv1) SetCacheSecurityGroupRequest ¶

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

SetCacheSecurityGroupRequest generates a "ksc/request.Request" representing the client's request for the SetCacheSecurityGroup 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 SetCacheSecurityGroup for more information on using the SetCacheSecurityGroup 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 SetCacheSecurityGroupRequest method.
req, resp := client.SetCacheSecurityGroupRequest(params)

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

func (*Kcsv1) SetCacheSecurityGroupWithContext ¶

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

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

See SetCacheSecurityGroup 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 (*Kcsv1) SetCacheSecurityRules ¶

func (c *Kcsv1) SetCacheSecurityRules(input *map[string]interface{}) (*map[string]interface{}, error)

SetCacheSecurityRules API operation for kcsv1.

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 kcsv1's API operation SetCacheSecurityRules for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/SetCacheSecurityRules

func (*Kcsv1) SetCacheSecurityRulesRequest ¶

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

SetCacheSecurityRulesRequest generates a "ksc/request.Request" representing the client's request for the SetCacheSecurityRules 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 SetCacheSecurityRules for more information on using the SetCacheSecurityRules 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 SetCacheSecurityRulesRequest method.
req, resp := client.SetCacheSecurityRulesRequest(params)

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

func (*Kcsv1) SetCacheSecurityRulesWithContext ¶

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

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

See SetCacheSecurityRules 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 (*Kcsv1) SetTimingSnapshot ¶

func (c *Kcsv1) SetTimingSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)

SetTimingSnapshot API operation for kcsv1.

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 kcsv1's API operation SetTimingSnapshot for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/SetTimingSnapshot

func (*Kcsv1) SetTimingSnapshotRequest ¶

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

SetTimingSnapshotRequest generates a "ksc/request.Request" representing the client's request for the SetTimingSnapshot 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 SetTimingSnapshot for more information on using the SetTimingSnapshot 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 SetTimingSnapshotRequest method.
req, resp := client.SetTimingSnapshotRequest(params)

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

func (*Kcsv1) SetTimingSnapshotWithContext ¶

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

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

See SetTimingSnapshot 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 (*Kcsv1) UpdatePassword ¶

func (c *Kcsv1) UpdatePassword(input *map[string]interface{}) (*map[string]interface{}, error)

UpdatePassword API operation for kcsv1.

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 kcsv1's API operation UpdatePassword for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/UpdatePassword

func (*Kcsv1) UpdatePasswordRequest ¶

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

UpdatePasswordRequest generates a "ksc/request.Request" representing the client's request for the UpdatePassword 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 UpdatePassword for more information on using the UpdatePassword 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 UpdatePasswordRequest method.
req, resp := client.UpdatePasswordRequest(params)

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

func (*Kcsv1) UpdatePasswordWithContext ¶

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

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

See UpdatePassword 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
kcsv1iface Package kcsv1iface provides an interface to enable mocking the kcsv1 service client for testing your code.	Package kcsv1iface provides an interface to enable mocking the kcsv1 service client for testing your code.

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