func (c *EC2) AttachInternetGatewayRequest(input *AttachInternetGatewayInput) (req *request.Request, output *AttachInternetGatewayOutput) {
	op := &request.Operation{
		Name:       opAttachInternetGateway,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AttachInternetGatewayInput{}
	}
	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output = &AttachInternetGatewayOutput{}
	req.Data = output
	return
}
AttachInternetGatewayRequest generates a "aws/request.Request" representing the
client's request for the AttachInternetGateway operation. The "output" return
value can be used to capture response data after the request's "Send" method
is called.

See AttachInternetGateway for usage and error information.

Creating a request object using this method should be used when you want to inject
custom logic into the request's lifecycle using a custom handler, or if you want to
access properties on the request object before or after sending the request. If
you just want the service response, call the AttachInternetGateway method directly
instead.

Note: You must call the "Send" method on the returned request object in order
to execute the request.

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

err := req.Send()
if err == nil { // resp is now filled
fmt.Println(resp)
}
package ec2
import (
	"fmt"
	"time"
	"github.com/aws/aws-sdk-go/aws/awsutil"
	"github.com/aws/aws-sdk-go/aws/request"
	"github.com/aws/aws-sdk-go/private/protocol"
	"github.com/aws/aws-sdk-go/private/protocol/ec2query"
)
const opAcceptReservedInstancesExchangeQuote = "AcceptReservedInstancesExchangeQuote"
func (c *EC2) AcceptReservedInstancesExchangeQuoteRequest(input *AcceptReservedInstancesExchangeQuoteInput) (req *request.Request, output *AcceptReservedInstancesExchangeQuoteOutput) {
	op := &request.Operation{
		Name:       opAcceptReservedInstancesExchangeQuote,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AcceptReservedInstancesExchangeQuoteInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AcceptReservedInstancesExchangeQuoteOutput{}
	req.Data = output
	return
}
func (c *EC2) AcceptReservedInstancesExchangeQuote(input *AcceptReservedInstancesExchangeQuoteInput) (*AcceptReservedInstancesExchangeQuoteOutput, error) {
	req, out := c.AcceptReservedInstancesExchangeQuoteRequest(input)
	err := req.Send()
	return out, err
}
const opAcceptVpcPeeringConnection = "AcceptVpcPeeringConnection"
func (c *EC2) AcceptVpcPeeringConnectionRequest(input *AcceptVpcPeeringConnectionInput) (req *request.Request, output *AcceptVpcPeeringConnectionOutput) {
	op := &request.Operation{
		Name:       opAcceptVpcPeeringConnection,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AcceptVpcPeeringConnectionInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AcceptVpcPeeringConnectionOutput{}
	req.Data = output
	return
}
func (c *EC2) AcceptVpcPeeringConnection(input *AcceptVpcPeeringConnectionInput) (*AcceptVpcPeeringConnectionOutput, error) {
	req, out := c.AcceptVpcPeeringConnectionRequest(input)
	err := req.Send()
	return out, err
}
const opAllocateAddress = "AllocateAddress"
func (c *EC2) AllocateAddressRequest(input *AllocateAddressInput) (req *request.Request, output *AllocateAddressOutput) {
	op := &request.Operation{
		Name:       opAllocateAddress,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AllocateAddressInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AllocateAddressOutput{}
	req.Data = output
	return
}
func (c *EC2) AllocateAddress(input *AllocateAddressInput) (*AllocateAddressOutput, error) {
	req, out := c.AllocateAddressRequest(input)
	err := req.Send()
	return out, err
}
const opAllocateHosts = "AllocateHosts"
func (c *EC2) AllocateHostsRequest(input *AllocateHostsInput) (req *request.Request, output *AllocateHostsOutput) {
	op := &request.Operation{
		Name:       opAllocateHosts,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AllocateHostsInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AllocateHostsOutput{}
	req.Data = output
	return
}
func (c *EC2) AllocateHosts(input *AllocateHostsInput) (*AllocateHostsOutput, error) {
	req, out := c.AllocateHostsRequest(input)
	err := req.Send()
	return out, err
}
const opAssignPrivateIpAddresses = "AssignPrivateIpAddresses"
func (c *EC2) AssignPrivateIpAddressesRequest(input *AssignPrivateIpAddressesInput) (req *request.Request, output *AssignPrivateIpAddressesOutput) {
	op := &request.Operation{
		Name:       opAssignPrivateIpAddresses,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AssignPrivateIpAddressesInput{}
	}
	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output = &AssignPrivateIpAddressesOutput{}
	req.Data = output
	return
}
func (c *EC2) AssignPrivateIpAddresses(input *AssignPrivateIpAddressesInput) (*AssignPrivateIpAddressesOutput, error) {
	req, out := c.AssignPrivateIpAddressesRequest(input)
	err := req.Send()
	return out, err
}
const opAssociateAddress = "AssociateAddress"
func (c *EC2) AssociateAddressRequest(input *AssociateAddressInput) (req *request.Request, output *AssociateAddressOutput) {
	op := &request.Operation{
		Name:       opAssociateAddress,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AssociateAddressInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AssociateAddressOutput{}
	req.Data = output
	return
}
func (c *EC2) AssociateAddress(input *AssociateAddressInput) (*AssociateAddressOutput, error) {
	req, out := c.AssociateAddressRequest(input)
	err := req.Send()
	return out, err
}
const opAssociateDhcpOptions = "AssociateDhcpOptions"
func (c *EC2) AssociateDhcpOptionsRequest(input *AssociateDhcpOptionsInput) (req *request.Request, output *AssociateDhcpOptionsOutput) {
	op := &request.Operation{
		Name:       opAssociateDhcpOptions,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AssociateDhcpOptionsInput{}
	}
	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output = &AssociateDhcpOptionsOutput{}
	req.Data = output
	return
}
func (c *EC2) AssociateDhcpOptions(input *AssociateDhcpOptionsInput) (*AssociateDhcpOptionsOutput, error) {
	req, out := c.AssociateDhcpOptionsRequest(input)
	err := req.Send()
	return out, err
}
const opAssociateRouteTable = "AssociateRouteTable"
func (c *EC2) AssociateRouteTableRequest(input *AssociateRouteTableInput) (req *request.Request, output *AssociateRouteTableOutput) {
	op := &request.Operation{
		Name:       opAssociateRouteTable,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AssociateRouteTableInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AssociateRouteTableOutput{}
	req.Data = output
	return
}
func (c *EC2) AssociateRouteTable(input *AssociateRouteTableInput) (*AssociateRouteTableOutput, error) {
	req, out := c.AssociateRouteTableRequest(input)
	err := req.Send()
	return out, err
}
const opAttachClassicLinkVpc = "AttachClassicLinkVpc"
func (c *EC2) AttachClassicLinkVpcRequest(input *AttachClassicLinkVpcInput) (req *request.Request, output *AttachClassicLinkVpcOutput) {
	op := &request.Operation{
		Name:       opAttachClassicLinkVpc,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AttachClassicLinkVpcInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AttachClassicLinkVpcOutput{}
	req.Data = output
	return
}
func (c *EC2) AttachClassicLinkVpc(input *AttachClassicLinkVpcInput) (*AttachClassicLinkVpcOutput, error) {
	req, out := c.AttachClassicLinkVpcRequest(input)
	err := req.Send()
	return out, err
}
const opAttachInternetGateway = "AttachInternetGateway"