kec

Documentation

Index

• Constants
• type Kec
  • func ExtraNew(info *utils.UrlInfo, p client.ConfigProvider, cfgs ...*aws.Config) *Kec
  • func New(p client.ConfigProvider, cfgs ...*aws.Config) *Kec
  • func SdkNew(p client.ConfigProvider, cfgs *ksc.Config, info ...*utils.UrlInfo) *Kec
  • func (c *Kec) AddVmIntoDataGuard(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) AddVmIntoDataGuardRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) AddVmIntoDataGuardWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) AttachKey(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) AttachKeyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) AttachKeyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) AttachNetworkInterface(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) AttachNetworkInterfaceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) AttachNetworkInterfaceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) CopyImage(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) CopyImageRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) CopyImageWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) CreateDataGuardGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) CreateDataGuardGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) CreateDataGuardGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) CreateImage(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) CreateImageRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) CreateImageWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) CreateLocalVolumeSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) CreateLocalVolumeSnapshotRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) CreateLocalVolumeSnapshotWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DeleteDataGuardGroups(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DeleteDataGuardGroupsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DeleteDataGuardGroupsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DeleteLocalVolumeSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DeleteLocalVolumeSnapshotRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DeleteLocalVolumeSnapshotWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeAvailabilityZones(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeAvailabilityZonesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeAvailabilityZonesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeDataGuardCapacity(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeDataGuardCapacityRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeDataGuardCapacityWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeDataGuardGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeDataGuardGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeDataGuardGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeImageSharePermission(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeImageSharePermissionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeImageSharePermissionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeImages(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeImagesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeImagesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeInstanceFamilys(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeInstanceFamilysRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeInstanceFamilysWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeInstanceTypeConfigs(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeInstanceTypeConfigsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeInstanceTypeConfigsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeInstanceVnc(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeInstanceVncRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeInstanceVncWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeInstances(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeKecInventory(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeKecInventoryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeKecInventoryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeLocalVolumeSnapshots(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeLocalVolumeSnapshotsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeLocalVolumeSnapshotsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeLocalVolumes(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeLocalVolumesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeLocalVolumesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeRegions(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeRegionsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeRegionsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DetachKey(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DetachKeyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DetachKeyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DetachNetworkInterface(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DetachNetworkInterfaceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DetachNetworkInterfaceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ImportImage(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ImportImageRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ImportImageWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyDataGuardGroups(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyDataGuardGroupsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyDataGuardGroupsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyImageAttribute(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyImageAttributeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyImageAttributeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyImageSharePermission(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyImageSharePermissionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyImageSharePermissionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyInstanceAttribute(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyInstanceAttributeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyInstanceAttributeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyInstanceImage(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyInstanceImageRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyInstanceImageWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyInstanceType(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyInstanceTypeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyInstanceTypeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyNetworkInterfaceAttribute(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyNetworkInterfaceAttributeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyNetworkInterfaceAttributeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) RebootInstances(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) RebootInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) RebootInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) RemoveImages(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) RemoveImagesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) RemoveImagesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) RemoveVmFromDataGuard(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) RemoveVmFromDataGuardRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) RemoveVmFromDataGuardWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) RollbackLocalVolume(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) RollbackLocalVolumeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) RollbackLocalVolumeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) RunInstances(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) RunInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) RunInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) StartInstances(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) StartInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) StartInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) StopInstances(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) StopInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) StopInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) TerminateInstances(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) TerminateInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) TerminateInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

Constants

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

Service information constants

Types

type Kec

type Kec struct {
	*client.Client
}

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

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

extraNew create int can support ssl or region locate set

func New

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

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

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

func SdkNew

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

SdkNew create int can support ssl or region locate set

func (*Kec) AddVmIntoDataGuard

func (c *Kec) AddVmIntoDataGuard(input *map[string]interface{}) (*map[string]interface{}, error)

AddVmIntoDataGuard API operation for kec.

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 kec's API operation AddVmIntoDataGuard for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/AddVmIntoDataGuard

func (*Kec) AddVmIntoDataGuardRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/AddVmIntoDataGuard

func (*Kec) AddVmIntoDataGuardWithContext

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

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

See AddVmIntoDataGuard 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 (*Kec) AttachKey

func (c *Kec) AttachKey(input *map[string]interface{}) (*map[string]interface{}, error)

AttachKey API operation for kec.

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 kec's API operation AttachKey for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/AttachKey

func (*Kec) AttachKeyRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/AttachKey

func (*Kec) AttachKeyWithContext

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

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

See AttachKey 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 (*Kec) AttachNetworkInterface

func (c *Kec) AttachNetworkInterface(input *map[string]interface{}) (*map[string]interface{}, error)

AttachNetworkInterface API operation for kec.

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 kec's API operation AttachNetworkInterface for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/AttachNetworkInterface

func (*Kec) AttachNetworkInterfaceRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/AttachNetworkInterface

func (*Kec) AttachNetworkInterfaceWithContext

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

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

See AttachNetworkInterface 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 (*Kec) CopyImage

func (c *Kec) CopyImage(input *map[string]interface{}) (*map[string]interface{}, error)

CopyImage API operation for kec.

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 kec's API operation CopyImage for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CopyImage

func (*Kec) CopyImageRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CopyImage

func (*Kec) CopyImageWithContext

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

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

See CopyImage 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 (*Kec) CreateDataGuardGroup

func (c *Kec) CreateDataGuardGroup(input *map[string]interface{}) (*map[string]interface{}, error)

CreateDataGuardGroup API operation for kec.

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 kec's API operation CreateDataGuardGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateDataGuardGroup

func (*Kec) CreateDataGuardGroupRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateDataGuardGroup

func (*Kec) CreateDataGuardGroupWithContext

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

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

See CreateDataGuardGroup 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 (*Kec) CreateImage

func (c *Kec) CreateImage(input *map[string]interface{}) (*map[string]interface{}, error)

CreateImage API operation for kec.

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 kec's API operation CreateImage for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateImage

func (*Kec) CreateImageRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateImage

func (*Kec) CreateImageWithContext

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

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

See CreateImage 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 (*Kec) CreateLocalVolumeSnapshot

func (c *Kec) CreateLocalVolumeSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)

CreateLocalVolumeSnapshot API operation for kec.

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 kec's API operation CreateLocalVolumeSnapshot for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateLocalVolumeSnapshot

func (*Kec) CreateLocalVolumeSnapshotRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateLocalVolumeSnapshot

func (*Kec) CreateLocalVolumeSnapshotWithContext

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

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

See CreateLocalVolumeSnapshot 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 (*Kec) DeleteDataGuardGroups

func (c *Kec) DeleteDataGuardGroups(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteDataGuardGroups API operation for kec.

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 kec's API operation DeleteDataGuardGroups for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DeleteDataGuardGroups

func (*Kec) DeleteDataGuardGroupsRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DeleteDataGuardGroups

func (*Kec) DeleteDataGuardGroupsWithContext

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

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

See DeleteDataGuardGroups 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 (*Kec) DeleteLocalVolumeSnapshot

func (c *Kec) DeleteLocalVolumeSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteLocalVolumeSnapshot API operation for kec.

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 kec's API operation DeleteLocalVolumeSnapshot for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DeleteLocalVolumeSnapshot

func (*Kec) DeleteLocalVolumeSnapshotRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DeleteLocalVolumeSnapshot

func (*Kec) DeleteLocalVolumeSnapshotWithContext

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

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

See DeleteLocalVolumeSnapshot 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 (*Kec) DescribeAvailabilityZones

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

DescribeAvailabilityZones API operation for kec.

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

func (*Kec) DescribeAvailabilityZonesRequest

func (c *Kec) 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/kec-2016-03-04/DescribeAvailabilityZones

func (*Kec) DescribeAvailabilityZonesWithContext

func (c *Kec) 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 (*Kec) DescribeDataGuardCapacity

func (c *Kec) DescribeDataGuardCapacity(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeDataGuardCapacity API operation for kec.

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 kec's API operation DescribeDataGuardCapacity for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeDataGuardCapacity

func (*Kec) DescribeDataGuardCapacityRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeDataGuardCapacity

func (*Kec) DescribeDataGuardCapacityWithContext

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

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

See DescribeDataGuardCapacity 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 (*Kec) DescribeDataGuardGroup

func (c *Kec) DescribeDataGuardGroup(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeDataGuardGroup API operation for kec.

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 kec's API operation DescribeDataGuardGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeDataGuardGroup

func (*Kec) DescribeDataGuardGroupRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeDataGuardGroup

func (*Kec) DescribeDataGuardGroupWithContext

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

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

See DescribeDataGuardGroup 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 (*Kec) DescribeImageSharePermission

func (c *Kec) DescribeImageSharePermission(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeImageSharePermission API operation for kec.

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 kec's API operation DescribeImageSharePermission for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeImageSharePermission

func (*Kec) DescribeImageSharePermissionRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeImageSharePermission

func (*Kec) DescribeImageSharePermissionWithContext

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

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

See DescribeImageSharePermission 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 (*Kec) DescribeImages

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

DescribeImages API operation for kec.

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 kec's API operation DescribeImages for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeImages

func (*Kec) DescribeImagesRequest

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

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

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

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

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeImages

func (*Kec) DescribeImagesWithContext

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

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

See DescribeImages for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeInstanceFamilys

func (c *Kec) DescribeInstanceFamilys(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeInstanceFamilys API operation for kec.

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 kec's API operation DescribeInstanceFamilys for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeInstanceFamilys

func (*Kec) DescribeInstanceFamilysRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeInstanceFamilys

func (*Kec) DescribeInstanceFamilysWithContext

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

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

See DescribeInstanceFamilys 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 (*Kec) DescribeInstanceTypeConfigs

func (c *Kec) DescribeInstanceTypeConfigs(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeInstanceTypeConfigs API operation for kec.

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 kec's API operation DescribeInstanceTypeConfigs for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeInstanceTypeConfigs

func (*Kec) DescribeInstanceTypeConfigsRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeInstanceTypeConfigs

func (*Kec) DescribeInstanceTypeConfigsWithContext

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

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

See DescribeInstanceTypeConfigs 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 (*Kec) DescribeInstanceVnc

func (c *Kec) DescribeInstanceVnc(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeInstanceVnc API operation for kec.

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 kec's API operation DescribeInstanceVnc for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeInstanceVnc

func (*Kec) DescribeInstanceVncRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeInstanceVnc

func (*Kec) DescribeInstanceVncWithContext

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

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

See DescribeInstanceVnc 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 (*Kec) DescribeInstances

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

DescribeInstances API operation for kec.

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 kec's API operation DescribeInstances for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeInstances

func (*Kec) DescribeInstancesRequest

func (c *Kec) 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/kec-2016-03-04/DescribeInstances

func (*Kec) DescribeInstancesWithContext

func (c *Kec) 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 (*Kec) DescribeKecInventory

func (c *Kec) DescribeKecInventory(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeKecInventory API operation for kec.

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 kec's API operation DescribeKecInventory for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeKecInventory

func (*Kec) DescribeKecInventoryRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeKecInventory

func (*Kec) DescribeKecInventoryWithContext

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

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

See DescribeKecInventory 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 (*Kec) DescribeLocalVolumeSnapshots

func (c *Kec) DescribeLocalVolumeSnapshots(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeLocalVolumeSnapshots API operation for kec.

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 kec's API operation DescribeLocalVolumeSnapshots for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeLocalVolumeSnapshots

func (*Kec) DescribeLocalVolumeSnapshotsRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeLocalVolumeSnapshots

func (*Kec) DescribeLocalVolumeSnapshotsWithContext

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

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

See DescribeLocalVolumeSnapshots 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 (*Kec) DescribeLocalVolumes

func (c *Kec) DescribeLocalVolumes(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeLocalVolumes API operation for kec.

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 kec's API operation DescribeLocalVolumes for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeLocalVolumes

func (*Kec) DescribeLocalVolumesRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeLocalVolumes

func (*Kec) DescribeLocalVolumesWithContext

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

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

See DescribeLocalVolumes 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 (*Kec) DescribeRegions

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

DescribeRegions API operation for kec.

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

func (*Kec) DescribeRegionsRequest

func (c *Kec) 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/kec-2016-03-04/DescribeRegions

func (*Kec) DescribeRegionsWithContext

func (c *Kec) 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 (*Kec) DetachKey

func (c *Kec) DetachKey(input *map[string]interface{}) (*map[string]interface{}, error)

DetachKey API operation for kec.

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 kec's API operation DetachKey for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DetachKey

func (*Kec) DetachKeyRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DetachKey

func (*Kec) DetachKeyWithContext

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

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

See DetachKey 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 (*Kec) DetachNetworkInterface

func (c *Kec) DetachNetworkInterface(input *map[string]interface{}) (*map[string]interface{}, error)

DetachNetworkInterface API operation for kec.

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 kec's API operation DetachNetworkInterface for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DetachNetworkInterface

func (*Kec) DetachNetworkInterfaceRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DetachNetworkInterface

func (*Kec) DetachNetworkInterfaceWithContext

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

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

See DetachNetworkInterface 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 (*Kec) ImportImage

func (c *Kec) ImportImage(input *map[string]interface{}) (*map[string]interface{}, error)

ImportImage API operation for kec.

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 kec's API operation ImportImage for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ImportImage

func (*Kec) ImportImageRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ImportImage

func (*Kec) ImportImageWithContext

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

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

See ImportImage 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 (*Kec) ModifyDataGuardGroups

func (c *Kec) ModifyDataGuardGroups(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyDataGuardGroups API operation for kec.

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 kec's API operation ModifyDataGuardGroups for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyDataGuardGroups

func (*Kec) ModifyDataGuardGroupsRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyDataGuardGroups

func (*Kec) ModifyDataGuardGroupsWithContext

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

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

See ModifyDataGuardGroups 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 (*Kec) ModifyImageAttribute

func (c *Kec) ModifyImageAttribute(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyImageAttribute API operation for kec.

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 kec's API operation ModifyImageAttribute for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyImageAttribute

func (*Kec) ModifyImageAttributeRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyImageAttribute

func (*Kec) ModifyImageAttributeWithContext

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

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

See ModifyImageAttribute 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 (*Kec) ModifyImageSharePermission

func (c *Kec) ModifyImageSharePermission(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyImageSharePermission API operation for kec.

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 kec's API operation ModifyImageSharePermission for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyImageSharePermission

func (*Kec) ModifyImageSharePermissionRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyImageSharePermission

func (*Kec) ModifyImageSharePermissionWithContext

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

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

See ModifyImageSharePermission 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 (*Kec) ModifyInstanceAttribute

func (c *Kec) ModifyInstanceAttribute(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyInstanceAttribute API operation for kec.

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 kec's API operation ModifyInstanceAttribute for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyInstanceAttribute

func (*Kec) ModifyInstanceAttributeRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyInstanceAttribute

func (*Kec) ModifyInstanceAttributeWithContext

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

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

See ModifyInstanceAttribute 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 (*Kec) ModifyInstanceImage

func (c *Kec) ModifyInstanceImage(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyInstanceImage API operation for kec.

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 kec's API operation ModifyInstanceImage for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyInstanceImage

func (*Kec) ModifyInstanceImageRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyInstanceImage

func (*Kec) ModifyInstanceImageWithContext

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

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

See ModifyInstanceImage 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 (*Kec) ModifyInstanceType

func (c *Kec) ModifyInstanceType(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyInstanceType API operation for kec.

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 kec's API operation ModifyInstanceType for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyInstanceType

func (*Kec) ModifyInstanceTypeRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyInstanceType

func (*Kec) ModifyInstanceTypeWithContext

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

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

See ModifyInstanceType 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 (*Kec) ModifyNetworkInterfaceAttribute

func (c *Kec) ModifyNetworkInterfaceAttribute(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyNetworkInterfaceAttribute API operation for kec.

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 kec's API operation ModifyNetworkInterfaceAttribute for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyNetworkInterfaceAttribute

func (*Kec) ModifyNetworkInterfaceAttributeRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyNetworkInterfaceAttribute

func (*Kec) ModifyNetworkInterfaceAttributeWithContext

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

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

See ModifyNetworkInterfaceAttribute 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 (*Kec) RebootInstances

func (c *Kec) RebootInstances(input *map[string]interface{}) (*map[string]interface{}, error)

RebootInstances API operation for kec.

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 kec's API operation RebootInstances for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/RebootInstances

func (*Kec) RebootInstancesRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/RebootInstances

func (*Kec) RebootInstancesWithContext

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

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

See RebootInstances 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 (*Kec) RemoveImages

func (c *Kec) RemoveImages(input *map[string]interface{}) (*map[string]interface{}, error)

RemoveImages API operation for kec.

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 kec's API operation RemoveImages for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/RemoveImages

func (*Kec) RemoveImagesRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/RemoveImages

func (*Kec) RemoveImagesWithContext

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

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

See RemoveImages 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 (*Kec) RemoveVmFromDataGuard

func (c *Kec) RemoveVmFromDataGuard(input *map[string]interface{}) (*map[string]interface{}, error)

RemoveVmFromDataGuard API operation for kec.

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 kec's API operation RemoveVmFromDataGuard for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/RemoveVmFromDataGuard

func (*Kec) RemoveVmFromDataGuardRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/RemoveVmFromDataGuard

func (*Kec) RemoveVmFromDataGuardWithContext

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

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

See RemoveVmFromDataGuard 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 (*Kec) RollbackLocalVolume

func (c *Kec) RollbackLocalVolume(input *map[string]interface{}) (*map[string]interface{}, error)

RollbackLocalVolume API operation for kec.

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 kec's API operation RollbackLocalVolume for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/RollbackLocalVolume

func (*Kec) RollbackLocalVolumeRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/RollbackLocalVolume

func (*Kec) RollbackLocalVolumeWithContext

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

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

See RollbackLocalVolume 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 (*Kec) RunInstances

func (c *Kec) RunInstances(input *map[string]interface{}) (*map[string]interface{}, error)

RunInstances API operation for kec.

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 kec's API operation RunInstances for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/RunInstances

func (*Kec) RunInstancesRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/RunInstances

func (*Kec) RunInstancesWithContext

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

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

See RunInstances 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 (*Kec) StartInstances

func (c *Kec) StartInstances(input *map[string]interface{}) (*map[string]interface{}, error)

StartInstances API operation for kec.

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 kec's API operation StartInstances for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/StartInstances

func (*Kec) StartInstancesRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/StartInstances

func (*Kec) StartInstancesWithContext

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

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

See StartInstances 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 (*Kec) StopInstances

func (c *Kec) StopInstances(input *map[string]interface{}) (*map[string]interface{}, error)

StopInstances API operation for kec.

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 kec's API operation StopInstances for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/StopInstances

func (*Kec) StopInstancesRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/StopInstances

func (*Kec) StopInstancesWithContext

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

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

See StopInstances 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 (*Kec) TerminateInstances

func (c *Kec) TerminateInstances(input *map[string]interface{}) (*map[string]interface{}, error)

TerminateInstances API operation for kec.

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 kec's API operation TerminateInstances for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/TerminateInstances

func (*Kec) TerminateInstancesRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/TerminateInstances

func (*Kec) TerminateInstancesWithContext

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

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

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