vpc

package

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

Details

Valid go.mod file

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

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

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

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

Repository

github.com/baoyxing/ksc-sdk-go

Links

Open Source Insights

Documentation ¶

Constants ¶

View Source

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

Service information constants

Variables ¶

This section is empty.

Functions ¶

This section is empty.

Types ¶

type Vpc ¶

type Vpc struct {
	*client.Client
}

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

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

extraNew create int can support ssl or region locate set

func New ¶

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

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

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

func SdkNew ¶

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

SdkNew create int can support ssl or region locate set

func (*Vpc) AcceptVpcPeeringConnection ¶

func (c *Vpc) AcceptVpcPeeringConnection(input *map[string]interface{}) (*map[string]interface{}, error)

AcceptVpcPeeringConnection API operation for vpc.

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

func (*Vpc) AcceptVpcPeeringConnectionRequest ¶

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

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

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

func (*Vpc) AcceptVpcPeeringConnectionWithContext ¶

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

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

See AcceptVpcPeeringConnection 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 (*Vpc) AddNatIp ¶

func (c *Vpc) AddNatIp(input *map[string]interface{}) (*map[string]interface{}, error)

AddNatIp API operation for vpc.

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

func (*Vpc) AddNatIpRequest ¶

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

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

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

func (*Vpc) AddNatIpWithContext ¶

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

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

See AddNatIp 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 (*Vpc) AllocateSubnetIpv6CidrBlock ¶

func (c *Vpc) AllocateSubnetIpv6CidrBlock(input *map[string]interface{}) (*map[string]interface{}, error)

AllocateSubnetIpv6CidrBlock API operation for vpc.

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

func (*Vpc) AllocateSubnetIpv6CidrBlockRequest ¶

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

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

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

func (*Vpc) AllocateSubnetIpv6CidrBlockWithContext ¶

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

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

See AllocateSubnetIpv6CidrBlock 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 (*Vpc) AssignPrivateIpAddress ¶

func (c *Vpc) AssignPrivateIpAddress(input *map[string]interface{}) (*map[string]interface{}, error)

AssignPrivateIpAddress API operation for vpc.

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

func (*Vpc) AssignPrivateIpAddressRequest ¶

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

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

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

func (*Vpc) AssignPrivateIpAddressWithContext ¶

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

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

See AssignPrivateIpAddress 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 (*Vpc) AssociateInstance ¶

func (c *Vpc) AssociateInstance(input *map[string]interface{}) (*map[string]interface{}, error)

AssociateInstance API operation for vpc.

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

func (*Vpc) AssociateInstanceRequest ¶

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

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

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

func (*Vpc) AssociateInstanceWithContext ¶

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

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

See AssociateInstance 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 (*Vpc) AssociateNat ¶

func (c *Vpc) AssociateNat(input *map[string]interface{}) (*map[string]interface{}, error)

AssociateNat API operation for vpc.

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

func (*Vpc) AssociateNatRequest ¶

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

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

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

func (*Vpc) AssociateNatWithContext ¶

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

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

See AssociateNat 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 (*Vpc) AssociateNetworkAcl ¶

func (c *Vpc) AssociateNetworkAcl(input *map[string]interface{}) (*map[string]interface{}, error)

AssociateNetworkAcl API operation for vpc.

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

func (*Vpc) AssociateNetworkAclRequest ¶

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

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

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

func (*Vpc) AssociateNetworkAclWithContext ¶

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

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

See AssociateNetworkAcl 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 (*Vpc) AssociateVpcCidrBlock ¶

func (c *Vpc) AssociateVpcCidrBlock(input *map[string]interface{}) (*map[string]interface{}, error)

AssociateVpcCidrBlock API operation for vpc.

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

func (*Vpc) AssociateVpcCidrBlockRequest ¶

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

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

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

func (*Vpc) AssociateVpcCidrBlockWithContext ¶

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

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

See AssociateVpcCidrBlock 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 (*Vpc) AttachDirectConnectGateway ¶

func (c *Vpc) AttachDirectConnectGateway(input *map[string]interface{}) (*map[string]interface{}, error)

AttachDirectConnectGateway API operation for vpc.

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

func (*Vpc) AttachDirectConnectGatewayRequest ¶

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

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

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

func (*Vpc) AttachDirectConnectGatewayWithContext ¶

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

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

See AttachDirectConnectGateway 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 (*Vpc) AuthorizeSecurityGroupEntry ¶

func (c *Vpc) AuthorizeSecurityGroupEntry(input *map[string]interface{}) (*map[string]interface{}, error)

AuthorizeSecurityGroupEntry API operation for vpc.

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

func (*Vpc) AuthorizeSecurityGroupEntryRequest ¶

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

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

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

func (*Vpc) AuthorizeSecurityGroupEntryWithContext ¶

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

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

See AuthorizeSecurityGroupEntry 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 (*Vpc) CreateCustomerGateway ¶

func (c *Vpc) CreateCustomerGateway(input *map[string]interface{}) (*map[string]interface{}, error)

CreateCustomerGateway API operation for vpc.

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

func (*Vpc) CreateCustomerGatewayRequest ¶

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

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

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

func (*Vpc) CreateCustomerGatewayWithContext ¶

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

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

See CreateCustomerGateway 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 (*Vpc) CreateDirectConnectExtraCidr ¶

func (c *Vpc) CreateDirectConnectExtraCidr(input *map[string]interface{}) (*map[string]interface{}, error)

CreateDirectConnectExtraCidr API operation for vpc.

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

func (*Vpc) CreateDirectConnectExtraCidrRequest ¶

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

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

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

func (*Vpc) CreateDirectConnectExtraCidrWithContext ¶

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

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

See CreateDirectConnectExtraCidr 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 (*Vpc) CreateDirectConnectGateway ¶

func (c *Vpc) CreateDirectConnectGateway(input *map[string]interface{}) (*map[string]interface{}, error)

CreateDirectConnectGateway API operation for vpc.

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

func (*Vpc) CreateDirectConnectGatewayRequest ¶

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

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

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

func (*Vpc) CreateDirectConnectGatewayWithContext ¶

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

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

See CreateDirectConnectGateway 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 (*Vpc) CreateDirectConnectInterface ¶

func (c *Vpc) CreateDirectConnectInterface(input *map[string]interface{}) (*map[string]interface{}, error)

CreateDirectConnectInterface API operation for vpc.

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

func (*Vpc) CreateDirectConnectInterfaceRequest ¶

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

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

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

func (*Vpc) CreateDirectConnectInterfaceWithContext ¶

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

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

See CreateDirectConnectInterface 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 (*Vpc) CreateDirectConnectReomteCidr ¶

func (c *Vpc) CreateDirectConnectReomteCidr(input *map[string]interface{}) (*map[string]interface{}, error)

CreateDirectConnectReomteCidr API operation for vpc.

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

func (*Vpc) CreateDirectConnectReomteCidrRequest ¶

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

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

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

func (*Vpc) CreateDirectConnectReomteCidrWithContext ¶

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

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

See CreateDirectConnectReomteCidr 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 (*Vpc) CreateDnat ¶

func (c *Vpc) CreateDnat(input *map[string]interface{}) (*map[string]interface{}, error)

CreateDnat API operation for vpc.

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

func (*Vpc) CreateDnatRequest ¶

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

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

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

func (*Vpc) CreateDnatWithContext ¶

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

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

See CreateDnat 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 (*Vpc) CreateIpv6PublicIp ¶

func (c *Vpc) CreateIpv6PublicIp(input *map[string]interface{}) (*map[string]interface{}, error)

CreateIpv6PublicIp API operation for vpc.

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

func (*Vpc) CreateIpv6PublicIpRequest ¶

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

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

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

func (*Vpc) CreateIpv6PublicIpWithContext ¶

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

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

See CreateIpv6PublicIp 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 (*Vpc) CreateNat ¶

func (c *Vpc) CreateNat(input *map[string]interface{}) (*map[string]interface{}, error)

CreateNat API operation for vpc.

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

func (*Vpc) CreateNatRateLimit ¶

func (c *Vpc) CreateNatRateLimit(input *map[string]interface{}) (*map[string]interface{}, error)

CreateNatRateLimit API operation for vpc.

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

func (*Vpc) CreateNatRateLimitRequest ¶

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

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

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

func (*Vpc) CreateNatRateLimitWithContext ¶

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

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

See CreateNatRateLimit 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 (*Vpc) CreateNatRequest ¶

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

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

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

func (*Vpc) CreateNatWithContext ¶

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

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

See CreateNat 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 (*Vpc) CreateNetworkAcl ¶

func (c *Vpc) CreateNetworkAcl(input *map[string]interface{}) (*map[string]interface{}, error)

CreateNetworkAcl API operation for vpc.

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

func (*Vpc) CreateNetworkAclEntry ¶

func (c *Vpc) CreateNetworkAclEntry(input *map[string]interface{}) (*map[string]interface{}, error)

CreateNetworkAclEntry API operation for vpc.

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

func (*Vpc) CreateNetworkAclEntryRequest ¶

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

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

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

func (*Vpc) CreateNetworkAclEntryWithContext ¶

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

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

See CreateNetworkAclEntry 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 (*Vpc) CreateNetworkAclRequest ¶

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

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

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

func (*Vpc) CreateNetworkAclWithContext ¶

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

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

See CreateNetworkAcl 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 (*Vpc) CreateNetworkInterface ¶

func (c *Vpc) CreateNetworkInterface(input *map[string]interface{}) (*map[string]interface{}, error)

CreateNetworkInterface API operation for vpc.

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

func (*Vpc) CreateNetworkInterfaceRequest ¶

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

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

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

func (*Vpc) CreateNetworkInterfaceWithContext ¶

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

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

See CreateNetworkInterface 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 (*Vpc) CreateRoute ¶

func (c *Vpc) CreateRoute(input *map[string]interface{}) (*map[string]interface{}, error)

CreateRoute API operation for vpc.

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

func (*Vpc) CreateRouteRequest ¶

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

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

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

func (*Vpc) CreateRouteWithContext ¶

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

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

See CreateRoute 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 (*Vpc) CreateSecurityGroup ¶

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

CreateSecurityGroup API operation for vpc.

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

func (*Vpc) CreateSecurityGroupRequest ¶

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

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

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

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

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

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

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

func (*Vpc) CreateSecurityGroupWithContext ¶

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

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

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

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

func (*Vpc) CreateSubnet ¶

func (c *Vpc) CreateSubnet(input *map[string]interface{}) (*map[string]interface{}, error)

CreateSubnet API operation for vpc.

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

func (*Vpc) CreateSubnetRequest ¶

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

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

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

func (*Vpc) CreateSubnetWithContext ¶

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

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

See CreateSubnet 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 (*Vpc) CreateVpc ¶

func (c *Vpc) CreateVpc(input *map[string]interface{}) (*map[string]interface{}, error)

CreateVpc API operation for vpc.

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

func (*Vpc) CreateVpcPeeringConnection ¶

func (c *Vpc) CreateVpcPeeringConnection(input *map[string]interface{}) (*map[string]interface{}, error)

CreateVpcPeeringConnection API operation for vpc.

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

func (*Vpc) CreateVpcPeeringConnectionRequest ¶

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

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

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

func (*Vpc) CreateVpcPeeringConnectionWithContext ¶

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

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

See CreateVpcPeeringConnection 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 (*Vpc) CreateVpcRequest ¶

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

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

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

func (*Vpc) CreateVpcWithContext ¶

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

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

See CreateVpc 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 (*Vpc) CreateVpnGateway ¶

func (c *Vpc) CreateVpnGateway(input *map[string]interface{}) (*map[string]interface{}, error)

CreateVpnGateway API operation for vpc.

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

func (*Vpc) CreateVpnGatewayRequest ¶

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

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

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

func (*Vpc) CreateVpnGatewayRoute ¶

func (c *Vpc) CreateVpnGatewayRoute(input *map[string]interface{}) (*map[string]interface{}, error)

CreateVpnGatewayRoute API operation for vpc.

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

func (*Vpc) CreateVpnGatewayRouteRequest ¶

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

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

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

func (*Vpc) CreateVpnGatewayRouteWithContext ¶

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

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

See CreateVpnGatewayRoute 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 (*Vpc) CreateVpnGatewayWithContext ¶

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

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

See CreateVpnGateway 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 (*Vpc) CreateVpnTunnel ¶

func (c *Vpc) CreateVpnTunnel(input *map[string]interface{}) (*map[string]interface{}, error)

CreateVpnTunnel API operation for vpc.

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

func (*Vpc) CreateVpnTunnelRequest ¶

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

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

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

func (*Vpc) CreateVpnTunnelWithContext ¶

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

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

See CreateVpnTunnel 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 (*Vpc) DeleteCustomerGateway ¶

func (c *Vpc) DeleteCustomerGateway(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteCustomerGateway API operation for vpc.

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

func (*Vpc) DeleteCustomerGatewayRequest ¶

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

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

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

func (*Vpc) DeleteCustomerGatewayWithContext ¶

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

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

See DeleteCustomerGateway 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 (*Vpc) DeleteDirectConnectExtraCidr ¶

func (c *Vpc) DeleteDirectConnectExtraCidr(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteDirectConnectExtraCidr API operation for vpc.

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

func (*Vpc) DeleteDirectConnectExtraCidrRequest ¶

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

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

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

func (*Vpc) DeleteDirectConnectExtraCidrWithContext ¶

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

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

See DeleteDirectConnectExtraCidr 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 (*Vpc) DeleteDirectConnectGateway ¶

func (c *Vpc) DeleteDirectConnectGateway(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteDirectConnectGateway API operation for vpc.

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

func (*Vpc) DeleteDirectConnectGatewayRequest ¶

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

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

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

func (*Vpc) DeleteDirectConnectGatewayWithContext ¶

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

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

See DeleteDirectConnectGateway 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 (*Vpc) DeleteDirectConnectInterface ¶

func (c *Vpc) DeleteDirectConnectInterface(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteDirectConnectInterface API operation for vpc.

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

func (*Vpc) DeleteDirectConnectInterfaceRequest ¶

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

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

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

func (*Vpc) DeleteDirectConnectInterfaceWithContext ¶

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

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

See DeleteDirectConnectInterface 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 (*Vpc) DeleteDirectConnectReomteCidr ¶

func (c *Vpc) DeleteDirectConnectReomteCidr(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteDirectConnectReomteCidr API operation for vpc.

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

func (*Vpc) DeleteDirectConnectReomteCidrRequest ¶

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

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

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

func (*Vpc) DeleteDirectConnectReomteCidrWithContext ¶

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

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

See DeleteDirectConnectReomteCidr 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 (*Vpc) DeleteDnat ¶

func (c *Vpc) DeleteDnat(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteDnat API operation for vpc.

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

func (*Vpc) DeleteDnatRequest ¶

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

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

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

func (*Vpc) DeleteDnatWithContext ¶

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

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

See DeleteDnat 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 (*Vpc) DeleteNat ¶

func (c *Vpc) DeleteNat(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteNat API operation for vpc.

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

func (*Vpc) DeleteNatIp ¶

func (c *Vpc) DeleteNatIp(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteNatIp API operation for vpc.

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

func (*Vpc) DeleteNatIpRequest ¶

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

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

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

func (*Vpc) DeleteNatIpWithContext ¶

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

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

See DeleteNatIp 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 (*Vpc) DeleteNatRateLimit ¶

func (c *Vpc) DeleteNatRateLimit(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteNatRateLimit API operation for vpc.

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

func (*Vpc) DeleteNatRateLimitRequest ¶

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

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

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

func (*Vpc) DeleteNatRateLimitWithContext ¶

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

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

See DeleteNatRateLimit 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 (*Vpc) DeleteNatRequest ¶

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

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

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

func (*Vpc) DeleteNatWithContext ¶

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

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

See DeleteNat 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 (*Vpc) DeleteNetworkAcl ¶

func (c *Vpc) DeleteNetworkAcl(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteNetworkAcl API operation for vpc.

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

func (*Vpc) DeleteNetworkAclEntry ¶

func (c *Vpc) DeleteNetworkAclEntry(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteNetworkAclEntry API operation for vpc.

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

func (*Vpc) DeleteNetworkAclEntryRequest ¶

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

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

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

func (*Vpc) DeleteNetworkAclEntryWithContext ¶

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

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

See DeleteNetworkAclEntry 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 (*Vpc) DeleteNetworkAclRequest ¶

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

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

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

func (*Vpc) DeleteNetworkAclWithContext ¶

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

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

See DeleteNetworkAcl 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 (*Vpc) DeleteNetworkInterface ¶

func (c *Vpc) DeleteNetworkInterface(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteNetworkInterface API operation for vpc.

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

func (*Vpc) DeleteNetworkInterfaceRequest ¶

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

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

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

func (*Vpc) DeleteNetworkInterfaceWithContext ¶

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

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

See DeleteNetworkInterface 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 (*Vpc) DeleteRoute ¶

func (c *Vpc) DeleteRoute(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteRoute API operation for vpc.

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

func (*Vpc) DeleteRouteRequest ¶

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

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

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

func (*Vpc) DeleteRouteWithContext ¶

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

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

See DeleteRoute 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 (*Vpc) DeleteSecurityGroup ¶

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

DeleteSecurityGroup API operation for vpc.

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

func (*Vpc) DeleteSecurityGroupRequest ¶

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

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

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

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

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

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

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

func (*Vpc) DeleteSecurityGroupWithContext ¶

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

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

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

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

func (*Vpc) DeleteSubnet ¶

func (c *Vpc) DeleteSubnet(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteSubnet API operation for vpc.

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

func (*Vpc) DeleteSubnetRequest ¶

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

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

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

func (*Vpc) DeleteSubnetWithContext ¶

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

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

See DeleteSubnet 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 (*Vpc) DeleteVpc ¶

func (c *Vpc) DeleteVpc(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteVpc API operation for vpc.

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

func (*Vpc) DeleteVpcPeeringConnection ¶

func (c *Vpc) DeleteVpcPeeringConnection(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteVpcPeeringConnection API operation for vpc.

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

func (*Vpc) DeleteVpcPeeringConnectionRequest ¶

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

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

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

func (*Vpc) DeleteVpcPeeringConnectionWithContext ¶

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

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

See DeleteVpcPeeringConnection 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 (*Vpc) DeleteVpcRequest ¶

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

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

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

func (*Vpc) DeleteVpcWithContext ¶

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

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

See DeleteVpc 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 (*Vpc) DeleteVpnGateway ¶

func (c *Vpc) DeleteVpnGateway(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteVpnGateway API operation for vpc.

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

func (*Vpc) DeleteVpnGatewayRequest ¶

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

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

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

func (*Vpc) DeleteVpnGatewayRoute ¶

func (c *Vpc) DeleteVpnGatewayRoute(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteVpnGatewayRoute API operation for vpc.

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

func (*Vpc) DeleteVpnGatewayRouteRequest ¶

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

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

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

func (*Vpc) DeleteVpnGatewayRouteWithContext ¶

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

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

See DeleteVpnGatewayRoute 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 (*Vpc) DeleteVpnGatewayWithContext ¶

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

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

See DeleteVpnGateway 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 (*Vpc) DeleteVpnTunnel ¶

func (c *Vpc) DeleteVpnTunnel(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteVpnTunnel API operation for vpc.

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

func (*Vpc) DeleteVpnTunnelRequest ¶

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

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

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

func (*Vpc) DeleteVpnTunnelWithContext ¶

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

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

See DeleteVpnTunnel 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 (*Vpc) DescribeAvailabilityZones ¶

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

DescribeAvailabilityZones API operation for vpc.

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

func (*Vpc) DescribeAvailabilityZonesRequest ¶

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

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

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

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

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

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

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

func (*Vpc) DescribeAvailabilityZonesWithContext ¶

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

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

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

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

func (*Vpc) DescribeCustomerGateways ¶

func (c *Vpc) DescribeCustomerGateways(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeCustomerGateways API operation for vpc.

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

func (*Vpc) DescribeCustomerGatewaysRequest ¶

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

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

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

func (*Vpc) DescribeCustomerGatewaysWithContext ¶

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

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

See DescribeCustomerGateways 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 (*Vpc) DescribeDirectConnectGateways ¶

func (c *Vpc) DescribeDirectConnectGateways(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeDirectConnectGateways API operation for vpc.

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

func (*Vpc) DescribeDirectConnectGatewaysRequest ¶

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

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

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

func (*Vpc) DescribeDirectConnectGatewaysWithContext ¶

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

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

See DescribeDirectConnectGateways 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 (*Vpc) DescribeDirectConnectInterfaces ¶

func (c *Vpc) DescribeDirectConnectInterfaces(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeDirectConnectInterfaces API operation for vpc.

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

func (*Vpc) DescribeDirectConnectInterfacesRequest ¶

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

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

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

func (*Vpc) DescribeDirectConnectInterfacesWithContext ¶

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

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

See DescribeDirectConnectInterfaces 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 (*Vpc) DescribeDirectConnects ¶

func (c *Vpc) DescribeDirectConnects(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeDirectConnects API operation for vpc.

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

func (*Vpc) DescribeDirectConnectsRequest ¶

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

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

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

func (*Vpc) DescribeDirectConnectsWithContext ¶

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

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

See DescribeDirectConnects 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 (*Vpc) DescribeDnats ¶

func (c *Vpc) DescribeDnats(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeDnats API operation for vpc.

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

func (*Vpc) DescribeDnatsRequest ¶

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

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

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

func (*Vpc) DescribeDnatsWithContext ¶

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

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

See DescribeDnats 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 (*Vpc) DescribeInternetGateways ¶

func (c *Vpc) DescribeInternetGateways(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeInternetGateways API operation for vpc.

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

func (*Vpc) DescribeInternetGatewaysRequest ¶

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

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

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

func (*Vpc) DescribeInternetGatewaysWithContext ¶

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

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

See DescribeInternetGateways 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 (*Vpc) DescribeIpv6NetworkInterfaces ¶

func (c *Vpc) DescribeIpv6NetworkInterfaces(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeIpv6NetworkInterfaces API operation for vpc.

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

func (*Vpc) DescribeIpv6NetworkInterfacesRequest ¶

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

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

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

func (*Vpc) DescribeIpv6NetworkInterfacesWithContext ¶

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

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

See DescribeIpv6NetworkInterfaces 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 (*Vpc) DescribeIpv6PublicIpAddresses ¶

func (c *Vpc) DescribeIpv6PublicIpAddresses(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeIpv6PublicIpAddresses API operation for vpc.

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

func (*Vpc) DescribeIpv6PublicIpAddressesRequest ¶

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

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

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

func (*Vpc) DescribeIpv6PublicIpAddressesWithContext ¶

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

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

See DescribeIpv6PublicIpAddresses 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 (*Vpc) DescribeNatRateLimit ¶

func (c *Vpc) DescribeNatRateLimit(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeNatRateLimit API operation for vpc.

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

func (*Vpc) DescribeNatRateLimitRequest ¶

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

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

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

func (*Vpc) DescribeNatRateLimitWithContext ¶

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

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

See DescribeNatRateLimit 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 (*Vpc) DescribeNats ¶

func (c *Vpc) DescribeNats(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeNats API operation for vpc.

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

func (*Vpc) DescribeNatsRequest ¶

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

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

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

func (*Vpc) DescribeNatsWithContext ¶

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

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

See DescribeNats 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 (*Vpc) DescribeNetworkAcls ¶

func (c *Vpc) DescribeNetworkAcls(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeNetworkAcls API operation for vpc.

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

func (*Vpc) DescribeNetworkAclsRequest ¶

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

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

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

func (*Vpc) DescribeNetworkAclsWithContext ¶

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

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

See DescribeNetworkAcls 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 (*Vpc) DescribeNetworkInterfaces ¶

func (c *Vpc) DescribeNetworkInterfaces(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeNetworkInterfaces API operation for vpc.

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

func (*Vpc) DescribeNetworkInterfacesRequest ¶

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

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

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

func (*Vpc) DescribeNetworkInterfacesWithContext ¶

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

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

See DescribeNetworkInterfaces 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 (*Vpc) DescribeRoutes ¶

func (c *Vpc) DescribeRoutes(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeRoutes API operation for vpc.

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

func (*Vpc) DescribeRoutesRequest ¶

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

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

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

func (*Vpc) DescribeRoutesWithContext ¶

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

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

See DescribeRoutes 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 (*Vpc) DescribeSecurityGroups ¶

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

DescribeSecurityGroups API operation for vpc.

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

func (*Vpc) DescribeSecurityGroupsRequest ¶

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

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

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

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

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

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

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

func (*Vpc) DescribeSecurityGroupsWithContext ¶

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

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

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

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

func (*Vpc) DescribeSubnetAllocatedIpAddresses ¶

func (c *Vpc) DescribeSubnetAllocatedIpAddresses(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeSubnetAllocatedIpAddresses API operation for vpc.

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

func (*Vpc) DescribeSubnetAllocatedIpAddressesRequest ¶

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

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

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

func (*Vpc) DescribeSubnetAllocatedIpAddressesWithContext ¶

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

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

See DescribeSubnetAllocatedIpAddresses 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 (*Vpc) DescribeSubnetAvailableAddresses ¶

func (c *Vpc) DescribeSubnetAvailableAddresses(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeSubnetAvailableAddresses API operation for vpc.

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

func (*Vpc) DescribeSubnetAvailableAddressesRequest ¶

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

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

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

func (*Vpc) DescribeSubnetAvailableAddressesWithContext ¶

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

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

See DescribeSubnetAvailableAddresses 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 (*Vpc) DescribeSubnets ¶

func (c *Vpc) DescribeSubnets(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeSubnets API operation for vpc.

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

func (*Vpc) DescribeSubnetsRequest ¶

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

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

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

func (*Vpc) DescribeSubnetsWithContext ¶

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

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

See DescribeSubnets 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 (*Vpc) DescribeVpcPeeringConnections ¶

func (c *Vpc) DescribeVpcPeeringConnections(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeVpcPeeringConnections API operation for vpc.

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

func (*Vpc) DescribeVpcPeeringConnectionsRequest ¶

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

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

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

func (*Vpc) DescribeVpcPeeringConnectionsWithContext ¶

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

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

See DescribeVpcPeeringConnections 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 (*Vpc) DescribeVpcs ¶

func (c *Vpc) DescribeVpcs(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeVpcs API operation for vpc.

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

func (*Vpc) DescribeVpcsRequest ¶

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

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

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

func (*Vpc) DescribeVpcsWithContext ¶

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

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

See DescribeVpcs 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 (*Vpc) DescribeVpnGatewayRoutes ¶

func (c *Vpc) DescribeVpnGatewayRoutes(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeVpnGatewayRoutes API operation for vpc.

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

func (*Vpc) DescribeVpnGatewayRoutesRequest ¶

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

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

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

func (*Vpc) DescribeVpnGatewayRoutesWithContext ¶

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

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

See DescribeVpnGatewayRoutes 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 (*Vpc) DescribeVpnGateways ¶

func (c *Vpc) DescribeVpnGateways(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeVpnGateways API operation for vpc.

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

func (*Vpc) DescribeVpnGatewaysRequest ¶

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

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

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

func (*Vpc) DescribeVpnGatewaysWithContext ¶

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

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

See DescribeVpnGateways 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 (*Vpc) DescribeVpnTunnels ¶

func (c *Vpc) DescribeVpnTunnels(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeVpnTunnels API operation for vpc.

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

func (*Vpc) DescribeVpnTunnelsRequest ¶

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

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

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

func (*Vpc) DescribeVpnTunnelsWithContext ¶

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

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

See DescribeVpnTunnels 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 (*Vpc) DetachDirectConnectGateway ¶

func (c *Vpc) DetachDirectConnectGateway(input *map[string]interface{}) (*map[string]interface{}, error)

DetachDirectConnectGateway API operation for vpc.

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

func (*Vpc) DetachDirectConnectGatewayRequest ¶

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

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

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

func (*Vpc) DetachDirectConnectGatewayWithContext ¶

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

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

See DetachDirectConnectGateway 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 (*Vpc) DisassociateInstance ¶

func (c *Vpc) DisassociateInstance(input *map[string]interface{}) (*map[string]interface{}, error)

DisassociateInstance API operation for vpc.

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

func (*Vpc) DisassociateInstanceRequest ¶

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

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

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

func (*Vpc) DisassociateInstanceWithContext ¶

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

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

See DisassociateInstance 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 (*Vpc) DisassociateNat ¶

func (c *Vpc) DisassociateNat(input *map[string]interface{}) (*map[string]interface{}, error)

DisassociateNat API operation for vpc.

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

func (*Vpc) DisassociateNatRequest ¶

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

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

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

func (*Vpc) DisassociateNatWithContext ¶

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

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

See DisassociateNat 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 (*Vpc) DisassociateNetworkAcl ¶

func (c *Vpc) DisassociateNetworkAcl(input *map[string]interface{}) (*map[string]interface{}, error)

DisassociateNetworkAcl API operation for vpc.

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

func (*Vpc) DisassociateNetworkAclRequest ¶

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

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

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

func (*Vpc) DisassociateNetworkAclWithContext ¶

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

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

See DisassociateNetworkAcl 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 (*Vpc) ModifyCustomerGateway ¶

func (c *Vpc) ModifyCustomerGateway(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyCustomerGateway API operation for vpc.

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

func (*Vpc) ModifyCustomerGatewayRequest ¶

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

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

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

func (*Vpc) ModifyCustomerGatewayWithContext ¶

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

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

See ModifyCustomerGateway 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 (*Vpc) ModifyDirectConnectGateway ¶

func (c *Vpc) ModifyDirectConnectGateway(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyDirectConnectGateway API operation for vpc.

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

func (*Vpc) ModifyDirectConnectGatewayRequest ¶

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

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

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

func (*Vpc) ModifyDirectConnectGatewayWithContext ¶

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

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

See ModifyDirectConnectGateway 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 (*Vpc) ModifyDirectConnectInterface ¶

func (c *Vpc) ModifyDirectConnectInterface(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyDirectConnectInterface API operation for vpc.

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

func (*Vpc) ModifyDirectConnectInterfaceRequest ¶

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

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

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

func (*Vpc) ModifyDirectConnectInterfaceWithContext ¶

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

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

See ModifyDirectConnectInterface 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 (*Vpc) ModifyDnat ¶

func (c *Vpc) ModifyDnat(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyDnat API operation for vpc.

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

func (*Vpc) ModifyDnatRequest ¶

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

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

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

func (*Vpc) ModifyDnatWithContext ¶

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

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

See ModifyDnat 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 (*Vpc) ModifyIpv6PublicIp ¶

func (c *Vpc) ModifyIpv6PublicIp(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyIpv6PublicIp API operation for vpc.

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

func (*Vpc) ModifyIpv6PublicIpRequest ¶

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

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

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

func (*Vpc) ModifyIpv6PublicIpWithContext ¶

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

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

See ModifyIpv6PublicIp 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 (*Vpc) ModifyNat ¶

func (c *Vpc) ModifyNat(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyNat API operation for vpc.

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

func (*Vpc) ModifyNatRateLimit ¶

func (c *Vpc) ModifyNatRateLimit(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyNatRateLimit API operation for vpc.

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

func (*Vpc) ModifyNatRateLimitRequest ¶

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

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

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

func (*Vpc) ModifyNatRateLimitWithContext ¶

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

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

See ModifyNatRateLimit 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 (*Vpc) ModifyNatRequest ¶

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

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

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

func (*Vpc) ModifyNatWithContext ¶

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

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

See ModifyNat 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 (*Vpc) ModifyNetworkAcl ¶

func (c *Vpc) ModifyNetworkAcl(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyNetworkAcl API operation for vpc.

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

func (*Vpc) ModifyNetworkAclEntry ¶

func (c *Vpc) ModifyNetworkAclEntry(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyNetworkAclEntry API operation for vpc.

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

func (*Vpc) ModifyNetworkAclEntryRequest ¶

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

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

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

func (*Vpc) ModifyNetworkAclEntryWithContext ¶

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

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

See ModifyNetworkAclEntry 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 (*Vpc) ModifyNetworkAclRequest ¶

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

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

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

func (*Vpc) ModifyNetworkAclWithContext ¶

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

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

See ModifyNetworkAcl 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 (*Vpc) ModifyNetworkInterface ¶

func (c *Vpc) ModifyNetworkInterface(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyNetworkInterface API operation for vpc.

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

func (*Vpc) ModifyNetworkInterfaceRequest ¶

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

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

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

func (*Vpc) ModifyNetworkInterfaceWithContext ¶

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

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

See ModifyNetworkInterface 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 (*Vpc) ModifySecurityGroup ¶

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

ModifySecurityGroup API operation for vpc.

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

func (*Vpc) ModifySecurityGroupEntry ¶

func (c *Vpc) ModifySecurityGroupEntry(input *map[string]interface{}) (*map[string]interface{}, error)

ModifySecurityGroupEntry API operation for vpc.

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

func (*Vpc) ModifySecurityGroupEntryRequest ¶

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

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

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

func (*Vpc) ModifySecurityGroupEntryWithContext ¶

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

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

See ModifySecurityGroupEntry 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 (*Vpc) ModifySecurityGroupRequest ¶

func (c *Vpc) 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)
}

func (*Vpc) ModifySecurityGroupWithContext ¶

func (c *Vpc) 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 (*Vpc) ModifySubnet ¶

func (c *Vpc) ModifySubnet(input *map[string]interface{}) (*map[string]interface{}, error)

ModifySubnet API operation for vpc.

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

func (*Vpc) ModifySubnetRequest ¶

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

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

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

func (*Vpc) ModifySubnetWithContext ¶

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

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

See ModifySubnet 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 (*Vpc) ModifyVpc ¶

func (c *Vpc) ModifyVpc(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyVpc API operation for vpc.

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

func (*Vpc) ModifyVpcPeeringConnection ¶

func (c *Vpc) ModifyVpcPeeringConnection(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyVpcPeeringConnection API operation for vpc.

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

func (*Vpc) ModifyVpcPeeringConnectionRequest ¶

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

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

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

func (*Vpc) ModifyVpcPeeringConnectionWithContext ¶

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

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

See ModifyVpcPeeringConnection 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 (*Vpc) ModifyVpcRequest ¶

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

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

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

func (*Vpc) ModifyVpcWithContext ¶

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

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

See ModifyVpc 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 (*Vpc) ModifyVpnGateway ¶

func (c *Vpc) ModifyVpnGateway(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyVpnGateway API operation for vpc.

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

func (*Vpc) ModifyVpnGatewayRequest ¶

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

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

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

func (*Vpc) ModifyVpnGatewayWithContext ¶

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

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

See ModifyVpnGateway 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 (*Vpc) ModifyVpnTunnel ¶

func (c *Vpc) ModifyVpnTunnel(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyVpnTunnel API operation for vpc.

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

func (*Vpc) ModifyVpnTunnelRequest ¶

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

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

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

func (*Vpc) ModifyVpnTunnelWithContext ¶

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

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

See ModifyVpnTunnel 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 (*Vpc) RejectVpcPeeringConnection ¶

func (c *Vpc) RejectVpcPeeringConnection(input *map[string]interface{}) (*map[string]interface{}, error)

RejectVpcPeeringConnection API operation for vpc.

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

func (*Vpc) RejectVpcPeeringConnectionRequest ¶

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

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

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

func (*Vpc) RejectVpcPeeringConnectionWithContext ¶

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

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

See RejectVpcPeeringConnection 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 (*Vpc) ReleaseIpv6PublicIp ¶

func (c *Vpc) ReleaseIpv6PublicIp(input *map[string]interface{}) (*map[string]interface{}, error)

ReleaseIpv6PublicIp API operation for vpc.

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

func (*Vpc) ReleaseIpv6PublicIpRequest ¶

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

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

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

func (*Vpc) ReleaseIpv6PublicIpWithContext ¶

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

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

See ReleaseIpv6PublicIp 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 (*Vpc) RevokeSecurityGroupEntry ¶

func (c *Vpc) RevokeSecurityGroupEntry(input *map[string]interface{}) (*map[string]interface{}, error)

RevokeSecurityGroupEntry API operation for vpc.

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

func (*Vpc) RevokeSecurityGroupEntryRequest ¶

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

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

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

func (*Vpc) RevokeSecurityGroupEntryWithContext ¶

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

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

See RevokeSecurityGroupEntry 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 (*Vpc) UnassignPrivateIpAddress ¶

func (c *Vpc) UnassignPrivateIpAddress(input *map[string]interface{}) (*map[string]interface{}, error)

UnassignPrivateIpAddress API operation for vpc.

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

func (*Vpc) UnassignPrivateIpAddressRequest ¶

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

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

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

func (*Vpc) UnassignPrivateIpAddressWithContext ¶

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

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

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

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

Source Files ¶

View all Source files

Directories ¶

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

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