kec

package

v0.3.1 Latest Latest Go to latest Published: Jan 11, 2024 License: Apache-2.0, Apache-2.0 Imports: 9 Imported by: 0

Details

Valid go.mod file

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

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

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

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

Repository

github.com/baoyxing/ksc-sdk-go

Links

Open Source Insights

Documentation ¶

Constants ¶

View Source

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

Variables ¶

This section is empty.

Functions ¶

This section is empty.

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

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) ApplyAutoSnapshotPolicy ¶

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

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

func (*Kec) ApplyAutoSnapshotPolicyRequest ¶

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

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

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

func (*Kec) ApplyAutoSnapshotPolicyWithContext ¶

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

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

See ApplyAutoSnapshotPolicy 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) AttachInstance ¶

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

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

func (*Kec) AttachInstanceRequest ¶

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

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

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

func (*Kec) AttachInstanceWithContext ¶

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

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

See AttachInstance 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) AttachInstancesIamRole ¶

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

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

func (*Kec) AttachInstancesIamRoleRequest ¶

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

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

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

func (*Kec) AttachInstancesIamRoleWithContext ¶

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

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

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

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

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) CalculatePolicyInVolumeNum ¶

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

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

func (*Kec) CalculatePolicyInVolumeNumRequest ¶

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

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

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

func (*Kec) CalculatePolicyInVolumeNumWithContext ¶

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

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

See CalculatePolicyInVolumeNum 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) CalculatePolicyNum ¶

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

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

func (*Kec) CalculatePolicyNumRequest ¶

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

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

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

func (*Kec) CalculatePolicyNumWithContext ¶

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

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

See CalculatePolicyNum 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) CancelAutoSnapshotPolicy ¶

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

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

func (*Kec) CancelAutoSnapshotPolicyRequest ¶

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

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

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

func (*Kec) CancelAutoSnapshotPolicyWithContext ¶

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

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

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

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) CreateAutoSnapshotPolicy ¶

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

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

func (*Kec) CreateAutoSnapshotPolicyRequest ¶

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

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

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

func (*Kec) CreateAutoSnapshotPolicyWithContext ¶

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

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

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

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

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

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) CreateScalingConfiguration ¶

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

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

func (*Kec) CreateScalingConfigurationRequest ¶

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

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

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

func (*Kec) CreateScalingConfigurationWithContext ¶

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

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

See CreateScalingConfiguration 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) CreateScalingGroup ¶

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

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

func (*Kec) CreateScalingGroupRequest ¶

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

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

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

func (*Kec) CreateScalingGroupWithContext ¶

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

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

See CreateScalingGroup 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) CreateScalingNotification ¶

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

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

func (*Kec) CreateScalingNotificationRequest ¶

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

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

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

func (*Kec) CreateScalingNotificationWithContext ¶

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

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

See CreateScalingNotification 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) CreateScalingPolicy ¶

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

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

func (*Kec) CreateScalingPolicyRequest ¶

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

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

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

func (*Kec) CreateScalingPolicyWithContext ¶

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

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

See CreateScalingPolicy 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) CreateScheduledTask ¶

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

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

func (*Kec) CreateScheduledTaskRequest ¶

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

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

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

func (*Kec) CreateScheduledTaskWithContext ¶

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

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

See CreateScheduledTask 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) DeleteAutoSnapshotPolicy ¶

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

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

func (*Kec) DeleteAutoSnapshotPolicyRequest ¶

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

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

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

func (*Kec) DeleteAutoSnapshotPolicyWithContext ¶

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

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

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

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

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) DeleteScalingConfiguration ¶

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

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

func (*Kec) DeleteScalingConfigurationRequest ¶

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

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

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

func (*Kec) DeleteScalingConfigurationWithContext ¶

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

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

See DeleteScalingConfiguration 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) DeleteScalingGroup ¶

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

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

func (*Kec) DeleteScalingGroupRequest ¶

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

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

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

func (*Kec) DeleteScalingGroupWithContext ¶

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

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

See DeleteScalingGroup 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) DeleteScalingPolicy ¶

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

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

func (*Kec) DeleteScalingPolicyRequest ¶

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

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

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

func (*Kec) DeleteScalingPolicyWithContext ¶

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

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

See DeleteScalingPolicy 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) DeleteScheduledTask ¶

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

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

func (*Kec) DeleteScheduledTaskRequest ¶

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

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

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

func (*Kec) DeleteScheduledTaskWithContext ¶

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

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

See DeleteScheduledTask 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) DescribeAutoSnapshotPolicy ¶

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

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

func (*Kec) DescribeAutoSnapshotPolicyRequest ¶

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

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

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

func (*Kec) DescribeAutoSnapshotPolicyWithContext ¶

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

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

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

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

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

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

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

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

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

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

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

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) DescribeKecIamRoles ¶

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

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

func (*Kec) DescribeKecIamRolesRequest ¶

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

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

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

func (*Kec) DescribeKecIamRolesWithContext ¶

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

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

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

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

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

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

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) DescribeScalingActivity ¶

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

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

func (*Kec) DescribeScalingActivityRequest ¶

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

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

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

func (*Kec) DescribeScalingActivityWithContext ¶

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

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

See DescribeScalingActivity 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) DescribeScalingConfiguration ¶

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

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

func (*Kec) DescribeScalingConfigurationRequest ¶

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

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

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

func (*Kec) DescribeScalingConfigurationWithContext ¶

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

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

See DescribeScalingConfiguration 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) DescribeScalingGroup ¶

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

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

func (*Kec) DescribeScalingGroupRequest ¶

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

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

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

func (*Kec) DescribeScalingGroupWithContext ¶

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

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

See DescribeScalingGroup 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) DescribeScalingInstance ¶

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

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

func (*Kec) DescribeScalingInstanceRequest ¶

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

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

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

func (*Kec) DescribeScalingInstanceWithContext ¶

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

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

See DescribeScalingInstance 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) DescribeScalingNotification ¶

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

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

func (*Kec) DescribeScalingNotificationRequest ¶

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

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

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

func (*Kec) DescribeScalingNotificationWithContext ¶

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

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

See DescribeScalingNotification 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) DescribeScalingPolicy ¶

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

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

func (*Kec) DescribeScalingPolicyRequest ¶

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

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

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

func (*Kec) DescribeScalingPolicyWithContext ¶

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

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

See DescribeScalingPolicy 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) DescribeScheduledTask ¶

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

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

func (*Kec) DescribeScheduledTaskRequest ¶

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

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

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

func (*Kec) DescribeScheduledTaskWithContext ¶

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

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

See DescribeScheduledTask 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) DetachInstance ¶

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

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

func (*Kec) DetachInstanceRequest ¶

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

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

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

func (*Kec) DetachInstanceWithContext ¶

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

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

See DetachInstance 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) DetachInstancesIamRole ¶

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

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

func (*Kec) DetachInstancesIamRoleRequest ¶

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

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

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

func (*Kec) DetachInstancesIamRoleWithContext ¶

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

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

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

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

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) DisableScalingGroup ¶

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

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

func (*Kec) DisableScalingGroupRequest ¶

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

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

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

func (*Kec) DisableScalingGroupWithContext ¶

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

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

See DisableScalingGroup 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) EnableImageCaching ¶

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

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

func (*Kec) EnableImageCachingRequest ¶

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

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

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

func (*Kec) EnableImageCachingWithContext ¶

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

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

See EnableImageCaching 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) EnableScalingGroup ¶

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

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

func (*Kec) EnableScalingGroupRequest ¶

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

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

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

func (*Kec) EnableScalingGroupWithContext ¶

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

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

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

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) ModifyAutoSnapshotPolicy ¶

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

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

func (*Kec) ModifyAutoSnapshotPolicyRequest ¶

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

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

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

func (*Kec) ModifyAutoSnapshotPolicyWithContext ¶

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

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

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

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

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

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

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

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

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

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) ModifyScalingConfiguration ¶

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

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

func (*Kec) ModifyScalingConfigurationRequest ¶

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

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

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

func (*Kec) ModifyScalingConfigurationWithContext ¶

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

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

See ModifyScalingConfiguration 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) ModifyScalingGroup ¶

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

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

func (*Kec) ModifyScalingGroupRequest ¶

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

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

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

func (*Kec) ModifyScalingGroupWithContext ¶

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

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

See ModifyScalingGroup 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) ModifyScalingLoadBalancers ¶

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

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

func (*Kec) ModifyScalingLoadBalancersRequest ¶

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

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

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

func (*Kec) ModifyScalingLoadBalancersWithContext ¶

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

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

See ModifyScalingLoadBalancers 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) ModifyScalingNotification ¶

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

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

func (*Kec) ModifyScalingNotificationRequest ¶

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

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

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

func (*Kec) ModifyScalingNotificationWithContext ¶

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

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

See ModifyScalingNotification 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) ModifyScalingPolicy ¶

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

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

func (*Kec) ModifyScalingPolicyRequest ¶

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

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

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

func (*Kec) ModifyScalingPolicyWithContext ¶

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

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

See ModifyScalingPolicy 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) ModifyScheduledTask ¶

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

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

func (*Kec) ModifyScheduledTaskRequest ¶

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

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

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

func (*Kec) ModifyScheduledTaskWithContext ¶

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

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

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

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

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

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

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

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) SetKvmProtectedDetach ¶

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

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

func (*Kec) SetKvmProtectedDetachRequest ¶

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

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

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

func (*Kec) SetKvmProtectedDetachWithContext ¶

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

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

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

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

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

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.

Source Files ¶

View all Source files

Directories ¶

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

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