func (c *EC2) AttachClassicLinkVpc(input *AttachClassicLinkVpcInput) (*AttachClassicLinkVpcOutput, error) {
	req, out := c.AttachClassicLinkVpcRequest(input)
	err := req.Send()
	return out, err
}
AttachClassicLinkVpc API operation for Amazon Elastic Compute Cloud.

Links an EC2-Classic instance to a ClassicLink-enabled VPC through one or
more of the VPC's security groups. You cannot link an EC2-Classic instance
to more than one VPC at a time. You can only link an instance that's in the
running state. An instance is automatically unlinked from a VPC when it's
stopped - you can link it to the VPC again when you restart it.

After you've linked an instance, you cannot change the VPC security groups
that are associated with it. To change the security groups, you must first
unlink the instance, and then link it again.

Linking your instance to a VPC is sometimes referred to as attaching your
instance.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions
with awserr.Error's Code and Message methods to get detailed information about
the error.

See the AWS API reference guide for Amazon Elastic Compute Cloud's
API operation AttachClassicLinkVpc for usage and error information.
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
}