vpc

Documentation

Index

• Constants
• type Vpc
  • func ExtraNew(info *utils.UrlInfo, p client.ConfigProvider, cfgs ...*aws.Config) *Vpc
  • func New(p client.ConfigProvider, cfgs ...*aws.Config) *Vpc
  • func SdkNew(p client.ConfigProvider, cfgs *ksc.Config, info ...*utils.UrlInfo) *Vpc
  • func (c *Vpc) AcceptVpcPeeringConnection(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) AcceptVpcPeeringConnectionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) AcceptVpcPeeringConnectionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) AddNatIp(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) AddNatIpRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) AddNatIpWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) AllocateSubnetIpv6CidrBlock(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) AllocateSubnetIpv6CidrBlockRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) AllocateSubnetIpv6CidrBlockWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) AssignPrivateIpAddress(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) AssignPrivateIpAddressRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) AssignPrivateIpAddressWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) AssociateInstance(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) AssociateInstanceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) AssociateInstanceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) AssociateNat(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) AssociateNatRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) AssociateNatWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) AssociateNetworkAcl(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) AssociateNetworkAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) AssociateNetworkAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) AssociateVpcCidrBlock(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) AssociateVpcCidrBlockRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) AssociateVpcCidrBlockWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) AttachDirectConnectGateway(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) AttachDirectConnectGatewayRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) AttachDirectConnectGatewayWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) AuthorizeSecurityGroupEntry(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) AuthorizeSecurityGroupEntryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) AuthorizeSecurityGroupEntryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) CreateCustomerGateway(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) CreateCustomerGatewayRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) CreateCustomerGatewayWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) CreateDirectConnectExtraCidr(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) CreateDirectConnectExtraCidrRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) CreateDirectConnectExtraCidrWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) CreateDirectConnectGateway(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) CreateDirectConnectGatewayRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) CreateDirectConnectGatewayWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) CreateDirectConnectInterface(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) CreateDirectConnectInterfaceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) CreateDirectConnectInterfaceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) CreateDirectConnectReomteCidr(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) CreateDirectConnectReomteCidrRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) CreateDirectConnectReomteCidrWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) CreateDnat(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) CreateDnatRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) CreateDnatWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) CreateIpv6PublicIp(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) CreateIpv6PublicIpRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) CreateIpv6PublicIpWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) CreateNat(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) CreateNatRateLimit(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) CreateNatRateLimitRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) CreateNatRateLimitWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) CreateNatRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) CreateNatWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) CreateNetworkAcl(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) CreateNetworkAclEntry(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) CreateNetworkAclEntryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) CreateNetworkAclEntryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) CreateNetworkAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) CreateNetworkAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) CreateNetworkInterface(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) CreateNetworkInterfaceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) CreateNetworkInterfaceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) CreateRoute(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) CreateRouteRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) CreateRouteWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) CreateSecurityGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) CreateSecurityGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) CreateSecurityGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) CreateSubnet(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) CreateSubnetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) CreateSubnetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) CreateVpc(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) CreateVpcPeeringConnection(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) CreateVpcPeeringConnectionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) CreateVpcPeeringConnectionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) CreateVpcRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) CreateVpcWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) CreateVpnGateway(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) CreateVpnGatewayRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) CreateVpnGatewayRoute(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) CreateVpnGatewayRouteRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) CreateVpnGatewayRouteWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) CreateVpnGatewayWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) CreateVpnTunnel(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) CreateVpnTunnelRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) CreateVpnTunnelWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteCustomerGateway(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteCustomerGatewayRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DeleteCustomerGatewayWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteDirectConnectExtraCidr(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteDirectConnectExtraCidrRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DeleteDirectConnectExtraCidrWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteDirectConnectGateway(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteDirectConnectGatewayRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DeleteDirectConnectGatewayWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteDirectConnectInterface(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteDirectConnectInterfaceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DeleteDirectConnectInterfaceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteDirectConnectReomteCidr(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteDirectConnectReomteCidrRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DeleteDirectConnectReomteCidrWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteDnat(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteDnatRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DeleteDnatWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteNat(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteNatIp(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteNatIpRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DeleteNatIpWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteNatRateLimit(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteNatRateLimitRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DeleteNatRateLimitWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteNatRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DeleteNatWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteNetworkAcl(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteNetworkAclEntry(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteNetworkAclEntryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DeleteNetworkAclEntryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteNetworkAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DeleteNetworkAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteNetworkInterface(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteNetworkInterfaceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DeleteNetworkInterfaceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteRoute(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteRouteRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DeleteRouteWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteSecurityGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteSecurityGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DeleteSecurityGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteSubnet(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteSubnetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DeleteSubnetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteVpc(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteVpcPeeringConnection(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteVpcPeeringConnectionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DeleteVpcPeeringConnectionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteVpcRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DeleteVpcWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteVpnGateway(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteVpnGatewayRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DeleteVpnGatewayRoute(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteVpnGatewayRouteRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DeleteVpnGatewayRouteWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteVpnGatewayWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteVpnTunnel(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DeleteVpnTunnelRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DeleteVpnTunnelWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeAvailabilityZones(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeAvailabilityZonesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeAvailabilityZonesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeCustomerGateways(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeCustomerGatewaysRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeCustomerGatewaysWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeDirectConnectGateways(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeDirectConnectGatewaysRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeDirectConnectGatewaysWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeDirectConnectInterfaces(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeDirectConnectInterfacesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeDirectConnectInterfacesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeDirectConnects(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeDirectConnectsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeDirectConnectsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeDnats(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeDnatsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeDnatsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeInternetGateways(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeInternetGatewaysRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeInternetGatewaysWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeIpv6NetworkInterfaces(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeIpv6NetworkInterfacesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeIpv6NetworkInterfacesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeIpv6PublicIpAddresses(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeIpv6PublicIpAddressesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeIpv6PublicIpAddressesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeNatRateLimit(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeNatRateLimitRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeNatRateLimitWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeNats(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeNatsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeNatsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeNetworkAcls(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeNetworkAclsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeNetworkAclsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeNetworkInterfaces(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeNetworkInterfacesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeNetworkInterfacesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeRoutes(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeRoutesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeRoutesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeSecurityGroups(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeSecurityGroupsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeSecurityGroupsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeSubnetAllocatedIpAddresses(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeSubnetAllocatedIpAddressesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeSubnetAllocatedIpAddressesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeSubnetAvailableAddresses(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeSubnetAvailableAddressesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeSubnetAvailableAddressesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeSubnets(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeSubnetsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeSubnetsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeVpcPeeringConnections(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeVpcPeeringConnectionsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeVpcPeeringConnectionsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeVpcs(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeVpcsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeVpcsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeVpnGatewayRoutes(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeVpnGatewayRoutesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeVpnGatewayRoutesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeVpnGateways(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeVpnGatewaysRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeVpnGatewaysWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeVpnTunnels(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DescribeVpnTunnelsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DescribeVpnTunnelsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DetachDirectConnectGateway(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DetachDirectConnectGatewayRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DetachDirectConnectGatewayWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DisassociateInstance(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DisassociateInstanceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DisassociateInstanceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DisassociateNat(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DisassociateNatRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DisassociateNatWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) DisassociateNetworkAcl(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) DisassociateNetworkAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) DisassociateNetworkAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyCustomerGateway(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyCustomerGatewayRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) ModifyCustomerGatewayWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyDirectConnectGateway(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyDirectConnectGatewayRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) ModifyDirectConnectGatewayWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyDirectConnectInterface(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyDirectConnectInterfaceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) ModifyDirectConnectInterfaceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyDnat(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyDnatRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) ModifyDnatWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyIpv6PublicIp(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyIpv6PublicIpRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) ModifyIpv6PublicIpWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyNat(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyNatRateLimit(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyNatRateLimitRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) ModifyNatRateLimitWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyNatRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) ModifyNatWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyNetworkAcl(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyNetworkAclEntry(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyNetworkAclEntryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) ModifyNetworkAclEntryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyNetworkAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) ModifyNetworkAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyNetworkInterface(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyNetworkInterfaceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) ModifyNetworkInterfaceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) ModifySecurityGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) ModifySecurityGroupEntry(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) ModifySecurityGroupEntryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) ModifySecurityGroupEntryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) ModifySecurityGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) ModifySecurityGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) ModifySubnet(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) ModifySubnetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) ModifySubnetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyVpc(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyVpcPeeringConnection(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyVpcPeeringConnectionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) ModifyVpcPeeringConnectionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyVpcRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) ModifyVpcWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyVpnGateway(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyVpnGatewayRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) ModifyVpnGatewayWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyVpnTunnel(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) ModifyVpnTunnelRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) ModifyVpnTunnelWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) RejectVpcPeeringConnection(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) RejectVpcPeeringConnectionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) RejectVpcPeeringConnectionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) ReleaseIpv6PublicIp(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) ReleaseIpv6PublicIpRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) ReleaseIpv6PublicIpWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) RevokeSecurityGroupEntry(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) RevokeSecurityGroupEntryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) RevokeSecurityGroupEntryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Vpc) UnassignPrivateIpAddress(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Vpc) UnassignPrivateIpAddressRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Vpc) UnassignPrivateIpAddressWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

Constants

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.