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) 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) 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) 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) 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) 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) 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) DeleteNat(input *map[string]interface{}) (*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) 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) 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) 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) 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) 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) 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) 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) 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) 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)

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