func (c *EC2) CancelConversionTaskRequest(input *CancelConversionTaskInput) (req *request.Request, output *CancelConversionTaskOutput) {
	op := &request.Operation{
		Name:       opCancelConversionTask,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CancelConversionTaskInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CancelConversionTaskOutput{}
	req.Data = output
	return
}
CancelConversionTaskRequest generates a request for the CancelConversionTask operation.
package ec2
import (
	"time"
	"github.com/aws/aws-sdk-go/aws/awsutil"
	"github.com/aws/aws-sdk-go/aws/request"
)
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 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)
	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)
	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"
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)
	output = &AttachInternetGatewayOutput{}
	req.Data = output
	return
}
func (c *EC2) AttachInternetGateway(input *AttachInternetGatewayInput) (*AttachInternetGatewayOutput, error) {
	req, out := c.AttachInternetGatewayRequest(input)
	err := req.Send()
	return out, err
}
const opAttachNetworkInterface = "AttachNetworkInterface"
func (c *EC2) AttachNetworkInterfaceRequest(input *AttachNetworkInterfaceInput) (req *request.Request, output *AttachNetworkInterfaceOutput) {
	op := &request.Operation{
		Name:       opAttachNetworkInterface,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AttachNetworkInterfaceInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AttachNetworkInterfaceOutput{}
	req.Data = output
	return
}
func (c *EC2) AttachNetworkInterface(input *AttachNetworkInterfaceInput) (*AttachNetworkInterfaceOutput, error) {
	req, out := c.AttachNetworkInterfaceRequest(input)
	err := req.Send()
	return out, err
}
const opAttachVolume = "AttachVolume"
func (c *EC2) AttachVolumeRequest(input *AttachVolumeInput) (req *request.Request, output *VolumeAttachment) {
	op := &request.Operation{
		Name:       opAttachVolume,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AttachVolumeInput{}
	}
	req = c.newRequest(op, input, output)
	output = &VolumeAttachment{}
	req.Data = output
	return
}
func (c *EC2) AttachVolume(input *AttachVolumeInput) (*VolumeAttachment, error) {
	req, out := c.AttachVolumeRequest(input)
	err := req.Send()
	return out, err
}
const opAttachVpnGateway = "AttachVpnGateway"
func (c *EC2) AttachVpnGatewayRequest(input *AttachVpnGatewayInput) (req *request.Request, output *AttachVpnGatewayOutput) {
	op := &request.Operation{
		Name:       opAttachVpnGateway,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AttachVpnGatewayInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AttachVpnGatewayOutput{}
	req.Data = output
	return
}
func (c *EC2) AttachVpnGateway(input *AttachVpnGatewayInput) (*AttachVpnGatewayOutput, error) {
	req, out := c.AttachVpnGatewayRequest(input)
	err := req.Send()
	return out, err
}
const opAuthorizeSecurityGroupEgress = "AuthorizeSecurityGroupEgress"
func (c *EC2) AuthorizeSecurityGroupEgressRequest(input *AuthorizeSecurityGroupEgressInput) (req *request.Request, output *AuthorizeSecurityGroupEgressOutput) {
	op := &request.Operation{
		Name:       opAuthorizeSecurityGroupEgress,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AuthorizeSecurityGroupEgressInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AuthorizeSecurityGroupEgressOutput{}
	req.Data = output
	return
}
func (c *EC2) AuthorizeSecurityGroupEgress(input *AuthorizeSecurityGroupEgressInput) (*AuthorizeSecurityGroupEgressOutput, error) {
	req, out := c.AuthorizeSecurityGroupEgressRequest(input)
	err := req.Send()
	return out, err
}
const opAuthorizeSecurityGroupIngress = "AuthorizeSecurityGroupIngress"
func (c *EC2) AuthorizeSecurityGroupIngressRequest(input *AuthorizeSecurityGroupIngressInput) (req *request.Request, output *AuthorizeSecurityGroupIngressOutput) {
	op := &request.Operation{
		Name:       opAuthorizeSecurityGroupIngress,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AuthorizeSecurityGroupIngressInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AuthorizeSecurityGroupIngressOutput{}
	req.Data = output
	return
}
func (c *EC2) AuthorizeSecurityGroupIngress(input *AuthorizeSecurityGroupIngressInput) (*AuthorizeSecurityGroupIngressOutput, error) {
	req, out := c.AuthorizeSecurityGroupIngressRequest(input)
	err := req.Send()
	return out, err
}
const opBundleInstance = "BundleInstance"
func (c *EC2) BundleInstanceRequest(input *BundleInstanceInput) (req *request.Request, output *BundleInstanceOutput) {
	op := &request.Operation{
		Name:       opBundleInstance,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &BundleInstanceInput{}
	}
	req = c.newRequest(op, input, output)
	output = &BundleInstanceOutput{}
	req.Data = output
	return
}
func (c *EC2) BundleInstance(input *BundleInstanceInput) (*BundleInstanceOutput, error) {
	req, out := c.BundleInstanceRequest(input)
	err := req.Send()
	return out, err
}
const opCancelBundleTask = "CancelBundleTask"
func (c *EC2) CancelBundleTaskRequest(input *CancelBundleTaskInput) (req *request.Request, output *CancelBundleTaskOutput) {
	op := &request.Operation{
		Name:       opCancelBundleTask,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CancelBundleTaskInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CancelBundleTaskOutput{}
	req.Data = output
	return
}
func (c *EC2) CancelBundleTask(input *CancelBundleTaskInput) (*CancelBundleTaskOutput, error) {
	req, out := c.CancelBundleTaskRequest(input)
	err := req.Send()
	return out, err
}
const opCancelConversionTask = "CancelConversionTask"