dedicated

Documentation

Index

• Constants
• type Dedicated
  • func ExtraNew(info *utils.UrlInfo, p client.ConfigProvider, cfgs ...*aws.Config) *Dedicated
  • func New(p client.ConfigProvider, cfgs ...*aws.Config) *Dedicated
  • func SdkNew(p client.ConfigProvider, cfgs *ksc.Config, info ...*utils.UrlInfo) *Dedicated
  • func (c *Dedicated) CreateDedicatedCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Dedicated) CreateDedicatedClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Dedicated) CreateDedicatedClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Dedicated) CreateDedicatedHosts(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Dedicated) CreateDedicatedHostsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Dedicated) CreateDedicatedHostsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Dedicated) DeleteDedicatedCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Dedicated) DeleteDedicatedClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Dedicated) DeleteDedicatedClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Dedicated) DeleteDedicatedHost(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Dedicated) DeleteDedicatedHostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Dedicated) DeleteDedicatedHostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Dedicated) DescribeDedicatedCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Dedicated) DescribeDedicatedClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Dedicated) DescribeDedicatedClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Dedicated) DescribeDedicatedHosts(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Dedicated) DescribeDedicatedHostsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Dedicated) DescribeDedicatedHostsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Dedicated) HostMigrate(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Dedicated) HostMigrateRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Dedicated) HostMigrateWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Dedicated) InstanceMigrate(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Dedicated) InstanceMigrateRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Dedicated) InstanceMigrateWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Dedicated) ModifyDedicatedClusterName(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Dedicated) ModifyDedicatedClusterNameRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Dedicated) ModifyDedicatedClusterNameWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Dedicated) RenameDedicatedHost(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Dedicated) RenameDedicatedHostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Dedicated) RenameDedicatedHostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Dedicated) RunInstances(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Dedicated) RunInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Dedicated) RunInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Dedicated) SetvCPU(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Dedicated) SetvCPURequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Dedicated) SetvCPUWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

Constants

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

Service information constants

Types

type Dedicated

type Dedicated struct {
	*client.Client
}

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

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

extraNew create int can support ssl or region locate set

func New

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

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

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

func SdkNew

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

SdkNew create int can support ssl or region locate set

func (*Dedicated) CreateDedicatedCluster

func (c *Dedicated) CreateDedicatedCluster(input *map[string]interface{}) (*map[string]interface{}, error)

CreateDedicatedCluster API operation for dedicated.

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

func (*Dedicated) CreateDedicatedClusterRequest

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

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

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

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

func (*Dedicated) CreateDedicatedClusterWithContext

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

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

See CreateDedicatedCluster 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 (*Dedicated) CreateDedicatedHosts

func (c *Dedicated) CreateDedicatedHosts(input *map[string]interface{}) (*map[string]interface{}, error)

CreateDedicatedHosts API operation for dedicated.

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

func (*Dedicated) CreateDedicatedHostsRequest

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

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

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

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

func (*Dedicated) CreateDedicatedHostsWithContext

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

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

See CreateDedicatedHosts 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 (*Dedicated) DeleteDedicatedCluster

func (c *Dedicated) DeleteDedicatedCluster(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteDedicatedCluster API operation for dedicated.

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

func (*Dedicated) DeleteDedicatedClusterRequest

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

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

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

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

func (*Dedicated) DeleteDedicatedClusterWithContext

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

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

See DeleteDedicatedCluster 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 (*Dedicated) DeleteDedicatedHost

func (c *Dedicated) DeleteDedicatedHost(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteDedicatedHost API operation for dedicated.

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

func (*Dedicated) DeleteDedicatedHostRequest

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

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

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

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

func (*Dedicated) DeleteDedicatedHostWithContext

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

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

See DeleteDedicatedHost 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 (*Dedicated) DescribeDedicatedCluster

func (c *Dedicated) DescribeDedicatedCluster(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeDedicatedCluster API operation for dedicated.

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

func (*Dedicated) DescribeDedicatedClusterRequest

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

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

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

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

func (*Dedicated) DescribeDedicatedClusterWithContext

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

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

See DescribeDedicatedCluster 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 (*Dedicated) DescribeDedicatedHosts

func (c *Dedicated) DescribeDedicatedHosts(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeDedicatedHosts API operation for dedicated.

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

func (*Dedicated) DescribeDedicatedHostsRequest

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

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

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

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

func (*Dedicated) DescribeDedicatedHostsWithContext

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

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

See DescribeDedicatedHosts 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 (*Dedicated) HostMigrate

func (c *Dedicated) HostMigrate(input *map[string]interface{}) (*map[string]interface{}, error)

HostMigrate API operation for dedicated.

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

func (*Dedicated) HostMigrateRequest

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

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

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

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

func (*Dedicated) HostMigrateWithContext

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

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

See HostMigrate 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 (*Dedicated) InstanceMigrate

func (c *Dedicated) InstanceMigrate(input *map[string]interface{}) (*map[string]interface{}, error)

InstanceMigrate API operation for dedicated.

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

func (*Dedicated) InstanceMigrateRequest

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

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

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

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

func (*Dedicated) InstanceMigrateWithContext

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

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

See InstanceMigrate 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 (*Dedicated) ModifyDedicatedClusterName

func (c *Dedicated) ModifyDedicatedClusterName(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyDedicatedClusterName API operation for dedicated.

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

func (*Dedicated) ModifyDedicatedClusterNameRequest

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

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

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

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

func (*Dedicated) ModifyDedicatedClusterNameWithContext

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

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

See ModifyDedicatedClusterName 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 (*Dedicated) RenameDedicatedHost

func (c *Dedicated) RenameDedicatedHost(input *map[string]interface{}) (*map[string]interface{}, error)

RenameDedicatedHost API operation for dedicated.

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

func (*Dedicated) RenameDedicatedHostRequest

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

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

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

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

func (*Dedicated) RenameDedicatedHostWithContext

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

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

See RenameDedicatedHost 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 (*Dedicated) RunInstances

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

RunInstances API operation for dedicated.

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

func (*Dedicated) RunInstancesRequest

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

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

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

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

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

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

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

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

func (*Dedicated) RunInstancesWithContext

func (c *Dedicated) 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 (*Dedicated) SetvCPU

func (c *Dedicated) SetvCPU(input *map[string]interface{}) (*map[string]interface{}, error)

SetvCPU API operation for dedicated.

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

func (*Dedicated) SetvCPURequest

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

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

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

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

func (*Dedicated) SetvCPUWithContext

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

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

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