epc

Documentation

Index

• Constants
• type Epc
  • func ExtraNew(info *utils.UrlInfo, p client.ConfigProvider, cfgs ...*aws.Config) *Epc
  • func New(p client.ConfigProvider, cfgs ...*aws.Config) *Epc
  • func SdkNew(p client.ConfigProvider, cfgs *ksc.Config, info ...*utils.UrlInfo) *Epc
  • func (c *Epc) AssociateCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) AssociateClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) AssociateClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) BuyAccessory(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) BuyAccessoryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) BuyAccessoryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) CreateAccessory(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) CreateAccessoryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) CreateAccessoryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) CreateCabinet(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) CreateCabinetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) CreateCabinetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) CreateEpc(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) CreateEpcRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) CreateEpcWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) CreateImage(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) CreateImageRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) CreateImageWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) CreateKey(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) CreateKeyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) CreateKeyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) CreateProcess(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) CreateProcessRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) CreateProcessWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) CreateRemoteManagement(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) CreateRemoteManagementRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) CreateRemoteManagementWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DeleteAccessory(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DeleteAccessoryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DeleteAccessoryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DeleteEpc(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DeleteEpcRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DeleteEpcWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DeleteImage(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DeleteImageRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DeleteImageWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DeleteKey(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DeleteKeyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DeleteKeyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DeleteProcess(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DeleteProcessRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DeleteProcessWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DeleteRemoteManagement(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DeleteRemoteManagementRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DeleteRemoteManagementWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DescribeAccessorys(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DescribeAccessorysRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DescribeAccessorysWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DescribeCabinets(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DescribeCabinetsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DescribeCabinetsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DescribeEpcDeviceAttributes(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DescribeEpcDeviceAttributesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DescribeEpcDeviceAttributesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DescribeEpcManagements(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DescribeEpcManagementsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DescribeEpcManagementsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DescribeEpcRaidAttributes(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DescribeEpcRaidAttributesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DescribeEpcRaidAttributesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DescribeEpcStocks(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DescribeEpcStocksRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DescribeEpcStocksWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DescribeEpcs(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DescribeEpcsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DescribeEpcsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DescribeImages(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DescribeImagesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DescribeImagesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DescribeInspections(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DescribeInspectionsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DescribeInspectionsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DescribeKeys(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DescribeKeysRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DescribeKeysWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DescribePhysicalMonitor(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DescribePhysicalMonitorRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DescribePhysicalMonitorWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DescribeProcesses(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DescribeProcessesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DescribeProcessesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DescribeRemoteManagements(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DescribeRemoteManagementsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DescribeRemoteManagementsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DescribeVpns(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DescribeVpnsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DescribeVpnsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) DisassociateCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) DisassociateClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) DisassociateClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) GetDynamicCode(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) GetDynamicCodeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) GetDynamicCodeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) ImportKey(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) ImportKeyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) ImportKeyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) ModifyDns(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) ModifyDnsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) ModifyDnsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) ModifyEpc(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) ModifyEpcRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) ModifyEpcWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) ModifyHyperThreading(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) ModifyHyperThreadingRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) ModifyHyperThreadingWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) ModifyImage(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) ModifyImageRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) ModifyImageWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) ModifyKey(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) ModifyKeyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) ModifyKeyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) ModifyNetworkInterfaceAttribute(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) ModifyNetworkInterfaceAttributeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) ModifyNetworkInterfaceAttributeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) ModifyRemoteManagement(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) ModifyRemoteManagementRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) ModifyRemoteManagementWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) ModifySecurityGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) ModifySecurityGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) ModifySecurityGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) RebootEpc(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) RebootEpcRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) RebootEpcWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) ReinstallCustomerEpc(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) ReinstallCustomerEpcRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) ReinstallCustomerEpcWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) ReinstallEpc(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) ReinstallEpcRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) ReinstallEpcWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) ReplyProcess(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) ReplyProcessRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) ReplyProcessWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) ResetPassword(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) ResetPasswordRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) ResetPasswordWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) StartEpc(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) StartEpcRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) StartEpcWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Epc) StopEpc(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Epc) StopEpcRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Epc) StopEpcWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

Constants

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

Service information constants

Types

type Epc

type Epc struct {
	*client.Client
}

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

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

extraNew create int can support ssl or region locate set

func New

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

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

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

func SdkNew

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

SdkNew create int can support ssl or region locate set

func (*Epc) AssociateCluster

func (c *Epc) AssociateCluster(input *map[string]interface{}) (*map[string]interface{}, error)

AssociateCluster API operation for epc.

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 epc's API operation AssociateCluster for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/AssociateCluster

func (*Epc) AssociateClusterRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/AssociateCluster

func (*Epc) AssociateClusterWithContext

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

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

See AssociateCluster 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 (*Epc) BuyAccessory

func (c *Epc) BuyAccessory(input *map[string]interface{}) (*map[string]interface{}, error)

BuyAccessory API operation for epc.

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 epc's API operation BuyAccessory for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/BuyAccessory

func (*Epc) BuyAccessoryRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/BuyAccessory

func (*Epc) BuyAccessoryWithContext

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

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

See BuyAccessory 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 (*Epc) CreateAccessory

func (c *Epc) CreateAccessory(input *map[string]interface{}) (*map[string]interface{}, error)

CreateAccessory API operation for epc.

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 epc's API operation CreateAccessory for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/CreateAccessory

func (*Epc) CreateAccessoryRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/CreateAccessory

func (*Epc) CreateAccessoryWithContext

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

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

See CreateAccessory 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 (*Epc) CreateCabinet

func (c *Epc) CreateCabinet(input *map[string]interface{}) (*map[string]interface{}, error)

CreateCabinet API operation for epc.

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 epc's API operation CreateCabinet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/CreateCabinet

func (*Epc) CreateCabinetRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/CreateCabinet

func (*Epc) CreateCabinetWithContext

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

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

See CreateCabinet 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 (*Epc) CreateEpc

func (c *Epc) CreateEpc(input *map[string]interface{}) (*map[string]interface{}, error)

CreateEpc API operation for epc.

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 epc's API operation CreateEpc for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/CreateEpc

func (*Epc) CreateEpcRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/CreateEpc

func (*Epc) CreateEpcWithContext

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

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

See CreateEpc 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 (*Epc) CreateImage

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

CreateImage API operation for epc.

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 epc's API operation CreateImage for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/CreateImage

func (*Epc) CreateImageRequest

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

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

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

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

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/CreateImage

func (*Epc) CreateImageWithContext

func (c *Epc) 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 (*Epc) CreateKey

func (c *Epc) CreateKey(input *map[string]interface{}) (*map[string]interface{}, error)

CreateKey API operation for epc.

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 epc's API operation CreateKey for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/CreateKey

func (*Epc) CreateKeyRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/CreateKey

func (*Epc) CreateKeyWithContext

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

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

See CreateKey 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 (*Epc) CreateProcess

func (c *Epc) CreateProcess(input *map[string]interface{}) (*map[string]interface{}, error)

CreateProcess API operation for epc.

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 epc's API operation CreateProcess for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/CreateProcess

func (*Epc) CreateProcessRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/CreateProcess

func (*Epc) CreateProcessWithContext

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

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

See CreateProcess 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 (*Epc) CreateRemoteManagement

func (c *Epc) CreateRemoteManagement(input *map[string]interface{}) (*map[string]interface{}, error)

CreateRemoteManagement API operation for epc.

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 epc's API operation CreateRemoteManagement for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/CreateRemoteManagement

func (*Epc) CreateRemoteManagementRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/CreateRemoteManagement

func (*Epc) CreateRemoteManagementWithContext

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

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

See CreateRemoteManagement 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 (*Epc) DeleteAccessory

func (c *Epc) DeleteAccessory(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteAccessory API operation for epc.

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 epc's API operation DeleteAccessory for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DeleteAccessory

func (*Epc) DeleteAccessoryRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DeleteAccessory

func (*Epc) DeleteAccessoryWithContext

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

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

See DeleteAccessory 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 (*Epc) DeleteEpc

func (c *Epc) DeleteEpc(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteEpc API operation for epc.

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 epc's API operation DeleteEpc for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DeleteEpc

func (*Epc) DeleteEpcRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DeleteEpc

func (*Epc) DeleteEpcWithContext

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

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

See DeleteEpc 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 (*Epc) DeleteImage

func (c *Epc) DeleteImage(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteImage API operation for epc.

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 epc's API operation DeleteImage for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DeleteImage

func (*Epc) DeleteImageRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DeleteImage

func (*Epc) DeleteImageWithContext

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

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

See DeleteImage 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 (*Epc) DeleteKey

func (c *Epc) DeleteKey(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteKey API operation for epc.

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 epc's API operation DeleteKey for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DeleteKey

func (*Epc) DeleteKeyRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DeleteKey

func (*Epc) DeleteKeyWithContext

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

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

See DeleteKey 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 (*Epc) DeleteProcess

func (c *Epc) DeleteProcess(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteProcess API operation for epc.

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 epc's API operation DeleteProcess for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DeleteProcess

func (*Epc) DeleteProcessRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DeleteProcess

func (*Epc) DeleteProcessWithContext

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

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

See DeleteProcess 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 (*Epc) DeleteRemoteManagement

func (c *Epc) DeleteRemoteManagement(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteRemoteManagement API operation for epc.

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 epc's API operation DeleteRemoteManagement for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DeleteRemoteManagement

func (*Epc) DeleteRemoteManagementRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DeleteRemoteManagement

func (*Epc) DeleteRemoteManagementWithContext

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

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

See DeleteRemoteManagement 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 (*Epc) DescribeAccessorys

func (c *Epc) DescribeAccessorys(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeAccessorys API operation for epc.

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 epc's API operation DescribeAccessorys for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeAccessorys

func (*Epc) DescribeAccessorysRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeAccessorys

func (*Epc) DescribeAccessorysWithContext

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

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

See DescribeAccessorys 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 (*Epc) DescribeCabinets

func (c *Epc) DescribeCabinets(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeCabinets API operation for epc.

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 epc's API operation DescribeCabinets for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeCabinets

func (*Epc) DescribeCabinetsRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeCabinets

func (*Epc) DescribeCabinetsWithContext

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

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

See DescribeCabinets 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 (*Epc) DescribeEpcDeviceAttributes

func (c *Epc) DescribeEpcDeviceAttributes(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeEpcDeviceAttributes API operation for epc.

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 epc's API operation DescribeEpcDeviceAttributes for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeEpcDeviceAttributes

func (*Epc) DescribeEpcDeviceAttributesRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeEpcDeviceAttributes

func (*Epc) DescribeEpcDeviceAttributesWithContext

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

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

See DescribeEpcDeviceAttributes 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 (*Epc) DescribeEpcManagements

func (c *Epc) DescribeEpcManagements(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeEpcManagements API operation for epc.

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 epc's API operation DescribeEpcManagements for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeEpcManagements

func (*Epc) DescribeEpcManagementsRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeEpcManagements

func (*Epc) DescribeEpcManagementsWithContext

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

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

See DescribeEpcManagements 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 (*Epc) DescribeEpcRaidAttributes

func (c *Epc) DescribeEpcRaidAttributes(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeEpcRaidAttributes API operation for epc.

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 epc's API operation DescribeEpcRaidAttributes for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeEpcRaidAttributes

func (*Epc) DescribeEpcRaidAttributesRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeEpcRaidAttributes

func (*Epc) DescribeEpcRaidAttributesWithContext

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

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

See DescribeEpcRaidAttributes 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 (*Epc) DescribeEpcStocks

func (c *Epc) DescribeEpcStocks(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeEpcStocks API operation for epc.

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 epc's API operation DescribeEpcStocks for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeEpcStocks

func (*Epc) DescribeEpcStocksRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeEpcStocks

func (*Epc) DescribeEpcStocksWithContext

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

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

See DescribeEpcStocks 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 (*Epc) DescribeEpcs

func (c *Epc) DescribeEpcs(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeEpcs API operation for epc.

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 epc's API operation DescribeEpcs for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeEpcs

func (*Epc) DescribeEpcsRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeEpcs

func (*Epc) DescribeEpcsWithContext

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

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

See DescribeEpcs 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 (*Epc) DescribeImages

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

DescribeImages API operation for epc.

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 epc's API operation DescribeImages for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeImages

func (*Epc) DescribeImagesRequest

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

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

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

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

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeImages

func (*Epc) DescribeImagesWithContext

func (c *Epc) 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 (*Epc) DescribeInspections

func (c *Epc) DescribeInspections(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeInspections API operation for epc.

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 epc's API operation DescribeInspections for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeInspections

func (*Epc) DescribeInspectionsRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeInspections

func (*Epc) DescribeInspectionsWithContext

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

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

See DescribeInspections 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 (*Epc) DescribeKeys

func (c *Epc) DescribeKeys(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeKeys API operation for epc.

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 epc's API operation DescribeKeys for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeKeys

func (*Epc) DescribeKeysRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeKeys

func (*Epc) DescribeKeysWithContext

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

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

See DescribeKeys 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 (*Epc) DescribePhysicalMonitor

func (c *Epc) DescribePhysicalMonitor(input *map[string]interface{}) (*map[string]interface{}, error)

DescribePhysicalMonitor API operation for epc.

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 epc's API operation DescribePhysicalMonitor for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribePhysicalMonitor

func (*Epc) DescribePhysicalMonitorRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribePhysicalMonitor

func (*Epc) DescribePhysicalMonitorWithContext

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

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

See DescribePhysicalMonitor 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 (*Epc) DescribeProcesses

func (c *Epc) DescribeProcesses(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeProcesses API operation for epc.

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 epc's API operation DescribeProcesses for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeProcesses

func (*Epc) DescribeProcessesRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeProcesses

func (*Epc) DescribeProcessesWithContext

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

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

See DescribeProcesses 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 (*Epc) DescribeRemoteManagements

func (c *Epc) DescribeRemoteManagements(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeRemoteManagements API operation for epc.

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 epc's API operation DescribeRemoteManagements for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeRemoteManagements

func (*Epc) DescribeRemoteManagementsRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeRemoteManagements

func (*Epc) DescribeRemoteManagementsWithContext

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

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

See DescribeRemoteManagements 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 (*Epc) DescribeVpns

func (c *Epc) DescribeVpns(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeVpns API operation for epc.

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 epc's API operation DescribeVpns for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeVpns

func (*Epc) DescribeVpnsRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DescribeVpns

func (*Epc) DescribeVpnsWithContext

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

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

See DescribeVpns 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 (*Epc) DisassociateCluster

func (c *Epc) DisassociateCluster(input *map[string]interface{}) (*map[string]interface{}, error)

DisassociateCluster API operation for epc.

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 epc's API operation DisassociateCluster for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DisassociateCluster

func (*Epc) DisassociateClusterRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/DisassociateCluster

func (*Epc) DisassociateClusterWithContext

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

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

See DisassociateCluster 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 (*Epc) GetDynamicCode

func (c *Epc) GetDynamicCode(input *map[string]interface{}) (*map[string]interface{}, error)

GetDynamicCode API operation for epc.

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 epc's API operation GetDynamicCode for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/GetDynamicCode

func (*Epc) GetDynamicCodeRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/GetDynamicCode

func (*Epc) GetDynamicCodeWithContext

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

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

See GetDynamicCode 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 (*Epc) ImportKey

func (c *Epc) ImportKey(input *map[string]interface{}) (*map[string]interface{}, error)

ImportKey API operation for epc.

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 epc's API operation ImportKey for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ImportKey

func (*Epc) ImportKeyRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ImportKey

func (*Epc) ImportKeyWithContext

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

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

See ImportKey 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 (*Epc) ModifyDns

func (c *Epc) ModifyDns(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyDns API operation for epc.

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 epc's API operation ModifyDns for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ModifyDns

func (*Epc) ModifyDnsRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ModifyDns

func (*Epc) ModifyDnsWithContext

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

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

See ModifyDns 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 (*Epc) ModifyEpc

func (c *Epc) ModifyEpc(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyEpc API operation for epc.

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 epc's API operation ModifyEpc for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ModifyEpc

func (*Epc) ModifyEpcRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ModifyEpc

func (*Epc) ModifyEpcWithContext

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

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

See ModifyEpc 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 (*Epc) ModifyHyperThreading

func (c *Epc) ModifyHyperThreading(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyHyperThreading API operation for epc.

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 epc's API operation ModifyHyperThreading for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ModifyHyperThreading

func (*Epc) ModifyHyperThreadingRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ModifyHyperThreading

func (*Epc) ModifyHyperThreadingWithContext

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

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

See ModifyHyperThreading 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 (*Epc) ModifyImage

func (c *Epc) ModifyImage(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyImage API operation for epc.

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 epc's API operation ModifyImage for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ModifyImage

func (*Epc) ModifyImageRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ModifyImage

func (*Epc) ModifyImageWithContext

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

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

See ModifyImage 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 (*Epc) ModifyKey

func (c *Epc) ModifyKey(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyKey API operation for epc.

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 epc's API operation ModifyKey for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ModifyKey

func (*Epc) ModifyKeyRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ModifyKey

func (*Epc) ModifyKeyWithContext

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

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

See ModifyKey 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 (*Epc) ModifyNetworkInterfaceAttribute

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

ModifyNetworkInterfaceAttribute API operation for epc.

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 epc's API operation ModifyNetworkInterfaceAttribute for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ModifyNetworkInterfaceAttribute

func (*Epc) ModifyNetworkInterfaceAttributeRequest

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

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

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

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

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ModifyNetworkInterfaceAttribute

func (*Epc) ModifyNetworkInterfaceAttributeWithContext

func (c *Epc) 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 (*Epc) ModifyRemoteManagement

func (c *Epc) ModifyRemoteManagement(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyRemoteManagement API operation for epc.

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 epc's API operation ModifyRemoteManagement for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ModifyRemoteManagement

func (*Epc) ModifyRemoteManagementRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ModifyRemoteManagement

func (*Epc) ModifyRemoteManagementWithContext

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

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

See ModifyRemoteManagement 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 (*Epc) ModifySecurityGroup

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

ModifySecurityGroup API operation for epc.

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 epc's API operation ModifySecurityGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ModifySecurityGroup

func (*Epc) ModifySecurityGroupRequest

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

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

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

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

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ModifySecurityGroup

func (*Epc) ModifySecurityGroupWithContext

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

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

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

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

func (*Epc) RebootEpc

func (c *Epc) RebootEpc(input *map[string]interface{}) (*map[string]interface{}, error)

RebootEpc API operation for epc.

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 epc's API operation RebootEpc for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/RebootEpc

func (*Epc) RebootEpcRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/RebootEpc

func (*Epc) RebootEpcWithContext

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

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

See RebootEpc 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 (*Epc) ReinstallCustomerEpc

func (c *Epc) ReinstallCustomerEpc(input *map[string]interface{}) (*map[string]interface{}, error)

ReinstallCustomerEpc API operation for epc.

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 epc's API operation ReinstallCustomerEpc for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ReinstallCustomerEpc

func (*Epc) ReinstallCustomerEpcRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ReinstallCustomerEpc

func (*Epc) ReinstallCustomerEpcWithContext

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

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

See ReinstallCustomerEpc 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 (*Epc) ReinstallEpc

func (c *Epc) ReinstallEpc(input *map[string]interface{}) (*map[string]interface{}, error)

ReinstallEpc API operation for epc.

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 epc's API operation ReinstallEpc for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ReinstallEpc

func (*Epc) ReinstallEpcRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ReinstallEpc

func (*Epc) ReinstallEpcWithContext

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

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

See ReinstallEpc 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 (*Epc) ReplyProcess

func (c *Epc) ReplyProcess(input *map[string]interface{}) (*map[string]interface{}, error)

ReplyProcess API operation for epc.

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 epc's API operation ReplyProcess for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ReplyProcess

func (*Epc) ReplyProcessRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ReplyProcess

func (*Epc) ReplyProcessWithContext

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

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

See ReplyProcess 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 (*Epc) ResetPassword

func (c *Epc) ResetPassword(input *map[string]interface{}) (*map[string]interface{}, error)

ResetPassword API operation for epc.

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 epc's API operation ResetPassword for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ResetPassword

func (*Epc) ResetPasswordRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/ResetPassword

func (*Epc) ResetPasswordWithContext

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

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

See ResetPassword 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 (*Epc) StartEpc

func (c *Epc) StartEpc(input *map[string]interface{}) (*map[string]interface{}, error)

StartEpc API operation for epc.

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 epc's API operation StartEpc for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/StartEpc

func (*Epc) StartEpcRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/StartEpc

func (*Epc) StartEpcWithContext

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

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

See StartEpc 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 (*Epc) StopEpc

func (c *Epc) StopEpc(input *map[string]interface{}) (*map[string]interface{}, error)

StopEpc API operation for epc.

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 epc's API operation StopEpc for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/StopEpc

func (*Epc) StopEpcRequest

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

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

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

See also, https://docs.aws.amazon.com/goto/WebAPI/epc-2015-11-01/StopEpc

func (*Epc) StopEpcWithContext

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

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

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