kcsv1

Documentation

Index

• Constants
• type Kcsv1
  • func ExtraNew(info *utils.UrlInfo, p client.ConfigProvider, cfgs ...*aws.Config) *Kcsv1
  • func New(p client.ConfigProvider, cfgs ...*aws.Config) *Kcsv1
  • func SdkNew(p client.ConfigProvider, cfgs *ksc.Config, info ...*utils.UrlInfo) *Kcsv1
  • func (c *Kcsv1) AllocateSecurityGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) AllocateSecurityGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) AllocateSecurityGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) CloneSecurityGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) CloneSecurityGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) CloneSecurityGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) CreateCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) CreateCacheClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) CreateCacheClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) CreateCacheParameterGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) CreateCacheParameterGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) CreateCacheParameterGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) CreateSecurityGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) CreateSecurityGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) CreateSecurityGroupRule(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) CreateSecurityGroupRuleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) CreateSecurityGroupRuleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) CreateSecurityGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) CreateSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) CreateSnapshotRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) CreateSnapshotWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) DeallocateSecurityGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) DeallocateSecurityGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) DeallocateSecurityGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) DeleteCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) DeleteCacheClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) DeleteCacheClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) DeleteCacheParameterGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) DeleteCacheParameterGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) DeleteCacheParameterGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) DeleteSecurityGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) DeleteSecurityGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) DeleteSecurityGroupRule(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) DeleteSecurityGroupRuleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) DeleteSecurityGroupRuleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) DeleteSecurityGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) DeleteSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) DeleteSnapshotRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) DeleteSnapshotWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeAvailabilityZones(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeAvailabilityZonesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) DescribeAvailabilityZonesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeCacheClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) DescribeCacheClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeCacheClusters(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeCacheClustersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) DescribeCacheClustersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeCacheDefaultParameters(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeCacheDefaultParametersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) DescribeCacheDefaultParametersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeCacheParameterGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeCacheParameterGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) DescribeCacheParameterGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeCacheParameterGroups(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeCacheParameterGroupsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) DescribeCacheParameterGroupsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeCacheParameters(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeCacheParametersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) DescribeCacheParametersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeInstances(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) DescribeInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeRegions(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeRegionsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) DescribeRegionsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeSecurityGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeSecurityGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) DescribeSecurityGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeSecurityGroups(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeSecurityGroupsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) DescribeSecurityGroupsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeSnapshots(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) DescribeSnapshotsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) DescribeSnapshotsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) DownloadSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) DownloadSnapshotRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) DownloadSnapshotWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) ExportSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) ExportSnapshotRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) ExportSnapshotWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) FlushCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) FlushCacheClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) FlushCacheClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) ModifyCacheParameterGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) ModifyCacheParameterGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) ModifyCacheParameterGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) ModifySecurityGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) ModifySecurityGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) ModifySecurityGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) RenameCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) RenameCacheClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) RenameCacheClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) RenameSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) RenameSnapshotRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) RenameSnapshotWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) ResizeCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) ResizeCacheClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) ResizeCacheClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) RestoreSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) RestoreSnapshotRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) RestoreSnapshotWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) SetCacheParameterGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) SetCacheParameterGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) SetCacheParameterGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) SetCacheParameters(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) SetCacheParametersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) SetCacheParametersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) SetTimingSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) SetTimingSnapshotRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) SetTimingSnapshotWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kcsv1) UpdatePassword(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kcsv1) UpdatePasswordRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kcsv1) UpdatePasswordWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

Constants

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

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) AllocateSecurityGroup

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

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

func (*Kcsv1) AllocateSecurityGroupRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/AllocateSecurityGroup

func (*Kcsv1) AllocateSecurityGroupWithContext

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

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

See AllocateSecurityGroup 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) CloneSecurityGroup

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

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

func (*Kcsv1) CloneSecurityGroupRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/CloneSecurityGroup

func (*Kcsv1) CloneSecurityGroupWithContext

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

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

See CloneSecurityGroup 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) 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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/CreateCacheCluster

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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/CreateCacheParameterGroup

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) CreateSecurityGroup

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

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

func (*Kcsv1) CreateSecurityGroupRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/CreateSecurityGroup

func (*Kcsv1) CreateSecurityGroupRule

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

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

func (*Kcsv1) CreateSecurityGroupRuleRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/CreateSecurityGroupRule

func (*Kcsv1) CreateSecurityGroupRuleWithContext

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

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

See CreateSecurityGroupRule 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) CreateSecurityGroupWithContext

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

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

See CreateSecurityGroup 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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/CreateSnapshot

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) DeallocateSecurityGroup

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

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

func (*Kcsv1) DeallocateSecurityGroupRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DeallocateSecurityGroup

func (*Kcsv1) DeallocateSecurityGroupWithContext

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

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

See DeallocateSecurityGroup 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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DeleteCacheCluster

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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DeleteCacheParameterGroup

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) DeleteSecurityGroup

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

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

func (*Kcsv1) DeleteSecurityGroupRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DeleteSecurityGroup

func (*Kcsv1) DeleteSecurityGroupRule

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

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

func (*Kcsv1) DeleteSecurityGroupRuleRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DeleteSecurityGroupRule

func (*Kcsv1) DeleteSecurityGroupRuleWithContext

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

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

See DeleteSecurityGroupRule 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) DeleteSecurityGroupWithContext

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

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

See DeleteSecurityGroup 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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DeleteSnapshot

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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeAvailabilityZones

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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeCacheCluster

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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeCacheClusters

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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeCacheDefaultParameters

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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeCacheParameterGroup

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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeCacheParameterGroups

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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeCacheParameters

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) DescribeInstances

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

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

func (*Kcsv1) DescribeInstancesRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeInstances

func (*Kcsv1) DescribeInstancesWithContext

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

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

See DescribeInstances 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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeRegions

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) DescribeSecurityGroup

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

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

func (*Kcsv1) DescribeSecurityGroupRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeSecurityGroup

func (*Kcsv1) DescribeSecurityGroupWithContext

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

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

See DescribeSecurityGroup 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) DescribeSecurityGroups

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

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

func (*Kcsv1) DescribeSecurityGroupsRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeSecurityGroups

func (*Kcsv1) DescribeSecurityGroupsWithContext

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

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

See DescribeSecurityGroups 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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DescribeSnapshots

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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/DownloadSnapshot

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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/ExportSnapshot

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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/FlushCacheCluster

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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/ModifyCacheParameterGroup

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) ModifySecurityGroup

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

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

func (*Kcsv1) ModifySecurityGroupRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/ModifySecurityGroup

func (*Kcsv1) ModifySecurityGroupWithContext

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

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

See ModifySecurityGroup 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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/RenameCacheCluster

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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/RenameSnapshot

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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/ResizeCacheCluster

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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/RestoreSnapshot

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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/SetCacheParameterGroup

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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/SetCacheParameters

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) 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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/SetTimingSnapshot

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)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kcs-2016-07-01/UpdatePassword

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.