Merge branch 'cloudwatch' of https://github.com/mtanda/grafana into cloudwatch

Godeps/Godeps.json

@@ -28,6 +28,11 @@
 			"Comment": "v0.7.3",
 			"Rev": "bed164a424e75154a40550c04c313ef51a7bb275"
 		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/internal/protocol/ec2query",
+			"Comment": "v0.7.3",
+			"Rev": "bed164a424e75154a40550c04c313ef51a7bb275"
+		},
 		{
 			"ImportPath": "github.com/aws/aws-sdk-go/internal/protocol/query",
 			"Comment": "v0.7.3",
@@ -53,6 +58,11 @@
 			"Comment": "v0.7.3",
 			"Rev": "bed164a424e75154a40550c04c313ef51a7bb275"
 		},
+		{
+			"ImportPath": "github.com/aws/aws-sdk-go/service/ec2",
+			"Comment": "v0.7.3",
+			"Rev": "bed164a424e75154a40550c04c313ef51a7bb275"
+		},
 		{
 			"ImportPath": "github.com/davecgh/go-spew/spew",
 			"Rev": "2df174808ee097f90d259e432cc04442cf60be21"

Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/ec2query/build.go

@@ -0,0 +1,32 @@
+// Package ec2query provides serialisation of AWS EC2 requests and responses.
+package ec2query
+
+//go:generate go run ../../fixtures/protocol/generate.go ../../fixtures/protocol/input/ec2.json build_test.go
+
+import (
+	"net/url"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/aws/aws-sdk-go/internal/protocol/query/queryutil"
+)
+
+// Build builds a request for the EC2 protocol.
+func Build(r *aws.Request) {
+	body := url.Values{
+		"Action":  {r.Operation.Name},
+		"Version": {r.Service.APIVersion},
+	}
+	if err := queryutil.Parse(body, r.Params, true); err != nil {
+		r.Error = awserr.New("SerializationError", "failed encoding EC2 Query request", err)
+	}
+
+	if r.ExpireTime == 0 {
+		r.HTTPRequest.Method = "POST"
+		r.HTTPRequest.Header.Set("Content-Type", "application/x-www-form-urlencoded; charset=utf-8")
+		r.SetBufferBody([]byte(body.Encode()))
+	} else { // This is a pre-signed request
+		r.HTTPRequest.Method = "GET"
+		r.HTTPRequest.URL.RawQuery = body.Encode()
+	}
+}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/ec2query/build_test.go

@@ -0,0 +1,860 @@
+package ec2query_test
+
+import (
+	"bytes"
+	"encoding/json"
+	"encoding/xml"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/internal/protocol/ec2query"
+	"github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil"
+	"github.com/aws/aws-sdk-go/internal/signer/v4"
+	"github.com/aws/aws-sdk-go/internal/util"
+	"github.com/stretchr/testify/assert"
+)
+
+var _ bytes.Buffer // always import bytes
+var _ http.Request
+var _ json.Marshaler
+var _ time.Time
+var _ xmlutil.XMLNode
+var _ xml.Attr
+var _ = ioutil.Discard
+var _ = util.Trim("")
+var _ = url.Values{}
+var _ = io.EOF
+
+type InputService1ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService1ProtocolTest client.
+func NewInputService1ProtocolTest(config *aws.Config) *InputService1ProtocolTest {
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "inputservice1protocoltest",
+		APIVersion:  "2014-01-01",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(ec2query.Build)
+	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
+
+	return &InputService1ProtocolTest{service}
+}
+
+// newRequest creates a new request for a InputService1ProtocolTest operation and runs any
+// custom request initialization.
+func (c *InputService1ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+	req := aws.NewRequest(c.Service, op, params, data)
+
+	return req
+}
+
+const opInputService1TestCaseOperation1 = "OperationName"
+
+// InputService1TestCaseOperation1Request generates a request for the InputService1TestCaseOperation1 operation.
+func (c *InputService1ProtocolTest) InputService1TestCaseOperation1Request(input *InputService1TestShapeInputShape) (req *aws.Request, output *InputService1TestShapeInputService1TestCaseOperation1Output) {
+	op := &aws.Operation{
+		Name: opInputService1TestCaseOperation1,
+	}
+
+	if input == nil {
+		input = &InputService1TestShapeInputShape{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &InputService1TestShapeInputService1TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService1ProtocolTest) InputService1TestCaseOperation1(input *InputService1TestShapeInputShape) (*InputService1TestShapeInputService1TestCaseOperation1Output, error) {
+	req, out := c.InputService1TestCaseOperation1Request(input)
+	err := req.Send()
+	return out, err
+}
+
+type InputService1TestShapeInputService1TestCaseOperation1Output struct {
+	metadataInputService1TestShapeInputService1TestCaseOperation1Output `json:"-" xml:"-"`
+}
+
+type metadataInputService1TestShapeInputService1TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService1TestShapeInputShape struct {
+	Bar *string `type:"string"`
+
+	Foo *string `type:"string"`
+
+	metadataInputService1TestShapeInputShape `json:"-" xml:"-"`
+}
+
+type metadataInputService1TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService2ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService2ProtocolTest client.
+func NewInputService2ProtocolTest(config *aws.Config) *InputService2ProtocolTest {
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "inputservice2protocoltest",
+		APIVersion:  "2014-01-01",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(ec2query.Build)
+	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
+
+	return &InputService2ProtocolTest{service}
+}
+
+// newRequest creates a new request for a InputService2ProtocolTest operation and runs any
+// custom request initialization.
+func (c *InputService2ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+	req := aws.NewRequest(c.Service, op, params, data)
+
+	return req
+}
+
+const opInputService2TestCaseOperation1 = "OperationName"
+
+// InputService2TestCaseOperation1Request generates a request for the InputService2TestCaseOperation1 operation.
+func (c *InputService2ProtocolTest) InputService2TestCaseOperation1Request(input *InputService2TestShapeInputShape) (req *aws.Request, output *InputService2TestShapeInputService2TestCaseOperation1Output) {
+	op := &aws.Operation{
+		Name: opInputService2TestCaseOperation1,
+	}
+
+	if input == nil {
+		input = &InputService2TestShapeInputShape{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &InputService2TestShapeInputService2TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService2ProtocolTest) InputService2TestCaseOperation1(input *InputService2TestShapeInputShape) (*InputService2TestShapeInputService2TestCaseOperation1Output, error) {
+	req, out := c.InputService2TestCaseOperation1Request(input)
+	err := req.Send()
+	return out, err
+}
+
+type InputService2TestShapeInputService2TestCaseOperation1Output struct {
+	metadataInputService2TestShapeInputService2TestCaseOperation1Output `json:"-" xml:"-"`
+}
+
+type metadataInputService2TestShapeInputService2TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService2TestShapeInputShape struct {
+	Bar *string `locationName:"barLocationName" type:"string"`
+
+	Foo *string `type:"string"`
+
+	Yuck *string `locationName:"yuckLocationName" queryName:"yuckQueryName" type:"string"`
+
+	metadataInputService2TestShapeInputShape `json:"-" xml:"-"`
+}
+
+type metadataInputService2TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService3ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService3ProtocolTest client.
+func NewInputService3ProtocolTest(config *aws.Config) *InputService3ProtocolTest {
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "inputservice3protocoltest",
+		APIVersion:  "2014-01-01",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(ec2query.Build)
+	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
+
+	return &InputService3ProtocolTest{service}
+}
+
+// newRequest creates a new request for a InputService3ProtocolTest operation and runs any
+// custom request initialization.
+func (c *InputService3ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+	req := aws.NewRequest(c.Service, op, params, data)
+
+	return req
+}
+
+const opInputService3TestCaseOperation1 = "OperationName"
+
+// InputService3TestCaseOperation1Request generates a request for the InputService3TestCaseOperation1 operation.
+func (c *InputService3ProtocolTest) InputService3TestCaseOperation1Request(input *InputService3TestShapeInputShape) (req *aws.Request, output *InputService3TestShapeInputService3TestCaseOperation1Output) {
+	op := &aws.Operation{
+		Name: opInputService3TestCaseOperation1,
+	}
+
+	if input == nil {
+		input = &InputService3TestShapeInputShape{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &InputService3TestShapeInputService3TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService3ProtocolTest) InputService3TestCaseOperation1(input *InputService3TestShapeInputShape) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) {
+	req, out := c.InputService3TestCaseOperation1Request(input)
+	err := req.Send()
+	return out, err
+}
+
+type InputService3TestShapeInputService3TestCaseOperation1Output struct {
+	metadataInputService3TestShapeInputService3TestCaseOperation1Output `json:"-" xml:"-"`
+}
+
+type metadataInputService3TestShapeInputService3TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService3TestShapeInputShape struct {
+	StructArg *InputService3TestShapeStructType `locationName:"Struct" type:"structure"`
+
+	metadataInputService3TestShapeInputShape `json:"-" xml:"-"`
+}
+
+type metadataInputService3TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService3TestShapeStructType struct {
+	ScalarArg *string `locationName:"Scalar" type:"string"`
+
+	metadataInputService3TestShapeStructType `json:"-" xml:"-"`
+}
+
+type metadataInputService3TestShapeStructType struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService4ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService4ProtocolTest client.
+func NewInputService4ProtocolTest(config *aws.Config) *InputService4ProtocolTest {
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "inputservice4protocoltest",
+		APIVersion:  "2014-01-01",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(ec2query.Build)
+	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
+
+	return &InputService4ProtocolTest{service}
+}
+
+// newRequest creates a new request for a InputService4ProtocolTest operation and runs any
+// custom request initialization.
+func (c *InputService4ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+	req := aws.NewRequest(c.Service, op, params, data)
+
+	return req
+}
+
+const opInputService4TestCaseOperation1 = "OperationName"
+
+// InputService4TestCaseOperation1Request generates a request for the InputService4TestCaseOperation1 operation.
+func (c *InputService4ProtocolTest) InputService4TestCaseOperation1Request(input *InputService4TestShapeInputShape) (req *aws.Request, output *InputService4TestShapeInputService4TestCaseOperation1Output) {
+	op := &aws.Operation{
+		Name: opInputService4TestCaseOperation1,
+	}
+
+	if input == nil {
+		input = &InputService4TestShapeInputShape{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &InputService4TestShapeInputService4TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService4ProtocolTest) InputService4TestCaseOperation1(input *InputService4TestShapeInputShape) (*InputService4TestShapeInputService4TestCaseOperation1Output, error) {
+	req, out := c.InputService4TestCaseOperation1Request(input)
+	err := req.Send()
+	return out, err
+}
+
+type InputService4TestShapeInputService4TestCaseOperation1Output struct {
+	metadataInputService4TestShapeInputService4TestCaseOperation1Output `json:"-" xml:"-"`
+}
+
+type metadataInputService4TestShapeInputService4TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService4TestShapeInputShape struct {
+	ListArg []*string `type:"list"`
+
+	metadataInputService4TestShapeInputShape `json:"-" xml:"-"`
+}
+
+type metadataInputService4TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService5ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService5ProtocolTest client.
+func NewInputService5ProtocolTest(config *aws.Config) *InputService5ProtocolTest {
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "inputservice5protocoltest",
+		APIVersion:  "2014-01-01",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(ec2query.Build)
+	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
+
+	return &InputService5ProtocolTest{service}
+}
+
+// newRequest creates a new request for a InputService5ProtocolTest operation and runs any
+// custom request initialization.
+func (c *InputService5ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+	req := aws.NewRequest(c.Service, op, params, data)
+
+	return req
+}
+
+const opInputService5TestCaseOperation1 = "OperationName"
+
+// InputService5TestCaseOperation1Request generates a request for the InputService5TestCaseOperation1 operation.
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation1Request(input *InputService5TestShapeInputShape) (req *aws.Request, output *InputService5TestShapeInputService5TestCaseOperation1Output) {
+	op := &aws.Operation{
+		Name: opInputService5TestCaseOperation1,
+	}
+
+	if input == nil {
+		input = &InputService5TestShapeInputShape{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &InputService5TestShapeInputService5TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation1(input *InputService5TestShapeInputShape) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) {
+	req, out := c.InputService5TestCaseOperation1Request(input)
+	err := req.Send()
+	return out, err
+}
+
+type InputService5TestShapeInputService5TestCaseOperation1Output struct {
+	metadataInputService5TestShapeInputService5TestCaseOperation1Output `json:"-" xml:"-"`
+}
+
+type metadataInputService5TestShapeInputService5TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService5TestShapeInputShape struct {
+	ListArg []*string `locationName:"ListMemberName" locationNameList:"item" type:"list"`
+
+	metadataInputService5TestShapeInputShape `json:"-" xml:"-"`
+}
+
+type metadataInputService5TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService6ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService6ProtocolTest client.
+func NewInputService6ProtocolTest(config *aws.Config) *InputService6ProtocolTest {
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "inputservice6protocoltest",
+		APIVersion:  "2014-01-01",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(ec2query.Build)
+	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
+
+	return &InputService6ProtocolTest{service}
+}
+
+// newRequest creates a new request for a InputService6ProtocolTest operation and runs any
+// custom request initialization.
+func (c *InputService6ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+	req := aws.NewRequest(c.Service, op, params, data)
+
+	return req
+}
+
+const opInputService6TestCaseOperation1 = "OperationName"
+
+// InputService6TestCaseOperation1Request generates a request for the InputService6TestCaseOperation1 operation.
+func (c *InputService6ProtocolTest) InputService6TestCaseOperation1Request(input *InputService6TestShapeInputShape) (req *aws.Request, output *InputService6TestShapeInputService6TestCaseOperation1Output) {
+	op := &aws.Operation{
+		Name: opInputService6TestCaseOperation1,
+	}
+
+	if input == nil {
+		input = &InputService6TestShapeInputShape{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &InputService6TestShapeInputService6TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService6ProtocolTest) InputService6TestCaseOperation1(input *InputService6TestShapeInputShape) (*InputService6TestShapeInputService6TestCaseOperation1Output, error) {
+	req, out := c.InputService6TestCaseOperation1Request(input)
+	err := req.Send()
+	return out, err
+}
+
+type InputService6TestShapeInputService6TestCaseOperation1Output struct {
+	metadataInputService6TestShapeInputService6TestCaseOperation1Output `json:"-" xml:"-"`
+}
+
+type metadataInputService6TestShapeInputService6TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService6TestShapeInputShape struct {
+	ListArg []*string `locationName:"ListMemberName" queryName:"ListQueryName" locationNameList:"item" type:"list"`
+
+	metadataInputService6TestShapeInputShape `json:"-" xml:"-"`
+}
+
+type metadataInputService6TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService7ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService7ProtocolTest client.
+func NewInputService7ProtocolTest(config *aws.Config) *InputService7ProtocolTest {
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "inputservice7protocoltest",
+		APIVersion:  "2014-01-01",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(ec2query.Build)
+	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
+
+	return &InputService7ProtocolTest{service}
+}
+
+// newRequest creates a new request for a InputService7ProtocolTest operation and runs any
+// custom request initialization.
+func (c *InputService7ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+	req := aws.NewRequest(c.Service, op, params, data)
+
+	return req
+}
+
+const opInputService7TestCaseOperation1 = "OperationName"
+
+// InputService7TestCaseOperation1Request generates a request for the InputService7TestCaseOperation1 operation.
+func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input *InputService7TestShapeInputShape) (req *aws.Request, output *InputService7TestShapeInputService7TestCaseOperation1Output) {
+	op := &aws.Operation{
+		Name: opInputService7TestCaseOperation1,
+	}
+
+	if input == nil {
+		input = &InputService7TestShapeInputShape{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &InputService7TestShapeInputService7TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService7ProtocolTest) InputService7TestCaseOperation1(input *InputService7TestShapeInputShape) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) {
+	req, out := c.InputService7TestCaseOperation1Request(input)
+	err := req.Send()
+	return out, err
+}
+
+type InputService7TestShapeInputService7TestCaseOperation1Output struct {
+	metadataInputService7TestShapeInputService7TestCaseOperation1Output `json:"-" xml:"-"`
+}
+
+type metadataInputService7TestShapeInputService7TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService7TestShapeInputShape struct {
+	BlobArg []byte `type:"blob"`
+
+	metadataInputService7TestShapeInputShape `json:"-" xml:"-"`
+}
+
+type metadataInputService7TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService8ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService8ProtocolTest client.
+func NewInputService8ProtocolTest(config *aws.Config) *InputService8ProtocolTest {
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "inputservice8protocoltest",
+		APIVersion:  "2014-01-01",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(ec2query.Build)
+	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
+
+	return &InputService8ProtocolTest{service}
+}
+
+// newRequest creates a new request for a InputService8ProtocolTest operation and runs any
+// custom request initialization.
+func (c *InputService8ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+	req := aws.NewRequest(c.Service, op, params, data)
+
+	return req
+}
+
+const opInputService8TestCaseOperation1 = "OperationName"
+
+// InputService8TestCaseOperation1Request generates a request for the InputService8TestCaseOperation1 operation.
+func (c *InputService8ProtocolTest) InputService8TestCaseOperation1Request(input *InputService8TestShapeInputShape) (req *aws.Request, output *InputService8TestShapeInputService8TestCaseOperation1Output) {
+	op := &aws.Operation{
+		Name: opInputService8TestCaseOperation1,
+	}
+
+	if input == nil {
+		input = &InputService8TestShapeInputShape{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &InputService8TestShapeInputService8TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService8ProtocolTest) InputService8TestCaseOperation1(input *InputService8TestShapeInputShape) (*InputService8TestShapeInputService8TestCaseOperation1Output, error) {
+	req, out := c.InputService8TestCaseOperation1Request(input)
+	err := req.Send()
+	return out, err
+}
+
+type InputService8TestShapeInputService8TestCaseOperation1Output struct {
+	metadataInputService8TestShapeInputService8TestCaseOperation1Output `json:"-" xml:"-"`
+}
+
+type metadataInputService8TestShapeInputService8TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService8TestShapeInputShape struct {
+	TimeArg *time.Time `type:"timestamp" timestampFormat:"iso8601"`
+
+	metadataInputService8TestShapeInputShape `json:"-" xml:"-"`
+}
+
+type metadataInputService8TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+//
+// Tests begin here
+//
+
+func TestInputService1ProtocolTestScalarMembersCase1(t *testing.T) {
+	svc := NewInputService1ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService1TestShapeInputShape{
+		Bar: aws.String("val2"),
+		Foo: aws.String("val1"),
+	}
+	req, _ := svc.InputService1TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	ec2query.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body, _ := ioutil.ReadAll(r.Body)
+	assert.Equal(t, util.Trim(`Action=OperationName&Bar=val2&Foo=val1&Version=2014-01-01`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService2ProtocolTestStructureWithLocationNameAndQueryNameAppliedToMembersCase1(t *testing.T) {
+	svc := NewInputService2ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService2TestShapeInputShape{
+		Bar:  aws.String("val2"),
+		Foo:  aws.String("val1"),
+		Yuck: aws.String("val3"),
+	}
+	req, _ := svc.InputService2TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	ec2query.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body, _ := ioutil.ReadAll(r.Body)
+	assert.Equal(t, util.Trim(`Action=OperationName&BarLocationName=val2&Foo=val1&Version=2014-01-01&yuckQueryName=val3`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService3ProtocolTestNestedStructureMembersCase1(t *testing.T) {
+	svc := NewInputService3ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService3TestShapeInputShape{
+		StructArg: &InputService3TestShapeStructType{
+			ScalarArg: aws.String("foo"),
+		},
+	}
+	req, _ := svc.InputService3TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	ec2query.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body, _ := ioutil.ReadAll(r.Body)
+	assert.Equal(t, util.Trim(`Action=OperationName&Struct.Scalar=foo&Version=2014-01-01`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService4ProtocolTestListTypesCase1(t *testing.T) {
+	svc := NewInputService4ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService4TestShapeInputShape{
+		ListArg: []*string{
+			aws.String("foo"),
+			aws.String("bar"),
+			aws.String("baz"),
+		},
+	}
+	req, _ := svc.InputService4TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	ec2query.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body, _ := ioutil.ReadAll(r.Body)
+	assert.Equal(t, util.Trim(`Action=OperationName&ListArg.1=foo&ListArg.2=bar&ListArg.3=baz&Version=2014-01-01`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService5ProtocolTestListWithLocationNameAppliedToMemberCase1(t *testing.T) {
+	svc := NewInputService5ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService5TestShapeInputShape{
+		ListArg: []*string{
+			aws.String("a"),
+			aws.String("b"),
+			aws.String("c"),
+		},
+	}
+	req, _ := svc.InputService5TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	ec2query.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body, _ := ioutil.ReadAll(r.Body)
+	assert.Equal(t, util.Trim(`Action=OperationName&ListMemberName.1=a&ListMemberName.2=b&ListMemberName.3=c&Version=2014-01-01`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService6ProtocolTestListWithLocationNameAndQueryNameCase1(t *testing.T) {
+	svc := NewInputService6ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService6TestShapeInputShape{
+		ListArg: []*string{
+			aws.String("a"),
+			aws.String("b"),
+			aws.String("c"),
+		},
+	}
+	req, _ := svc.InputService6TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	ec2query.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body, _ := ioutil.ReadAll(r.Body)
+	assert.Equal(t, util.Trim(`Action=OperationName&ListQueryName.1=a&ListQueryName.2=b&ListQueryName.3=c&Version=2014-01-01`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService7ProtocolTestBase64EncodedBlobsCase1(t *testing.T) {
+	svc := NewInputService7ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService7TestShapeInputShape{
+		BlobArg: []byte("foo"),
+	}
+	req, _ := svc.InputService7TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	ec2query.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body, _ := ioutil.ReadAll(r.Body)
+	assert.Equal(t, util.Trim(`Action=OperationName&BlobArg=Zm9v&Version=2014-01-01`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService8ProtocolTestTimestampValuesCase1(t *testing.T) {
+	svc := NewInputService8ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService8TestShapeInputShape{
+		TimeArg: aws.Time(time.Unix(1422172800, 0)),
+	}
+	req, _ := svc.InputService8TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	ec2query.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body, _ := ioutil.ReadAll(r.Body)
+	assert.Equal(t, util.Trim(`Action=OperationName&TimeArg=2015-01-25T08%3A00%3A00Z&Version=2014-01-01`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/ec2query/unmarshal.go

@@ -0,0 +1,54 @@
+package ec2query
+
+//go:generate go run ../../fixtures/protocol/generate.go ../../fixtures/protocol/output/ec2.json unmarshal_test.go
+
+import (
+	"encoding/xml"
+	"io"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil"
+)
+
+// Unmarshal unmarshals a response body for the EC2 protocol.
+func Unmarshal(r *aws.Request) {
+	defer r.HTTPResponse.Body.Close()
+	if r.DataFilled() {
+		decoder := xml.NewDecoder(r.HTTPResponse.Body)
+		err := xmlutil.UnmarshalXML(r.Data, decoder, "")
+		if err != nil {
+			r.Error = awserr.New("SerializationError", "failed decoding EC2 Query response", err)
+			return
+		}
+	}
+}
+
+// UnmarshalMeta unmarshals response headers for the EC2 protocol.
+func UnmarshalMeta(r *aws.Request) {
+	// TODO implement unmarshaling of request IDs
+}
+
+type xmlErrorResponse struct {
+	XMLName   xml.Name `xml:"Response"`
+	Code      string   `xml:"Errors>Error>Code"`
+	Message   string   `xml:"Errors>Error>Message"`
+	RequestID string   `xml:"RequestId"`
+}
+
+// UnmarshalError unmarshals a response error for the EC2 protocol.
+func UnmarshalError(r *aws.Request) {
+	defer r.HTTPResponse.Body.Close()
+
+	resp := &xmlErrorResponse{}
+	err := xml.NewDecoder(r.HTTPResponse.Body).Decode(resp)
+	if err != nil && err != io.EOF {
+		r.Error = awserr.New("SerializationError", "failed decoding EC2 Query error response", err)
+	} else {
+		r.Error = awserr.NewRequestFailure(
+			awserr.New(resp.Code, resp.Message, nil),
+			r.HTTPResponse.StatusCode,
+			resp.RequestID,
+		)
+	}
+}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/ec2query/unmarshal_test.go

@@ -0,0 +1,816 @@
+package ec2query_test
+
+import (
+	"bytes"
+	"encoding/json"
+	"encoding/xml"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/internal/protocol/ec2query"
+	"github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil"
+	"github.com/aws/aws-sdk-go/internal/signer/v4"
+	"github.com/aws/aws-sdk-go/internal/util"
+	"github.com/stretchr/testify/assert"
+)
+
+var _ bytes.Buffer // always import bytes
+var _ http.Request
+var _ json.Marshaler
+var _ time.Time
+var _ xmlutil.XMLNode
+var _ xml.Attr
+var _ = ioutil.Discard
+var _ = util.Trim("")
+var _ = url.Values{}
+var _ = io.EOF
+
+type OutputService1ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService1ProtocolTest client.
+func NewOutputService1ProtocolTest(config *aws.Config) *OutputService1ProtocolTest {
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice1protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(ec2query.Build)
+	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
+
+	return &OutputService1ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService1ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService1ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+	req := aws.NewRequest(c.Service, op, params, data)
+
+	return req
+}
+
+const opOutputService1TestCaseOperation1 = "OperationName"
+
+// OutputService1TestCaseOperation1Request generates a request for the OutputService1TestCaseOperation1 operation.
+func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1Request(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (req *aws.Request, output *OutputService1TestShapeOutputShape) {
+	op := &aws.Operation{
+		Name: opOutputService1TestCaseOperation1,
+	}
+
+	if input == nil {
+		input = &OutputService1TestShapeOutputService1TestCaseOperation1Input{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &OutputService1TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (*OutputService1TestShapeOutputShape, error) {
+	req, out := c.OutputService1TestCaseOperation1Request(input)
+	err := req.Send()
+	return out, err
+}
+
+type OutputService1TestShapeOutputService1TestCaseOperation1Input struct {
+	metadataOutputService1TestShapeOutputService1TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService1TestShapeOutputService1TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService1TestShapeOutputShape struct {
+	Char *string `type:"character"`
+
+	Double *float64 `type:"double"`
+
+	FalseBool *bool `type:"boolean"`
+
+	Float *float64 `type:"float"`
+
+	Long *int64 `type:"long"`
+
+	Num *int64 `locationName:"FooNum" type:"integer"`
+
+	Str *string `type:"string"`
+
+	TrueBool *bool `type:"boolean"`
+
+	metadataOutputService1TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService1TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService2ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService2ProtocolTest client.
+func NewOutputService2ProtocolTest(config *aws.Config) *OutputService2ProtocolTest {
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice2protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(ec2query.Build)
+	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
+
+	return &OutputService2ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService2ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService2ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+	req := aws.NewRequest(c.Service, op, params, data)
+
+	return req
+}
+
+const opOutputService2TestCaseOperation1 = "OperationName"
+
+// OutputService2TestCaseOperation1Request generates a request for the OutputService2TestCaseOperation1 operation.
+func (c *OutputService2ProtocolTest) OutputService2TestCaseOperation1Request(input *OutputService2TestShapeOutputService2TestCaseOperation1Input) (req *aws.Request, output *OutputService2TestShapeOutputShape) {
+	op := &aws.Operation{
+		Name: opOutputService2TestCaseOperation1,
+	}
+
+	if input == nil {
+		input = &OutputService2TestShapeOutputService2TestCaseOperation1Input{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &OutputService2TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService2ProtocolTest) OutputService2TestCaseOperation1(input *OutputService2TestShapeOutputService2TestCaseOperation1Input) (*OutputService2TestShapeOutputShape, error) {
+	req, out := c.OutputService2TestCaseOperation1Request(input)
+	err := req.Send()
+	return out, err
+}
+
+type OutputService2TestShapeOutputService2TestCaseOperation1Input struct {
+	metadataOutputService2TestShapeOutputService2TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService2TestShapeOutputService2TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService2TestShapeOutputShape struct {
+	Blob []byte `type:"blob"`
+
+	metadataOutputService2TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService2TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService3ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService3ProtocolTest client.
+func NewOutputService3ProtocolTest(config *aws.Config) *OutputService3ProtocolTest {
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice3protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(ec2query.Build)
+	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
+
+	return &OutputService3ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService3ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService3ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+	req := aws.NewRequest(c.Service, op, params, data)
+
+	return req
+}
+
+const opOutputService3TestCaseOperation1 = "OperationName"
+
+// OutputService3TestCaseOperation1Request generates a request for the OutputService3TestCaseOperation1 operation.
+func (c *OutputService3ProtocolTest) OutputService3TestCaseOperation1Request(input *OutputService3TestShapeOutputService3TestCaseOperation1Input) (req *aws.Request, output *OutputService3TestShapeOutputShape) {
+	op := &aws.Operation{
+		Name: opOutputService3TestCaseOperation1,
+	}
+
+	if input == nil {
+		input = &OutputService3TestShapeOutputService3TestCaseOperation1Input{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &OutputService3TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService3ProtocolTest) OutputService3TestCaseOperation1(input *OutputService3TestShapeOutputService3TestCaseOperation1Input) (*OutputService3TestShapeOutputShape, error) {
+	req, out := c.OutputService3TestCaseOperation1Request(input)
+	err := req.Send()
+	return out, err
+}
+
+type OutputService3TestShapeOutputService3TestCaseOperation1Input struct {
+	metadataOutputService3TestShapeOutputService3TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService3TestShapeOutputService3TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService3TestShapeOutputShape struct {
+	ListMember []*string `type:"list"`
+
+	metadataOutputService3TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService3TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService4ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService4ProtocolTest client.
+func NewOutputService4ProtocolTest(config *aws.Config) *OutputService4ProtocolTest {
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice4protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(ec2query.Build)
+	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
+
+	return &OutputService4ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService4ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService4ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+	req := aws.NewRequest(c.Service, op, params, data)
+
+	return req
+}
+
+const opOutputService4TestCaseOperation1 = "OperationName"
+
+// OutputService4TestCaseOperation1Request generates a request for the OutputService4TestCaseOperation1 operation.
+func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1Request(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (req *aws.Request, output *OutputService4TestShapeOutputShape) {
+	op := &aws.Operation{
+		Name: opOutputService4TestCaseOperation1,
+	}
+
+	if input == nil {
+		input = &OutputService4TestShapeOutputService4TestCaseOperation1Input{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &OutputService4TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (*OutputService4TestShapeOutputShape, error) {
+	req, out := c.OutputService4TestCaseOperation1Request(input)
+	err := req.Send()
+	return out, err
+}
+
+type OutputService4TestShapeOutputService4TestCaseOperation1Input struct {
+	metadataOutputService4TestShapeOutputService4TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService4TestShapeOutputService4TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService4TestShapeOutputShape struct {
+	ListMember []*string `locationNameList:"item" type:"list"`
+
+	metadataOutputService4TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService4TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService5ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService5ProtocolTest client.
+func NewOutputService5ProtocolTest(config *aws.Config) *OutputService5ProtocolTest {
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice5protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(ec2query.Build)
+	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
+
+	return &OutputService5ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService5ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService5ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+	req := aws.NewRequest(c.Service, op, params, data)
+
+	return req
+}
+
+const opOutputService5TestCaseOperation1 = "OperationName"
+
+// OutputService5TestCaseOperation1Request generates a request for the OutputService5TestCaseOperation1 operation.
+func (c *OutputService5ProtocolTest) OutputService5TestCaseOperation1Request(input *OutputService5TestShapeOutputService5TestCaseOperation1Input) (req *aws.Request, output *OutputService5TestShapeOutputShape) {
+	op := &aws.Operation{
+		Name: opOutputService5TestCaseOperation1,
+	}
+
+	if input == nil {
+		input = &OutputService5TestShapeOutputService5TestCaseOperation1Input{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &OutputService5TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService5ProtocolTest) OutputService5TestCaseOperation1(input *OutputService5TestShapeOutputService5TestCaseOperation1Input) (*OutputService5TestShapeOutputShape, error) {
+	req, out := c.OutputService5TestCaseOperation1Request(input)
+	err := req.Send()
+	return out, err
+}
+
+type OutputService5TestShapeOutputService5TestCaseOperation1Input struct {
+	metadataOutputService5TestShapeOutputService5TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService5TestShapeOutputService5TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService5TestShapeOutputShape struct {
+	ListMember []*string `type:"list" flattened:"true"`
+
+	metadataOutputService5TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService5TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService6ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService6ProtocolTest client.
+func NewOutputService6ProtocolTest(config *aws.Config) *OutputService6ProtocolTest {
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice6protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(ec2query.Build)
+	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
+
+	return &OutputService6ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService6ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService6ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+	req := aws.NewRequest(c.Service, op, params, data)
+
+	return req
+}
+
+const opOutputService6TestCaseOperation1 = "OperationName"
+
+// OutputService6TestCaseOperation1Request generates a request for the OutputService6TestCaseOperation1 operation.
+func (c *OutputService6ProtocolTest) OutputService6TestCaseOperation1Request(input *OutputService6TestShapeOutputService6TestCaseOperation1Input) (req *aws.Request, output *OutputService6TestShapeOutputShape) {
+	op := &aws.Operation{
+		Name: opOutputService6TestCaseOperation1,
+	}
+
+	if input == nil {
+		input = &OutputService6TestShapeOutputService6TestCaseOperation1Input{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &OutputService6TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService6ProtocolTest) OutputService6TestCaseOperation1(input *OutputService6TestShapeOutputService6TestCaseOperation1Input) (*OutputService6TestShapeOutputShape, error) {
+	req, out := c.OutputService6TestCaseOperation1Request(input)
+	err := req.Send()
+	return out, err
+}
+
+type OutputService6TestShapeOutputService6TestCaseOperation1Input struct {
+	metadataOutputService6TestShapeOutputService6TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService6TestShapeOutputService6TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService6TestShapeOutputShape struct {
+	Map map[string]*OutputService6TestShapeStructureType `type:"map"`
+
+	metadataOutputService6TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService6TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService6TestShapeStructureType struct {
+	Foo *string `locationName:"foo" type:"string"`
+
+	metadataOutputService6TestShapeStructureType `json:"-" xml:"-"`
+}
+
+type metadataOutputService6TestShapeStructureType struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService7ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService7ProtocolTest client.
+func NewOutputService7ProtocolTest(config *aws.Config) *OutputService7ProtocolTest {
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice7protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(ec2query.Build)
+	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
+
+	return &OutputService7ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService7ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService7ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+	req := aws.NewRequest(c.Service, op, params, data)
+
+	return req
+}
+
+const opOutputService7TestCaseOperation1 = "OperationName"
+
+// OutputService7TestCaseOperation1Request generates a request for the OutputService7TestCaseOperation1 operation.
+func (c *OutputService7ProtocolTest) OutputService7TestCaseOperation1Request(input *OutputService7TestShapeOutputService7TestCaseOperation1Input) (req *aws.Request, output *OutputService7TestShapeOutputShape) {
+	op := &aws.Operation{
+		Name: opOutputService7TestCaseOperation1,
+	}
+
+	if input == nil {
+		input = &OutputService7TestShapeOutputService7TestCaseOperation1Input{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &OutputService7TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService7ProtocolTest) OutputService7TestCaseOperation1(input *OutputService7TestShapeOutputService7TestCaseOperation1Input) (*OutputService7TestShapeOutputShape, error) {
+	req, out := c.OutputService7TestCaseOperation1Request(input)
+	err := req.Send()
+	return out, err
+}
+
+type OutputService7TestShapeOutputService7TestCaseOperation1Input struct {
+	metadataOutputService7TestShapeOutputService7TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService7TestShapeOutputService7TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService7TestShapeOutputShape struct {
+	Map map[string]*string `type:"map" flattened:"true"`
+
+	metadataOutputService7TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService7TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService8ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService8ProtocolTest client.
+func NewOutputService8ProtocolTest(config *aws.Config) *OutputService8ProtocolTest {
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice8protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(ec2query.Build)
+	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
+
+	return &OutputService8ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService8ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService8ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+	req := aws.NewRequest(c.Service, op, params, data)
+
+	return req
+}
+
+const opOutputService8TestCaseOperation1 = "OperationName"
+
+// OutputService8TestCaseOperation1Request generates a request for the OutputService8TestCaseOperation1 operation.
+func (c *OutputService8ProtocolTest) OutputService8TestCaseOperation1Request(input *OutputService8TestShapeOutputService8TestCaseOperation1Input) (req *aws.Request, output *OutputService8TestShapeOutputShape) {
+	op := &aws.Operation{
+		Name: opOutputService8TestCaseOperation1,
+	}
+
+	if input == nil {
+		input = &OutputService8TestShapeOutputService8TestCaseOperation1Input{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &OutputService8TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService8ProtocolTest) OutputService8TestCaseOperation1(input *OutputService8TestShapeOutputService8TestCaseOperation1Input) (*OutputService8TestShapeOutputShape, error) {
+	req, out := c.OutputService8TestCaseOperation1Request(input)
+	err := req.Send()
+	return out, err
+}
+
+type OutputService8TestShapeOutputService8TestCaseOperation1Input struct {
+	metadataOutputService8TestShapeOutputService8TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService8TestShapeOutputService8TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService8TestShapeOutputShape struct {
+	Map map[string]*string `locationNameKey:"foo" locationNameValue:"bar" type:"map" flattened:"true"`
+
+	metadataOutputService8TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService8TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+//
+// Tests begin here
+//
+
+func TestOutputService1ProtocolTestScalarMembersCase1(t *testing.T) {
+	svc := NewOutputService1ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse><Str>myname</Str><FooNum>123</FooNum><FalseBool>false</FalseBool><TrueBool>true</TrueBool><Float>1.2</Float><Double>1.3</Double><Long>200</Long><Char>a</Char><RequestId>request-id</RequestId></OperationNameResponse>"))
+	req, out := svc.OutputService1TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	ec2query.UnmarshalMeta(req)
+	ec2query.Unmarshal(req)
+	assert.NoError(t, req.Error)
+
+	// assert response
+	assert.NotNil(t, out) // ensure out variable is used
+	assert.Equal(t, "a", *out.Char)
+	assert.Equal(t, 1.3, *out.Double)
+	assert.Equal(t, false, *out.FalseBool)
+	assert.Equal(t, 1.2, *out.Float)
+	assert.Equal(t, int64(200), *out.Long)
+	assert.Equal(t, int64(123), *out.Num)
+	assert.Equal(t, "myname", *out.Str)
+	assert.Equal(t, true, *out.TrueBool)
+
+}
+
+func TestOutputService2ProtocolTestBlobCase1(t *testing.T) {
+	svc := NewOutputService2ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse><Blob>dmFsdWU=</Blob><RequestId>requestid</RequestId></OperationNameResponse>"))
+	req, out := svc.OutputService2TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	ec2query.UnmarshalMeta(req)
+	ec2query.Unmarshal(req)
+	assert.NoError(t, req.Error)
+
+	// assert response
+	assert.NotNil(t, out) // ensure out variable is used
+	assert.Equal(t, "value", string(out.Blob))
+
+}
+
+func TestOutputService3ProtocolTestListsCase1(t *testing.T) {
+	svc := NewOutputService3ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse><ListMember><member>abc</member><member>123</member></ListMember><RequestId>requestid</RequestId></OperationNameResponse>"))
+	req, out := svc.OutputService3TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	ec2query.UnmarshalMeta(req)
+	ec2query.Unmarshal(req)
+	assert.NoError(t, req.Error)
+
+	// assert response
+	assert.NotNil(t, out) // ensure out variable is used
+	assert.Equal(t, "abc", *out.ListMember[0])
+	assert.Equal(t, "123", *out.ListMember[1])
+
+}
+
+func TestOutputService4ProtocolTestListWithCustomMemberNameCase1(t *testing.T) {
+	svc := NewOutputService4ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse><ListMember><item>abc</item><item>123</item></ListMember><RequestId>requestid</RequestId></OperationNameResponse>"))
+	req, out := svc.OutputService4TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	ec2query.UnmarshalMeta(req)
+	ec2query.Unmarshal(req)
+	assert.NoError(t, req.Error)
+
+	// assert response
+	assert.NotNil(t, out) // ensure out variable is used
+	assert.Equal(t, "abc", *out.ListMember[0])
+	assert.Equal(t, "123", *out.ListMember[1])
+
+}
+
+func TestOutputService5ProtocolTestFlattenedListCase1(t *testing.T) {
+	svc := NewOutputService5ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse><ListMember>abc</ListMember><ListMember>123</ListMember><RequestId>requestid</RequestId></OperationNameResponse>"))
+	req, out := svc.OutputService5TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	ec2query.UnmarshalMeta(req)
+	ec2query.Unmarshal(req)
+	assert.NoError(t, req.Error)
+
+	// assert response
+	assert.NotNil(t, out) // ensure out variable is used
+	assert.Equal(t, "abc", *out.ListMember[0])
+	assert.Equal(t, "123", *out.ListMember[1])
+
+}
+
+func TestOutputService6ProtocolTestNormalMapCase1(t *testing.T) {
+	svc := NewOutputService6ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse><Map><entry><key>qux</key><value><foo>bar</foo></value></entry><entry><key>baz</key><value><foo>bam</foo></value></entry></Map><RequestId>requestid</RequestId></OperationNameResponse>"))
+	req, out := svc.OutputService6TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	ec2query.UnmarshalMeta(req)
+	ec2query.Unmarshal(req)
+	assert.NoError(t, req.Error)
+
+	// assert response
+	assert.NotNil(t, out) // ensure out variable is used
+	assert.Equal(t, "bam", *out.Map["baz"].Foo)
+	assert.Equal(t, "bar", *out.Map["qux"].Foo)
+
+}
+
+func TestOutputService7ProtocolTestFlattenedMapCase1(t *testing.T) {
+	svc := NewOutputService7ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse><Map><key>qux</key><value>bar</value></Map><Map><key>baz</key><value>bam</value></Map><RequestId>requestid</RequestId></OperationNameResponse>"))
+	req, out := svc.OutputService7TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	ec2query.UnmarshalMeta(req)
+	ec2query.Unmarshal(req)
+	assert.NoError(t, req.Error)
+
+	// assert response
+	assert.NotNil(t, out) // ensure out variable is used
+	assert.Equal(t, "bam", *out.Map["baz"])
+	assert.Equal(t, "bar", *out.Map["qux"])
+
+}
+
+func TestOutputService8ProtocolTestNamedMapCase1(t *testing.T) {
+	svc := NewOutputService8ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse><Map><foo>qux</foo><bar>bar</bar></Map><Map><foo>baz</foo><bar>bam</bar></Map><RequestId>requestid</RequestId></OperationNameResponse>"))
+	req, out := svc.OutputService8TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	ec2query.UnmarshalMeta(req)
+	ec2query.Unmarshal(req)
+	assert.NoError(t, req.Error)
+
+	// assert response
+	assert.NotNil(t, out) // ensure out variable is used
+	assert.Equal(t, "bam", *out.Map["baz"])
+	assert.Equal(t, "bar", *out.Map["qux"])
+
+}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/ec2/api.go

@@ -0,0 +1,24490 @@
+// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
+
+// Package ec2 provides a client for Amazon Elastic Compute Cloud.
+package ec2
+
+import (
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awsutil"
+)
+
+const opAcceptVPCPeeringConnection = "AcceptVpcPeeringConnection"
+
+// AcceptVPCPeeringConnectionRequest generates a request for the AcceptVPCPeeringConnection operation.
+func (c *EC2) AcceptVPCPeeringConnectionRequest(input *AcceptVPCPeeringConnectionInput) (req *aws.Request, output *AcceptVPCPeeringConnectionOutput) {
+	op := &aws.Operation{
+		Name:       opAcceptVPCPeeringConnection,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &AcceptVPCPeeringConnectionInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &AcceptVPCPeeringConnectionOutput{}
+	req.Data = output
+	return
+}
+
+// Accept a VPC peering connection request. To accept a request, the VPC peering
+// connection must be in the pending-acceptance state, and you must be the owner
+// of the peer VPC. Use the DescribeVpcPeeringConnections request to view your
+// outstanding VPC peering connection requests.
+func (c *EC2) AcceptVPCPeeringConnection(input *AcceptVPCPeeringConnectionInput) (*AcceptVPCPeeringConnectionOutput, error) {
+	req, out := c.AcceptVPCPeeringConnectionRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opAllocateAddress = "AllocateAddress"
+
+// AllocateAddressRequest generates a request for the AllocateAddress operation.
+func (c *EC2) AllocateAddressRequest(input *AllocateAddressInput) (req *aws.Request, output *AllocateAddressOutput) {
+	op := &aws.Operation{
+		Name:       opAllocateAddress,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &AllocateAddressInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &AllocateAddressOutput{}
+	req.Data = output
+	return
+}
+
+// Acquires an Elastic IP address.
+//
+// An Elastic IP address is for use either in the EC2-Classic platform or in
+// a VPC. For more information, see Elastic IP Addresses (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) AllocateAddress(input *AllocateAddressInput) (*AllocateAddressOutput, error) {
+	req, out := c.AllocateAddressRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opAssignPrivateIPAddresses = "AssignPrivateIpAddresses"
+
+// AssignPrivateIPAddressesRequest generates a request for the AssignPrivateIPAddresses operation.
+func (c *EC2) AssignPrivateIPAddressesRequest(input *AssignPrivateIPAddressesInput) (req *aws.Request, output *AssignPrivateIPAddressesOutput) {
+	op := &aws.Operation{
+		Name:       opAssignPrivateIPAddresses,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &AssignPrivateIPAddressesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &AssignPrivateIPAddressesOutput{}
+	req.Data = output
+	return
+}
+
+// Assigns one or more secondary private IP addresses to the specified network
+// interface. You can specify one or more specific secondary IP addresses, or
+// you can specify the number of secondary IP addresses to be automatically
+// assigned within the subnet's CIDR block range. The number of secondary IP
+// addresses that you can assign to an instance varies by instance type. For
+// information about instance types, see Instance Types (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html)
+// in the Amazon Elastic Compute Cloud User Guide. For more information about
+// Elastic IP addresses, see Elastic IP Addresses (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+//
+// AssignPrivateIpAddresses is available only in EC2-VPC.
+func (c *EC2) AssignPrivateIPAddresses(input *AssignPrivateIPAddressesInput) (*AssignPrivateIPAddressesOutput, error) {
+	req, out := c.AssignPrivateIPAddressesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opAssociateAddress = "AssociateAddress"
+
+// AssociateAddressRequest generates a request for the AssociateAddress operation.
+func (c *EC2) AssociateAddressRequest(input *AssociateAddressInput) (req *aws.Request, output *AssociateAddressOutput) {
+	op := &aws.Operation{
+		Name:       opAssociateAddress,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &AssociateAddressInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &AssociateAddressOutput{}
+	req.Data = output
+	return
+}
+
+// Associates an Elastic IP address with an instance or a network interface.
+//
+// An Elastic IP address is for use in either the EC2-Classic platform or in
+// a VPC. For more information, see Elastic IP Addresses (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+//
+// [EC2-Classic, VPC in an EC2-VPC-only account] If the Elastic IP address
+// is already associated with a different instance, it is disassociated from
+// that instance and associated with the specified instance.
+//
+// [VPC in an EC2-Classic account] If you don't specify a private IP address,
+// the Elastic IP address is associated with the primary IP address. If the
+// Elastic IP address is already associated with a different instance or a network
+// interface, you get an error unless you allow reassociation.
+//
+// This is an idempotent operation. If you perform the operation more than
+// once, Amazon EC2 doesn't return an error.
+func (c *EC2) AssociateAddress(input *AssociateAddressInput) (*AssociateAddressOutput, error) {
+	req, out := c.AssociateAddressRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opAssociateDHCPOptions = "AssociateDhcpOptions"
+
+// AssociateDHCPOptionsRequest generates a request for the AssociateDHCPOptions operation.
+func (c *EC2) AssociateDHCPOptionsRequest(input *AssociateDHCPOptionsInput) (req *aws.Request, output *AssociateDHCPOptionsOutput) {
+	op := &aws.Operation{
+		Name:       opAssociateDHCPOptions,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &AssociateDHCPOptionsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &AssociateDHCPOptionsOutput{}
+	req.Data = output
+	return
+}
+
+// Associates a set of DHCP options (that you've previously created) with the
+// specified VPC, or associates no DHCP options with the VPC.
+//
+// After you associate the options with the VPC, any existing instances and
+// all new instances that you launch in that VPC use the options. You don't
+// need to restart or relaunch the instances. They automatically pick up the
+// changes within a few hours, depending on how frequently the instance renews
+// its DHCP lease. You can explicitly renew the lease using the operating system
+// on the instance.
+//
+// For more information, see DHCP Options Sets (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_DHCP_Options.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) AssociateDHCPOptions(input *AssociateDHCPOptionsInput) (*AssociateDHCPOptionsOutput, error) {
+	req, out := c.AssociateDHCPOptionsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opAssociateRouteTable = "AssociateRouteTable"
+
+// AssociateRouteTableRequest generates a request for the AssociateRouteTable operation.
+func (c *EC2) AssociateRouteTableRequest(input *AssociateRouteTableInput) (req *aws.Request, output *AssociateRouteTableOutput) {
+	op := &aws.Operation{
+		Name:       opAssociateRouteTable,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &AssociateRouteTableInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &AssociateRouteTableOutput{}
+	req.Data = output
+	return
+}
+
+// Associates a subnet with a route table. The subnet and route table must be
+// in the same VPC. This association causes traffic originating from the subnet
+// to be routed according to the routes in the route table. The action returns
+// an association ID, which you need in order to disassociate the route table
+// from the subnet later. A route table can be associated with multiple subnets.
+//
+// For more information about route tables, see Route Tables (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Route_Tables.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) AssociateRouteTable(input *AssociateRouteTableInput) (*AssociateRouteTableOutput, error) {
+	req, out := c.AssociateRouteTableRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opAttachClassicLinkVPC = "AttachClassicLinkVpc"
+
+// AttachClassicLinkVPCRequest generates a request for the AttachClassicLinkVPC operation.
+func (c *EC2) AttachClassicLinkVPCRequest(input *AttachClassicLinkVPCInput) (req *aws.Request, output *AttachClassicLinkVPCOutput) {
+	op := &aws.Operation{
+		Name:       opAttachClassicLinkVPC,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &AttachClassicLinkVPCInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &AttachClassicLinkVPCOutput{}
+	req.Data = output
+	return
+}
+
+// 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.
+func (c *EC2) AttachClassicLinkVPC(input *AttachClassicLinkVPCInput) (*AttachClassicLinkVPCOutput, error) {
+	req, out := c.AttachClassicLinkVPCRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opAttachInternetGateway = "AttachInternetGateway"
+
+// AttachInternetGatewayRequest generates a request for the AttachInternetGateway operation.
+func (c *EC2) AttachInternetGatewayRequest(input *AttachInternetGatewayInput) (req *aws.Request, output *AttachInternetGatewayOutput) {
+	op := &aws.Operation{
+		Name:       opAttachInternetGateway,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &AttachInternetGatewayInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &AttachInternetGatewayOutput{}
+	req.Data = output
+	return
+}
+
+// Attaches an Internet gateway to a VPC, enabling connectivity between the
+// Internet and the VPC. For more information about your VPC and Internet gateway,
+// see the Amazon Virtual Private Cloud User Guide (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/).
+func (c *EC2) AttachInternetGateway(input *AttachInternetGatewayInput) (*AttachInternetGatewayOutput, error) {
+	req, out := c.AttachInternetGatewayRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opAttachNetworkInterface = "AttachNetworkInterface"
+
+// AttachNetworkInterfaceRequest generates a request for the AttachNetworkInterface operation.
+func (c *EC2) AttachNetworkInterfaceRequest(input *AttachNetworkInterfaceInput) (req *aws.Request, output *AttachNetworkInterfaceOutput) {
+	op := &aws.Operation{
+		Name:       opAttachNetworkInterface,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &AttachNetworkInterfaceInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &AttachNetworkInterfaceOutput{}
+	req.Data = output
+	return
+}
+
+// Attaches a network interface to an instance.
+func (c *EC2) AttachNetworkInterface(input *AttachNetworkInterfaceInput) (*AttachNetworkInterfaceOutput, error) {
+	req, out := c.AttachNetworkInterfaceRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opAttachVPNGateway = "AttachVpnGateway"
+
+// AttachVPNGatewayRequest generates a request for the AttachVPNGateway operation.
+func (c *EC2) AttachVPNGatewayRequest(input *AttachVPNGatewayInput) (req *aws.Request, output *AttachVPNGatewayOutput) {
+	op := &aws.Operation{
+		Name:       opAttachVPNGateway,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &AttachVPNGatewayInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &AttachVPNGatewayOutput{}
+	req.Data = output
+	return
+}
+
+// Attaches a virtual private gateway to a VPC. For more information, see Adding
+// a Hardware Virtual Private Gateway to Your VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_VPN.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) AttachVPNGateway(input *AttachVPNGatewayInput) (*AttachVPNGatewayOutput, error) {
+	req, out := c.AttachVPNGatewayRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opAttachVolume = "AttachVolume"
+
+// AttachVolumeRequest generates a request for the AttachVolume operation.
+func (c *EC2) AttachVolumeRequest(input *AttachVolumeInput) (req *aws.Request, output *VolumeAttachment) {
+	op := &aws.Operation{
+		Name:       opAttachVolume,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &AttachVolumeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &VolumeAttachment{}
+	req.Data = output
+	return
+}
+
+// Attaches an EBS volume to a running or stopped instance and exposes it to
+// the instance with the specified device name.
+//
+// Encrypted EBS volumes may only be attached to instances that support Amazon
+// EBS encryption. For more information, see Amazon EBS Encryption (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+//
+// For a list of supported device names, see Attaching an EBS Volume to an
+// Instance (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-attaching-volume.html).
+// Any device names that aren't reserved for instance store volumes can be used
+// for EBS volumes. For more information, see Amazon EC2 Instance Store (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+//
+// If a volume has an AWS Marketplace product code:
+//
+//  The volume can be attached only to a stopped instance. AWS Marketplace
+// product codes are copied from the volume to the instance. You must be subscribed
+// to the product. The instance type and operating system of the instance must
+// support the product. For example, you can't detach a volume from a Windows
+// instance and attach it to a Linux instance.  For an overview of the AWS Marketplace,
+// see Introducing AWS Marketplace (https://aws.amazon.com/marketplace/help/200900000).
+//
+// For more information about EBS volumes, see Attaching Amazon EBS Volumes
+// (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-attaching-volume.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) AttachVolume(input *AttachVolumeInput) (*VolumeAttachment, error) {
+	req, out := c.AttachVolumeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opAuthorizeSecurityGroupEgress = "AuthorizeSecurityGroupEgress"
+
+// AuthorizeSecurityGroupEgressRequest generates a request for the AuthorizeSecurityGroupEgress operation.
+func (c *EC2) AuthorizeSecurityGroupEgressRequest(input *AuthorizeSecurityGroupEgressInput) (req *aws.Request, output *AuthorizeSecurityGroupEgressOutput) {
+	op := &aws.Operation{
+		Name:       opAuthorizeSecurityGroupEgress,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &AuthorizeSecurityGroupEgressInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &AuthorizeSecurityGroupEgressOutput{}
+	req.Data = output
+	return
+}
+
+// Adds one or more egress rules to a security group for use with a VPC. Specifically,
+// this action permits instances to send traffic to one or more destination
+// CIDR IP address ranges, or to one or more destination security groups for
+// the same VPC.
+//
+//  You can have up to 50 rules per security group (covering both ingress and
+// egress rules).
+//
+//  A security group is for use with instances either in the EC2-Classic platform
+// or in a specific VPC. This action doesn't apply to security groups for use
+// in EC2-Classic. For more information, see Security Groups for Your VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_SecurityGroups.html)
+// in the Amazon Virtual Private Cloud User Guide.
+//
+// Each rule consists of the protocol (for example, TCP), plus either a CIDR
+// range or a source group. For the TCP and UDP protocols, you must also specify
+// the destination port or port range. For the ICMP protocol, you must also
+// specify the ICMP type and code. You can use -1 for the type or code to mean
+// all types or all codes.
+//
+// Rule changes are propagated to affected instances as quickly as possible.
+// However, a small delay might occur.
+func (c *EC2) AuthorizeSecurityGroupEgress(input *AuthorizeSecurityGroupEgressInput) (*AuthorizeSecurityGroupEgressOutput, error) {
+	req, out := c.AuthorizeSecurityGroupEgressRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opAuthorizeSecurityGroupIngress = "AuthorizeSecurityGroupIngress"
+
+// AuthorizeSecurityGroupIngressRequest generates a request for the AuthorizeSecurityGroupIngress operation.
+func (c *EC2) AuthorizeSecurityGroupIngressRequest(input *AuthorizeSecurityGroupIngressInput) (req *aws.Request, output *AuthorizeSecurityGroupIngressOutput) {
+	op := &aws.Operation{
+		Name:       opAuthorizeSecurityGroupIngress,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &AuthorizeSecurityGroupIngressInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &AuthorizeSecurityGroupIngressOutput{}
+	req.Data = output
+	return
+}
+
+// Adds one or more ingress rules to a security group.
+//
+//  EC2-Classic: You can have up to 100 rules per group.
+//
+// EC2-VPC: You can have up to 50 rules per group (covering both ingress and
+// egress rules).
+//
+//  Rule changes are propagated to instances within the security group as quickly
+// as possible. However, a small delay might occur.
+//
+// [EC2-Classic] This action gives one or more CIDR IP address ranges permission
+// to access a security group in your account, or gives one or more security
+// groups (called the source groups) permission to access a security group for
+// your account. A source group can be for your own AWS account, or another.
+//
+// [EC2-VPC] This action gives one or more CIDR IP address ranges permission
+// to access a security group in your VPC, or gives one or more other security
+// groups (called the source groups) permission to access a security group for
+// your VPC. The security groups must all be for the same VPC.
+func (c *EC2) AuthorizeSecurityGroupIngress(input *AuthorizeSecurityGroupIngressInput) (*AuthorizeSecurityGroupIngressOutput, error) {
+	req, out := c.AuthorizeSecurityGroupIngressRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opBundleInstance = "BundleInstance"
+
+// BundleInstanceRequest generates a request for the BundleInstance operation.
+func (c *EC2) BundleInstanceRequest(input *BundleInstanceInput) (req *aws.Request, output *BundleInstanceOutput) {
+	op := &aws.Operation{
+		Name:       opBundleInstance,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &BundleInstanceInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &BundleInstanceOutput{}
+	req.Data = output
+	return
+}
+
+// Bundles an Amazon instance store-backed Windows instance.
+//
+// During bundling, only the root device volume (C:\) is bundled. Data on other
+// instance store volumes is not preserved.
+//
+//  This action is not applicable for Linux/Unix instances or Windows instances
+// that are backed by Amazon EBS.
+//
+//  For more information, see Creating an Instance Store-Backed Windows AMI
+// (http://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/Creating_InstanceStoreBacked_WinAMI.html).
+func (c *EC2) BundleInstance(input *BundleInstanceInput) (*BundleInstanceOutput, error) {
+	req, out := c.BundleInstanceRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCancelBundleTask = "CancelBundleTask"
+
+// CancelBundleTaskRequest generates a request for the CancelBundleTask operation.
+func (c *EC2) CancelBundleTaskRequest(input *CancelBundleTaskInput) (req *aws.Request, output *CancelBundleTaskOutput) {
+	op := &aws.Operation{
+		Name:       opCancelBundleTask,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CancelBundleTaskInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CancelBundleTaskOutput{}
+	req.Data = output
+	return
+}
+
+// Cancels a bundling operation for an instance store-backed Windows instance.
+func (c *EC2) CancelBundleTask(input *CancelBundleTaskInput) (*CancelBundleTaskOutput, error) {
+	req, out := c.CancelBundleTaskRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCancelConversionTask = "CancelConversionTask"
+
+// CancelConversionTaskRequest generates a request for the CancelConversionTask operation.
+func (c *EC2) CancelConversionTaskRequest(input *CancelConversionTaskInput) (req *aws.Request, output *CancelConversionTaskOutput) {
+	op := &aws.Operation{
+		Name:       opCancelConversionTask,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CancelConversionTaskInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CancelConversionTaskOutput{}
+	req.Data = output
+	return
+}
+
+// Cancels an active conversion task. The task can be the import of an instance
+// or volume. The action removes all artifacts of the conversion, including
+// a partially uploaded volume or instance. If the conversion is complete or
+// is in the process of transferring the final disk image, the command fails
+// and returns an exception.
+//
+// For more information, see Using the Command Line Tools to Import Your Virtual
+// Machine to Amazon EC2 (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UploadingYourInstancesandVolumes.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) CancelConversionTask(input *CancelConversionTaskInput) (*CancelConversionTaskOutput, error) {
+	req, out := c.CancelConversionTaskRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCancelExportTask = "CancelExportTask"
+
+// CancelExportTaskRequest generates a request for the CancelExportTask operation.
+func (c *EC2) CancelExportTaskRequest(input *CancelExportTaskInput) (req *aws.Request, output *CancelExportTaskOutput) {
+	op := &aws.Operation{
+		Name:       opCancelExportTask,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CancelExportTaskInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CancelExportTaskOutput{}
+	req.Data = output
+	return
+}
+
+// Cancels an active export task. The request removes all artifacts of the export,
+// including any partially-created Amazon S3 objects. If the export task is
+// complete or is in the process of transferring the final disk image, the command
+// fails and returns an error.
+func (c *EC2) CancelExportTask(input *CancelExportTaskInput) (*CancelExportTaskOutput, error) {
+	req, out := c.CancelExportTaskRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCancelImportTask = "CancelImportTask"
+
+// CancelImportTaskRequest generates a request for the CancelImportTask operation.
+func (c *EC2) CancelImportTaskRequest(input *CancelImportTaskInput) (req *aws.Request, output *CancelImportTaskOutput) {
+	op := &aws.Operation{
+		Name:       opCancelImportTask,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CancelImportTaskInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CancelImportTaskOutput{}
+	req.Data = output
+	return
+}
+
+// Cancels an in-process import virtual machine or import snapshot task.
+func (c *EC2) CancelImportTask(input *CancelImportTaskInput) (*CancelImportTaskOutput, error) {
+	req, out := c.CancelImportTaskRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCancelReservedInstancesListing = "CancelReservedInstancesListing"
+
+// CancelReservedInstancesListingRequest generates a request for the CancelReservedInstancesListing operation.
+func (c *EC2) CancelReservedInstancesListingRequest(input *CancelReservedInstancesListingInput) (req *aws.Request, output *CancelReservedInstancesListingOutput) {
+	op := &aws.Operation{
+		Name:       opCancelReservedInstancesListing,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CancelReservedInstancesListingInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CancelReservedInstancesListingOutput{}
+	req.Data = output
+	return
+}
+
+// Cancels the specified Reserved Instance listing in the Reserved Instance
+// Marketplace.
+//
+// For more information, see Reserved Instance Marketplace (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) CancelReservedInstancesListing(input *CancelReservedInstancesListingInput) (*CancelReservedInstancesListingOutput, error) {
+	req, out := c.CancelReservedInstancesListingRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCancelSpotFleetRequests = "CancelSpotFleetRequests"
+
+// CancelSpotFleetRequestsRequest generates a request for the CancelSpotFleetRequests operation.
+func (c *EC2) CancelSpotFleetRequestsRequest(input *CancelSpotFleetRequestsInput) (req *aws.Request, output *CancelSpotFleetRequestsOutput) {
+	op := &aws.Operation{
+		Name:       opCancelSpotFleetRequests,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CancelSpotFleetRequestsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CancelSpotFleetRequestsOutput{}
+	req.Data = output
+	return
+}
+
+// Cancels the specified Spot fleet requests.
+func (c *EC2) CancelSpotFleetRequests(input *CancelSpotFleetRequestsInput) (*CancelSpotFleetRequestsOutput, error) {
+	req, out := c.CancelSpotFleetRequestsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCancelSpotInstanceRequests = "CancelSpotInstanceRequests"
+
+// CancelSpotInstanceRequestsRequest generates a request for the CancelSpotInstanceRequests operation.
+func (c *EC2) CancelSpotInstanceRequestsRequest(input *CancelSpotInstanceRequestsInput) (req *aws.Request, output *CancelSpotInstanceRequestsOutput) {
+	op := &aws.Operation{
+		Name:       opCancelSpotInstanceRequests,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CancelSpotInstanceRequestsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CancelSpotInstanceRequestsOutput{}
+	req.Data = output
+	return
+}
+
+// Cancels one or more Spot Instance requests. Spot Instances are instances
+// that Amazon EC2 starts on your behalf when the bid price that you specify
+// exceeds the current Spot Price. Amazon EC2 periodically sets the Spot Price
+// based on available Spot Instance capacity and current Spot Instance requests.
+// For more information, see Spot Instance Requests (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-requests.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+//
+//  Canceling a Spot Instance request does not terminate running Spot Instances
+// associated with the request.
+func (c *EC2) CancelSpotInstanceRequests(input *CancelSpotInstanceRequestsInput) (*CancelSpotInstanceRequestsOutput, error) {
+	req, out := c.CancelSpotInstanceRequestsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opConfirmProductInstance = "ConfirmProductInstance"
+
+// ConfirmProductInstanceRequest generates a request for the ConfirmProductInstance operation.
+func (c *EC2) ConfirmProductInstanceRequest(input *ConfirmProductInstanceInput) (req *aws.Request, output *ConfirmProductInstanceOutput) {
+	op := &aws.Operation{
+		Name:       opConfirmProductInstance,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ConfirmProductInstanceInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ConfirmProductInstanceOutput{}
+	req.Data = output
+	return
+}
+
+// Determines whether a product code is associated with an instance. This action
+// can only be used by the owner of the product code. It is useful when a product
+// code owner needs to verify whether another user's instance is eligible for
+// support.
+func (c *EC2) ConfirmProductInstance(input *ConfirmProductInstanceInput) (*ConfirmProductInstanceOutput, error) {
+	req, out := c.ConfirmProductInstanceRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCopyImage = "CopyImage"
+
+// CopyImageRequest generates a request for the CopyImage operation.
+func (c *EC2) CopyImageRequest(input *CopyImageInput) (req *aws.Request, output *CopyImageOutput) {
+	op := &aws.Operation{
+		Name:       opCopyImage,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CopyImageInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CopyImageOutput{}
+	req.Data = output
+	return
+}
+
+// Initiates the copy of an AMI from the specified source region to the current
+// region. You specify the destination region by using its endpoint when making
+// the request. AMIs that use encrypted EBS snapshots cannot be copied with
+// this method.
+//
+// For more information, see Copying AMIs (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/CopyingAMIs.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) CopyImage(input *CopyImageInput) (*CopyImageOutput, error) {
+	req, out := c.CopyImageRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCopySnapshot = "CopySnapshot"
+
+// CopySnapshotRequest generates a request for the CopySnapshot operation.
+func (c *EC2) CopySnapshotRequest(input *CopySnapshotInput) (req *aws.Request, output *CopySnapshotOutput) {
+	op := &aws.Operation{
+		Name:       opCopySnapshot,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CopySnapshotInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CopySnapshotOutput{}
+	req.Data = output
+	return
+}
+
+// Copies a point-in-time snapshot of an EBS volume and stores it in Amazon
+// S3. You can copy the snapshot within the same region or from one region to
+// another. You can use the snapshot to create EBS volumes or Amazon Machine
+// Images (AMIs). The snapshot is copied to the regional endpoint that you send
+// the HTTP request to.
+//
+// Copies of encrypted EBS snapshots remain encrypted. Copies of unencrypted
+// snapshots remain unencrypted, unless the Encrypted flag is specified during
+// the snapshot copy operation. By default, encrypted snapshot copies use the
+// default AWS Key Management Service (AWS KMS) customer master key (CMK); however,
+// you can specify a non-default CMK with the KmsKeyId parameter.
+//
+// For more information, see Copying an Amazon EBS Snapshot (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-copy-snapshot.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) CopySnapshot(input *CopySnapshotInput) (*CopySnapshotOutput, error) {
+	req, out := c.CopySnapshotRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateCustomerGateway = "CreateCustomerGateway"
+
+// CreateCustomerGatewayRequest generates a request for the CreateCustomerGateway operation.
+func (c *EC2) CreateCustomerGatewayRequest(input *CreateCustomerGatewayInput) (req *aws.Request, output *CreateCustomerGatewayOutput) {
+	op := &aws.Operation{
+		Name:       opCreateCustomerGateway,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateCustomerGatewayInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateCustomerGatewayOutput{}
+	req.Data = output
+	return
+}
+
+// Provides information to AWS about your VPN customer gateway device. The customer
+// gateway is the appliance at your end of the VPN connection. (The device on
+// the AWS side of the VPN connection is the virtual private gateway.) You must
+// provide the Internet-routable IP address of the customer gateway's external
+// interface. The IP address must be static and can't be behind a device performing
+// network address translation (NAT).
+//
+// For devices that use Border Gateway Protocol (BGP), you can also provide
+// the device's BGP Autonomous System Number (ASN). You can use an existing
+// ASN assigned to your network. If you don't have an ASN already, you can use
+// a private ASN (in the 64512 - 65534 range).
+//
+//  Amazon EC2 supports all 2-byte ASN numbers in the range of 1 - 65534, with
+// the exception of 7224, which is reserved in the us-east-1 region, and 9059,
+// which is reserved in the eu-west-1 region.
+//
+//  For more information about VPN customer gateways, see Adding a Hardware
+// Virtual Private Gateway to Your VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_VPN.html)
+// in the Amazon Virtual Private Cloud User Guide.
+//
+//  You cannot create more than one customer gateway with the same VPN type,
+// IP address, and BGP ASN parameter values. If you run an identical request
+// more than one time, the first request creates the customer gateway, and subsequent
+// requests return information about the existing customer gateway. The subsequent
+// requests do not create new customer gateway resources.
+func (c *EC2) CreateCustomerGateway(input *CreateCustomerGatewayInput) (*CreateCustomerGatewayOutput, error) {
+	req, out := c.CreateCustomerGatewayRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateDHCPOptions = "CreateDhcpOptions"
+
+// CreateDHCPOptionsRequest generates a request for the CreateDHCPOptions operation.
+func (c *EC2) CreateDHCPOptionsRequest(input *CreateDHCPOptionsInput) (req *aws.Request, output *CreateDHCPOptionsOutput) {
+	op := &aws.Operation{
+		Name:       opCreateDHCPOptions,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateDHCPOptionsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateDHCPOptionsOutput{}
+	req.Data = output
+	return
+}
+
+// Creates a set of DHCP options for your VPC. After creating the set, you must
+// associate it with the VPC, causing all existing and new instances that you
+// launch in the VPC to use this set of DHCP options. The following are the
+// individual DHCP options you can specify. For more information about the options,
+// see RFC 2132 (http://www.ietf.org/rfc/rfc2132.txt).
+//
+//   domain-name-servers - The IP addresses of up to four domain name servers,
+// or AmazonProvidedDNS. The default DHCP option set specifies AmazonProvidedDNS.
+// If specifying more than one domain name server, specify the IP addresses
+// in a single parameter, separated by commas.  domain-name - If you're using
+// AmazonProvidedDNS in us-east-1, specify ec2.internal. If you're using AmazonProvidedDNS
+// in another region, specify region.compute.internal (for example, ap-northeast-1.compute.internal).
+// Otherwise, specify a domain name (for example, MyCompany.com). Important:
+// Some Linux operating systems accept multiple domain names separated by spaces.
+// However, Windows and other Linux operating systems treat the value as a single
+// domain, which results in unexpected behavior. If your DHCP options set is
+// associated with a VPC that has instances with multiple operating systems,
+// specify only one domain name.  ntp-servers - The IP addresses of up to four
+// Network Time Protocol (NTP) servers.  netbios-name-servers - The IP addresses
+// of up to four NetBIOS name servers.  netbios-node-type - The NetBIOS node
+// type (1, 2, 4, or 8). We recommend that you specify 2 (broadcast and multicast
+// are not currently supported). For more information about these node types,
+// see RFC 2132 (http://www.ietf.org/rfc/rfc2132.txt).   Your VPC automatically
+// starts out with a set of DHCP options that includes only a DNS server that
+// we provide (AmazonProvidedDNS). If you create a set of options, and if your
+// VPC has an Internet gateway, make sure to set the domain-name-servers option
+// either to AmazonProvidedDNS or to a domain name server of your choice. For
+// more information about DHCP options, see DHCP Options Sets (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_DHCP_Options.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) CreateDHCPOptions(input *CreateDHCPOptionsInput) (*CreateDHCPOptionsOutput, error) {
+	req, out := c.CreateDHCPOptionsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateFlowLogs = "CreateFlowLogs"
+
+// CreateFlowLogsRequest generates a request for the CreateFlowLogs operation.
+func (c *EC2) CreateFlowLogsRequest(input *CreateFlowLogsInput) (req *aws.Request, output *CreateFlowLogsOutput) {
+	op := &aws.Operation{
+		Name:       opCreateFlowLogs,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateFlowLogsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateFlowLogsOutput{}
+	req.Data = output
+	return
+}
+
+// Creates one or more flow logs to capture IP traffic for a specific network
+// interface, subnet, or VPC. Flow logs are delivered to a specified log group
+// in Amazon CloudWatch Logs. If you specify a VPC or subnet in the request,
+// a log stream is created in CloudWatch Logs for each network interface in
+// the subnet or VPC. Log streams can include information about accepted and
+// rejected traffic to a network interface. You can view the data in your log
+// streams using Amazon CloudWatch Logs.
+//
+// In your request, you must also specify an IAM role that has permission to
+// publish logs to CloudWatch Logs.
+func (c *EC2) CreateFlowLogs(input *CreateFlowLogsInput) (*CreateFlowLogsOutput, error) {
+	req, out := c.CreateFlowLogsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateImage = "CreateImage"
+
+// CreateImageRequest generates a request for the CreateImage operation.
+func (c *EC2) CreateImageRequest(input *CreateImageInput) (req *aws.Request, output *CreateImageOutput) {
+	op := &aws.Operation{
+		Name:       opCreateImage,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateImageInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateImageOutput{}
+	req.Data = output
+	return
+}
+
+// Creates an Amazon EBS-backed AMI from an Amazon EBS-backed instance that
+// is either running or stopped.
+//
+// If you customized your instance with instance store volumes or EBS volumes
+// in addition to the root device volume, the new AMI contains block device
+// mapping information for those volumes. When you launch an instance from this
+// new AMI, the instance automatically launches with those additional volumes.
+//
+// For more information, see Creating Amazon EBS-Backed Linux AMIs (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-ebs.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) CreateImage(input *CreateImageInput) (*CreateImageOutput, error) {
+	req, out := c.CreateImageRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateInstanceExportTask = "CreateInstanceExportTask"
+
+// CreateInstanceExportTaskRequest generates a request for the CreateInstanceExportTask operation.
+func (c *EC2) CreateInstanceExportTaskRequest(input *CreateInstanceExportTaskInput) (req *aws.Request, output *CreateInstanceExportTaskOutput) {
+	op := &aws.Operation{
+		Name:       opCreateInstanceExportTask,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateInstanceExportTaskInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateInstanceExportTaskOutput{}
+	req.Data = output
+	return
+}
+
+// Exports a running or stopped instance to an S3 bucket.
+//
+// For information about the supported operating systems, image formats, and
+// known limitations for the types of instances you can export, see Exporting
+// EC2 Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ExportingEC2Instances.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) CreateInstanceExportTask(input *CreateInstanceExportTaskInput) (*CreateInstanceExportTaskOutput, error) {
+	req, out := c.CreateInstanceExportTaskRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateInternetGateway = "CreateInternetGateway"
+
+// CreateInternetGatewayRequest generates a request for the CreateInternetGateway operation.
+func (c *EC2) CreateInternetGatewayRequest(input *CreateInternetGatewayInput) (req *aws.Request, output *CreateInternetGatewayOutput) {
+	op := &aws.Operation{
+		Name:       opCreateInternetGateway,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateInternetGatewayInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateInternetGatewayOutput{}
+	req.Data = output
+	return
+}
+
+// Creates an Internet gateway for use with a VPC. After creating the Internet
+// gateway, you attach it to a VPC using AttachInternetGateway.
+//
+// For more information about your VPC and Internet gateway, see the Amazon
+// Virtual Private Cloud User Guide (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/).
+func (c *EC2) CreateInternetGateway(input *CreateInternetGatewayInput) (*CreateInternetGatewayOutput, error) {
+	req, out := c.CreateInternetGatewayRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateKeyPair = "CreateKeyPair"
+
+// CreateKeyPairRequest generates a request for the CreateKeyPair operation.
+func (c *EC2) CreateKeyPairRequest(input *CreateKeyPairInput) (req *aws.Request, output *CreateKeyPairOutput) {
+	op := &aws.Operation{
+		Name:       opCreateKeyPair,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateKeyPairInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateKeyPairOutput{}
+	req.Data = output
+	return
+}
+
+// Creates a 2048-bit RSA key pair with the specified name. Amazon EC2 stores
+// the public key and displays the private key for you to save to a file. The
+// private key is returned as an unencrypted PEM encoded PKCS#8 private key.
+// If a key with the specified name already exists, Amazon EC2 returns an error.
+//
+// You can have up to five thousand key pairs per region.
+//
+// The key pair returned to you is available only in the region in which you
+// create it. To create a key pair that is available in all regions, use ImportKeyPair.
+//
+// For more information about key pairs, see Key Pairs (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) CreateKeyPair(input *CreateKeyPairInput) (*CreateKeyPairOutput, error) {
+	req, out := c.CreateKeyPairRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateNetworkACL = "CreateNetworkAcl"
+
+// CreateNetworkACLRequest generates a request for the CreateNetworkACL operation.
+func (c *EC2) CreateNetworkACLRequest(input *CreateNetworkACLInput) (req *aws.Request, output *CreateNetworkACLOutput) {
+	op := &aws.Operation{
+		Name:       opCreateNetworkACL,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateNetworkACLInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateNetworkACLOutput{}
+	req.Data = output
+	return
+}
+
+// Creates a network ACL in a VPC. Network ACLs provide an optional layer of
+// security (in addition to security groups) for the instances in your VPC.
+//
+// For more information about network ACLs, see Network ACLs (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_ACLs.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) CreateNetworkACL(input *CreateNetworkACLInput) (*CreateNetworkACLOutput, error) {
+	req, out := c.CreateNetworkACLRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateNetworkACLEntry = "CreateNetworkAclEntry"
+
+// CreateNetworkACLEntryRequest generates a request for the CreateNetworkACLEntry operation.
+func (c *EC2) CreateNetworkACLEntryRequest(input *CreateNetworkACLEntryInput) (req *aws.Request, output *CreateNetworkACLEntryOutput) {
+	op := &aws.Operation{
+		Name:       opCreateNetworkACLEntry,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateNetworkACLEntryInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateNetworkACLEntryOutput{}
+	req.Data = output
+	return
+}
+
+// Creates an entry (a rule) in a network ACL with the specified rule number.
+// Each network ACL has a set of numbered ingress rules and a separate set of
+// numbered egress rules. When determining whether a packet should be allowed
+// in or out of a subnet associated with the ACL, we process the entries in
+// the ACL according to the rule numbers, in ascending order. Each network ACL
+// has a set of ingress rules and a separate set of egress rules.
+//
+// We recommend that you leave room between the rule numbers (for example,
+// 100, 110, 120, ...), and not number them one right after the other (for example,
+// 101, 102, 103, ...). This makes it easier to add a rule between existing
+// ones without having to renumber the rules.
+//
+// After you add an entry, you can't modify it; you must either replace it,
+// or create an entry and delete the old one.
+//
+// For more information about network ACLs, see Network ACLs (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_ACLs.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) CreateNetworkACLEntry(input *CreateNetworkACLEntryInput) (*CreateNetworkACLEntryOutput, error) {
+	req, out := c.CreateNetworkACLEntryRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateNetworkInterface = "CreateNetworkInterface"
+
+// CreateNetworkInterfaceRequest generates a request for the CreateNetworkInterface operation.
+func (c *EC2) CreateNetworkInterfaceRequest(input *CreateNetworkInterfaceInput) (req *aws.Request, output *CreateNetworkInterfaceOutput) {
+	op := &aws.Operation{
+		Name:       opCreateNetworkInterface,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateNetworkInterfaceInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateNetworkInterfaceOutput{}
+	req.Data = output
+	return
+}
+
+// Creates a network interface in the specified subnet.
+//
+// For more information about network interfaces, see Elastic Network Interfaces
+// (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) in the
+// Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) CreateNetworkInterface(input *CreateNetworkInterfaceInput) (*CreateNetworkInterfaceOutput, error) {
+	req, out := c.CreateNetworkInterfaceRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreatePlacementGroup = "CreatePlacementGroup"
+
+// CreatePlacementGroupRequest generates a request for the CreatePlacementGroup operation.
+func (c *EC2) CreatePlacementGroupRequest(input *CreatePlacementGroupInput) (req *aws.Request, output *CreatePlacementGroupOutput) {
+	op := &aws.Operation{
+		Name:       opCreatePlacementGroup,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreatePlacementGroupInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreatePlacementGroupOutput{}
+	req.Data = output
+	return
+}
+
+// Creates a placement group that you launch cluster instances into. You must
+// give the group a name that's unique within the scope of your account.
+//
+// For more information about placement groups and cluster instances, see Cluster
+// Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using_cluster_computing.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) CreatePlacementGroup(input *CreatePlacementGroupInput) (*CreatePlacementGroupOutput, error) {
+	req, out := c.CreatePlacementGroupRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateReservedInstancesListing = "CreateReservedInstancesListing"
+
+// CreateReservedInstancesListingRequest generates a request for the CreateReservedInstancesListing operation.
+func (c *EC2) CreateReservedInstancesListingRequest(input *CreateReservedInstancesListingInput) (req *aws.Request, output *CreateReservedInstancesListingOutput) {
+	op := &aws.Operation{
+		Name:       opCreateReservedInstancesListing,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateReservedInstancesListingInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateReservedInstancesListingOutput{}
+	req.Data = output
+	return
+}
+
+// Creates a listing for Amazon EC2 Reserved Instances to be sold in the Reserved
+// Instance Marketplace. You can submit one Reserved Instance listing at a time.
+// To get a list of your Reserved Instances, you can use the DescribeReservedInstances
+// operation.
+//
+// The Reserved Instance Marketplace matches sellers who want to resell Reserved
+// Instance capacity that they no longer need with buyers who want to purchase
+// additional capacity. Reserved Instances bought and sold through the Reserved
+// Instance Marketplace work like any other Reserved Instances.
+//
+// To sell your Reserved Instances, you must first register as a seller in
+// the Reserved Instance Marketplace. After completing the registration process,
+// you can create a Reserved Instance Marketplace listing of some or all of
+// your Reserved Instances, and specify the upfront price to receive for them.
+// Your Reserved Instance listings then become available for purchase. To view
+// the details of your Reserved Instance listing, you can use the DescribeReservedInstancesListings
+// operation.
+//
+// For more information, see Reserved Instance Marketplace (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) CreateReservedInstancesListing(input *CreateReservedInstancesListingInput) (*CreateReservedInstancesListingOutput, error) {
+	req, out := c.CreateReservedInstancesListingRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateRoute = "CreateRoute"
+
+// CreateRouteRequest generates a request for the CreateRoute operation.
+func (c *EC2) CreateRouteRequest(input *CreateRouteInput) (req *aws.Request, output *CreateRouteOutput) {
+	op := &aws.Operation{
+		Name:       opCreateRoute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateRouteInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateRouteOutput{}
+	req.Data = output
+	return
+}
+
+// Creates a route in a route table within a VPC.
+//
+// You must specify one of the following targets: Internet gateway or virtual
+// private gateway, NAT instance, VPC peering connection, or network interface.
+//
+// When determining how to route traffic, we use the route with the most specific
+// match. For example, let's say the traffic is destined for 192.0.2.3, and
+// the route table includes the following two routes:
+//
+//   192.0.2.0/24 (goes to some target A)
+//
+//   192.0.2.0/28 (goes to some target B)
+//
+//   Both routes apply to the traffic destined for 192.0.2.3. However, the
+// second route in the list covers a smaller number of IP addresses and is therefore
+// more specific, so we use that route to determine where to target the traffic.
+//
+// For more information about route tables, see Route Tables (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Route_Tables.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) CreateRoute(input *CreateRouteInput) (*CreateRouteOutput, error) {
+	req, out := c.CreateRouteRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateRouteTable = "CreateRouteTable"
+
+// CreateRouteTableRequest generates a request for the CreateRouteTable operation.
+func (c *EC2) CreateRouteTableRequest(input *CreateRouteTableInput) (req *aws.Request, output *CreateRouteTableOutput) {
+	op := &aws.Operation{
+		Name:       opCreateRouteTable,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateRouteTableInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateRouteTableOutput{}
+	req.Data = output
+	return
+}
+
+// Creates a route table for the specified VPC. After you create a route table,
+// you can add routes and associate the table with a subnet.
+//
+// For more information about route tables, see Route Tables (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Route_Tables.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) CreateRouteTable(input *CreateRouteTableInput) (*CreateRouteTableOutput, error) {
+	req, out := c.CreateRouteTableRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateSecurityGroup = "CreateSecurityGroup"
+
+// CreateSecurityGroupRequest generates a request for the CreateSecurityGroup operation.
+func (c *EC2) CreateSecurityGroupRequest(input *CreateSecurityGroupInput) (req *aws.Request, output *CreateSecurityGroupOutput) {
+	op := &aws.Operation{
+		Name:       opCreateSecurityGroup,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateSecurityGroupInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateSecurityGroupOutput{}
+	req.Data = output
+	return
+}
+
+// Creates a security group.
+//
+// A security group is for use with instances either in the EC2-Classic platform
+// or in a specific VPC. For more information, see Amazon EC2 Security Groups
+// (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html)
+// in the Amazon Elastic Compute Cloud User Guide and Security Groups for Your
+// VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_SecurityGroups.html)
+// in the Amazon Virtual Private Cloud User Guide.
+//
+//  EC2-Classic: You can have up to 500 security groups.
+//
+// EC2-VPC: You can create up to 100 security groups per VPC.
+//
+//  When you create a security group, you specify a friendly name of your choice.
+// You can have a security group for use in EC2-Classic with the same name as
+// a security group for use in a VPC. However, you can't have two security groups
+// for use in EC2-Classic with the same name or two security groups for use
+// in a VPC with the same name.
+//
+// You have a default security group for use in EC2-Classic and a default security
+// group for use in your VPC. If you don't specify a security group when you
+// launch an instance, the instance is launched into the appropriate default
+// security group. A default security group includes a default rule that grants
+// instances unrestricted network access to each other.
+//
+// You can add or remove rules from your security groups using AuthorizeSecurityGroupIngress,
+// AuthorizeSecurityGroupEgress, RevokeSecurityGroupIngress, and RevokeSecurityGroupEgress.
+func (c *EC2) CreateSecurityGroup(input *CreateSecurityGroupInput) (*CreateSecurityGroupOutput, error) {
+	req, out := c.CreateSecurityGroupRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateSnapshot = "CreateSnapshot"
+
+// CreateSnapshotRequest generates a request for the CreateSnapshot operation.
+func (c *EC2) CreateSnapshotRequest(input *CreateSnapshotInput) (req *aws.Request, output *Snapshot) {
+	op := &aws.Operation{
+		Name:       opCreateSnapshot,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateSnapshotInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &Snapshot{}
+	req.Data = output
+	return
+}
+
+// Creates a snapshot of an EBS volume and stores it in Amazon S3. You can use
+// snapshots for backups, to make copies of EBS volumes, and to save data before
+// shutting down an instance.
+//
+// When a snapshot is created, any AWS Marketplace product codes that are associated
+// with the source volume are propagated to the snapshot.
+//
+// You can take a snapshot of an attached volume that is in use. However, snapshots
+// only capture data that has been written to your EBS volume at the time the
+// snapshot command is issued; this may exclude any data that has been cached
+// by any applications or the operating system. If you can pause any file systems
+// on the volume long enough to take a snapshot, your snapshot should be complete.
+// However, if you cannot pause all file writes to the volume, you should unmount
+// the volume from within the instance, issue the snapshot command, and then
+// remount the volume to ensure a consistent and complete snapshot. You may
+// remount and use your volume while the snapshot status is pending.
+//
+// To create a snapshot for EBS volumes that serve as root devices, you should
+// stop the instance before taking the snapshot.
+//
+// Snapshots that are taken from encrypted volumes are automatically encrypted.
+// Volumes that are created from encrypted snapshots are also automatically
+// encrypted. Your encrypted volumes and any associated snapshots always remain
+// protected.
+//
+// For more information, see Amazon Elastic Block Store (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html)
+// and Amazon EBS Encryption (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) CreateSnapshot(input *CreateSnapshotInput) (*Snapshot, error) {
+	req, out := c.CreateSnapshotRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateSpotDatafeedSubscription = "CreateSpotDatafeedSubscription"
+
+// CreateSpotDatafeedSubscriptionRequest generates a request for the CreateSpotDatafeedSubscription operation.
+func (c *EC2) CreateSpotDatafeedSubscriptionRequest(input *CreateSpotDatafeedSubscriptionInput) (req *aws.Request, output *CreateSpotDatafeedSubscriptionOutput) {
+	op := &aws.Operation{
+		Name:       opCreateSpotDatafeedSubscription,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateSpotDatafeedSubscriptionInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateSpotDatafeedSubscriptionOutput{}
+	req.Data = output
+	return
+}
+
+// Creates a data feed for Spot Instances, enabling you to view Spot Instance
+// usage logs. You can create one data feed per AWS account. For more information,
+// see Spot Instance Data Feed (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-data-feeds.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) CreateSpotDatafeedSubscription(input *CreateSpotDatafeedSubscriptionInput) (*CreateSpotDatafeedSubscriptionOutput, error) {
+	req, out := c.CreateSpotDatafeedSubscriptionRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateSubnet = "CreateSubnet"
+
+// CreateSubnetRequest generates a request for the CreateSubnet operation.
+func (c *EC2) CreateSubnetRequest(input *CreateSubnetInput) (req *aws.Request, output *CreateSubnetOutput) {
+	op := &aws.Operation{
+		Name:       opCreateSubnet,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateSubnetInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateSubnetOutput{}
+	req.Data = output
+	return
+}
+
+// Creates a subnet in an existing VPC.
+//
+// When you create each subnet, you provide the VPC ID and the CIDR block you
+// want for the subnet. After you create a subnet, you can't change its CIDR
+// block. The subnet's CIDR block can be the same as the VPC's CIDR block (assuming
+// you want only a single subnet in the VPC), or a subset of the VPC's CIDR
+// block. If you create more than one subnet in a VPC, the subnets' CIDR blocks
+// must not overlap. The smallest subnet (and VPC) you can create uses a /28
+// netmask (16 IP addresses), and the largest uses a /16 netmask (65,536 IP
+// addresses).
+//
+//  AWS reserves both the first four and the last IP address in each subnet's
+// CIDR block. They're not available for use.
+//
+//  If you add more than one subnet to a VPC, they're set up in a star topology
+// with a logical router in the middle.
+//
+// If you launch an instance in a VPC using an Amazon EBS-backed AMI, the IP
+// address doesn't change if you stop and restart the instance (unlike a similar
+// instance launched outside a VPC, which gets a new IP address when restarted).
+// It's therefore possible to have a subnet with no running instances (they're
+// all stopped), but no remaining IP addresses available.
+//
+// For more information about subnets, see Your VPC and Subnets (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Subnets.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) CreateSubnet(input *CreateSubnetInput) (*CreateSubnetOutput, error) {
+	req, out := c.CreateSubnetRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateTags = "CreateTags"
+
+// CreateTagsRequest generates a request for the CreateTags operation.
+func (c *EC2) CreateTagsRequest(input *CreateTagsInput) (req *aws.Request, output *CreateTagsOutput) {
+	op := &aws.Operation{
+		Name:       opCreateTags,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateTagsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateTagsOutput{}
+	req.Data = output
+	return
+}
+
+// Adds or overwrites one or more tags for the specified Amazon EC2 resource
+// or resources. Each resource can have a maximum of 10 tags. Each tag consists
+// of a key and optional value. Tag keys must be unique per resource.
+//
+// For more information about tags, see Tagging Your Resources (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) CreateTags(input *CreateTagsInput) (*CreateTagsOutput, error) {
+	req, out := c.CreateTagsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateVPC = "CreateVpc"
+
+// CreateVPCRequest generates a request for the CreateVPC operation.
+func (c *EC2) CreateVPCRequest(input *CreateVPCInput) (req *aws.Request, output *CreateVPCOutput) {
+	op := &aws.Operation{
+		Name:       opCreateVPC,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateVPCInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateVPCOutput{}
+	req.Data = output
+	return
+}
+
+// Creates a VPC with the specified CIDR block.
+//
+// The smallest VPC you can create uses a /28 netmask (16 IP addresses), and
+// the largest uses a /16 netmask (65,536 IP addresses). To help you decide
+// how big to make your VPC, see Your VPC and Subnets (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Subnets.html)
+// in the Amazon Virtual Private Cloud User Guide.
+//
+// By default, each instance you launch in the VPC has the default DHCP options,
+// which includes only a default DNS server that we provide (AmazonProvidedDNS).
+// For more information about DHCP options, see DHCP Options Sets (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_DHCP_Options.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) CreateVPC(input *CreateVPCInput) (*CreateVPCOutput, error) {
+	req, out := c.CreateVPCRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateVPCEndpoint = "CreateVpcEndpoint"
+
+// CreateVPCEndpointRequest generates a request for the CreateVPCEndpoint operation.
+func (c *EC2) CreateVPCEndpointRequest(input *CreateVPCEndpointInput) (req *aws.Request, output *CreateVPCEndpointOutput) {
+	op := &aws.Operation{
+		Name:       opCreateVPCEndpoint,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateVPCEndpointInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateVPCEndpointOutput{}
+	req.Data = output
+	return
+}
+
+// Creates a VPC endpoint for a specified AWS service. An endpoint enables you
+// to create a private connection between your VPC and another AWS service in
+// your account. You can specify an endpoint policy to attach to the endpoint
+// that will control access to the service from your VPC. You can also specify
+// the VPC route tables that use the endpoint.
+//
+// Currently, only endpoints to Amazon S3 are supported.
+func (c *EC2) CreateVPCEndpoint(input *CreateVPCEndpointInput) (*CreateVPCEndpointOutput, error) {
+	req, out := c.CreateVPCEndpointRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateVPCPeeringConnection = "CreateVpcPeeringConnection"
+
+// CreateVPCPeeringConnectionRequest generates a request for the CreateVPCPeeringConnection operation.
+func (c *EC2) CreateVPCPeeringConnectionRequest(input *CreateVPCPeeringConnectionInput) (req *aws.Request, output *CreateVPCPeeringConnectionOutput) {
+	op := &aws.Operation{
+		Name:       opCreateVPCPeeringConnection,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateVPCPeeringConnectionInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateVPCPeeringConnectionOutput{}
+	req.Data = output
+	return
+}
+
+// Requests a VPC peering connection between two VPCs: a requester VPC that
+// you own and a peer VPC with which to create the connection. The peer VPC
+// can belong to another AWS account. The requester VPC and peer VPC cannot
+// have overlapping CIDR blocks.
+//
+// The owner of the peer VPC must accept the peering request to activate the
+// peering connection. The VPC peering connection request expires after 7 days,
+// after which it cannot be accepted or rejected.
+//
+// A CreateVpcPeeringConnection request between VPCs with overlapping CIDR
+// blocks results in the VPC peering connection having a status of failed.
+func (c *EC2) CreateVPCPeeringConnection(input *CreateVPCPeeringConnectionInput) (*CreateVPCPeeringConnectionOutput, error) {
+	req, out := c.CreateVPCPeeringConnectionRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateVPNConnection = "CreateVpnConnection"
+
+// CreateVPNConnectionRequest generates a request for the CreateVPNConnection operation.
+func (c *EC2) CreateVPNConnectionRequest(input *CreateVPNConnectionInput) (req *aws.Request, output *CreateVPNConnectionOutput) {
+	op := &aws.Operation{
+		Name:       opCreateVPNConnection,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateVPNConnectionInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateVPNConnectionOutput{}
+	req.Data = output
+	return
+}
+
+// Creates a VPN connection between an existing virtual private gateway and
+// a VPN customer gateway. The only supported connection type is ipsec.1.
+//
+// The response includes information that you need to give to your network
+// administrator to configure your customer gateway.
+//
+//  We strongly recommend that you use HTTPS when calling this operation because
+// the response contains sensitive cryptographic information for configuring
+// your customer gateway.
+//
+//  If you decide to shut down your VPN connection for any reason and later
+// create a new VPN connection, you must reconfigure your customer gateway with
+// the new information returned from this call.
+//
+// For more information about VPN connections, see Adding a Hardware Virtual
+// Private Gateway to Your VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_VPN.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) CreateVPNConnection(input *CreateVPNConnectionInput) (*CreateVPNConnectionOutput, error) {
+	req, out := c.CreateVPNConnectionRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateVPNConnectionRoute = "CreateVpnConnectionRoute"
+
+// CreateVPNConnectionRouteRequest generates a request for the CreateVPNConnectionRoute operation.
+func (c *EC2) CreateVPNConnectionRouteRequest(input *CreateVPNConnectionRouteInput) (req *aws.Request, output *CreateVPNConnectionRouteOutput) {
+	op := &aws.Operation{
+		Name:       opCreateVPNConnectionRoute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateVPNConnectionRouteInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateVPNConnectionRouteOutput{}
+	req.Data = output
+	return
+}
+
+// Creates a static route associated with a VPN connection between an existing
+// virtual private gateway and a VPN customer gateway. The static route allows
+// traffic to be routed from the virtual private gateway to the VPN customer
+// gateway.
+//
+// For more information about VPN connections, see Adding a Hardware Virtual
+// Private Gateway to Your VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_VPN.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) CreateVPNConnectionRoute(input *CreateVPNConnectionRouteInput) (*CreateVPNConnectionRouteOutput, error) {
+	req, out := c.CreateVPNConnectionRouteRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateVPNGateway = "CreateVpnGateway"
+
+// CreateVPNGatewayRequest generates a request for the CreateVPNGateway operation.
+func (c *EC2) CreateVPNGatewayRequest(input *CreateVPNGatewayInput) (req *aws.Request, output *CreateVPNGatewayOutput) {
+	op := &aws.Operation{
+		Name:       opCreateVPNGateway,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateVPNGatewayInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &CreateVPNGatewayOutput{}
+	req.Data = output
+	return
+}
+
+// Creates a virtual private gateway. A virtual private gateway is the endpoint
+// on the VPC side of your VPN connection. You can create a virtual private
+// gateway before creating the VPC itself.
+//
+// For more information about virtual private gateways, see Adding a Hardware
+// Virtual Private Gateway to Your VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_VPN.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) CreateVPNGateway(input *CreateVPNGatewayInput) (*CreateVPNGatewayOutput, error) {
+	req, out := c.CreateVPNGatewayRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opCreateVolume = "CreateVolume"
+
+// CreateVolumeRequest generates a request for the CreateVolume operation.
+func (c *EC2) CreateVolumeRequest(input *CreateVolumeInput) (req *aws.Request, output *Volume) {
+	op := &aws.Operation{
+		Name:       opCreateVolume,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateVolumeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &Volume{}
+	req.Data = output
+	return
+}
+
+// Creates an EBS volume that can be attached to an instance in the same Availability
+// Zone. The volume is created in the regional endpoint that you send the HTTP
+// request to. For more information see Regions and Endpoints (http://docs.aws.amazon.com/general/latest/gr/rande.html).
+//
+// You can create a new empty volume or restore a volume from an EBS snapshot.
+// Any AWS Marketplace product codes from the snapshot are propagated to the
+// volume.
+//
+// You can create encrypted volumes with the Encrypted parameter. Encrypted
+// volumes may only be attached to instances that support Amazon EBS encryption.
+// Volumes that are created from encrypted snapshots are also automatically
+// encrypted. For more information, see Amazon EBS Encryption (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+//
+// For more information, see Creating or Restoring an Amazon EBS Volume (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-creating-volume.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) CreateVolume(input *CreateVolumeInput) (*Volume, error) {
+	req, out := c.CreateVolumeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteCustomerGateway = "DeleteCustomerGateway"
+
+// DeleteCustomerGatewayRequest generates a request for the DeleteCustomerGateway operation.
+func (c *EC2) DeleteCustomerGatewayRequest(input *DeleteCustomerGatewayInput) (req *aws.Request, output *DeleteCustomerGatewayOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteCustomerGateway,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteCustomerGatewayInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteCustomerGatewayOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes the specified customer gateway. You must delete the VPN connection
+// before you can delete the customer gateway.
+func (c *EC2) DeleteCustomerGateway(input *DeleteCustomerGatewayInput) (*DeleteCustomerGatewayOutput, error) {
+	req, out := c.DeleteCustomerGatewayRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteDHCPOptions = "DeleteDhcpOptions"
+
+// DeleteDHCPOptionsRequest generates a request for the DeleteDHCPOptions operation.
+func (c *EC2) DeleteDHCPOptionsRequest(input *DeleteDHCPOptionsInput) (req *aws.Request, output *DeleteDHCPOptionsOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteDHCPOptions,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteDHCPOptionsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteDHCPOptionsOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes the specified set of DHCP options. You must disassociate the set
+// of DHCP options before you can delete it. You can disassociate the set of
+// DHCP options by associating either a new set of options or the default set
+// of options with the VPC.
+func (c *EC2) DeleteDHCPOptions(input *DeleteDHCPOptionsInput) (*DeleteDHCPOptionsOutput, error) {
+	req, out := c.DeleteDHCPOptionsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteFlowLogs = "DeleteFlowLogs"
+
+// DeleteFlowLogsRequest generates a request for the DeleteFlowLogs operation.
+func (c *EC2) DeleteFlowLogsRequest(input *DeleteFlowLogsInput) (req *aws.Request, output *DeleteFlowLogsOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteFlowLogs,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteFlowLogsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteFlowLogsOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes one or more flow logs.
+func (c *EC2) DeleteFlowLogs(input *DeleteFlowLogsInput) (*DeleteFlowLogsOutput, error) {
+	req, out := c.DeleteFlowLogsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteInternetGateway = "DeleteInternetGateway"
+
+// DeleteInternetGatewayRequest generates a request for the DeleteInternetGateway operation.
+func (c *EC2) DeleteInternetGatewayRequest(input *DeleteInternetGatewayInput) (req *aws.Request, output *DeleteInternetGatewayOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteInternetGateway,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteInternetGatewayInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteInternetGatewayOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes the specified Internet gateway. You must detach the Internet gateway
+// from the VPC before you can delete it.
+func (c *EC2) DeleteInternetGateway(input *DeleteInternetGatewayInput) (*DeleteInternetGatewayOutput, error) {
+	req, out := c.DeleteInternetGatewayRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteKeyPair = "DeleteKeyPair"
+
+// DeleteKeyPairRequest generates a request for the DeleteKeyPair operation.
+func (c *EC2) DeleteKeyPairRequest(input *DeleteKeyPairInput) (req *aws.Request, output *DeleteKeyPairOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteKeyPair,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteKeyPairInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteKeyPairOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes the specified key pair, by removing the public key from Amazon EC2.
+func (c *EC2) DeleteKeyPair(input *DeleteKeyPairInput) (*DeleteKeyPairOutput, error) {
+	req, out := c.DeleteKeyPairRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteNetworkACL = "DeleteNetworkAcl"
+
+// DeleteNetworkACLRequest generates a request for the DeleteNetworkACL operation.
+func (c *EC2) DeleteNetworkACLRequest(input *DeleteNetworkACLInput) (req *aws.Request, output *DeleteNetworkACLOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteNetworkACL,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteNetworkACLInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteNetworkACLOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes the specified network ACL. You can't delete the ACL if it's associated
+// with any subnets. You can't delete the default network ACL.
+func (c *EC2) DeleteNetworkACL(input *DeleteNetworkACLInput) (*DeleteNetworkACLOutput, error) {
+	req, out := c.DeleteNetworkACLRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteNetworkACLEntry = "DeleteNetworkAclEntry"
+
+// DeleteNetworkACLEntryRequest generates a request for the DeleteNetworkACLEntry operation.
+func (c *EC2) DeleteNetworkACLEntryRequest(input *DeleteNetworkACLEntryInput) (req *aws.Request, output *DeleteNetworkACLEntryOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteNetworkACLEntry,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteNetworkACLEntryInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteNetworkACLEntryOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes the specified ingress or egress entry (rule) from the specified network
+// ACL.
+func (c *EC2) DeleteNetworkACLEntry(input *DeleteNetworkACLEntryInput) (*DeleteNetworkACLEntryOutput, error) {
+	req, out := c.DeleteNetworkACLEntryRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteNetworkInterface = "DeleteNetworkInterface"
+
+// DeleteNetworkInterfaceRequest generates a request for the DeleteNetworkInterface operation.
+func (c *EC2) DeleteNetworkInterfaceRequest(input *DeleteNetworkInterfaceInput) (req *aws.Request, output *DeleteNetworkInterfaceOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteNetworkInterface,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteNetworkInterfaceInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteNetworkInterfaceOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes the specified network interface. You must detach the network interface
+// before you can delete it.
+func (c *EC2) DeleteNetworkInterface(input *DeleteNetworkInterfaceInput) (*DeleteNetworkInterfaceOutput, error) {
+	req, out := c.DeleteNetworkInterfaceRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeletePlacementGroup = "DeletePlacementGroup"
+
+// DeletePlacementGroupRequest generates a request for the DeletePlacementGroup operation.
+func (c *EC2) DeletePlacementGroupRequest(input *DeletePlacementGroupInput) (req *aws.Request, output *DeletePlacementGroupOutput) {
+	op := &aws.Operation{
+		Name:       opDeletePlacementGroup,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeletePlacementGroupInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeletePlacementGroupOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes the specified placement group. You must terminate all instances in
+// the placement group before you can delete the placement group. For more information
+// about placement groups and cluster instances, see Cluster Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using_cluster_computing.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) DeletePlacementGroup(input *DeletePlacementGroupInput) (*DeletePlacementGroupOutput, error) {
+	req, out := c.DeletePlacementGroupRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteRoute = "DeleteRoute"
+
+// DeleteRouteRequest generates a request for the DeleteRoute operation.
+func (c *EC2) DeleteRouteRequest(input *DeleteRouteInput) (req *aws.Request, output *DeleteRouteOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteRoute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteRouteInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteRouteOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes the specified route from the specified route table.
+func (c *EC2) DeleteRoute(input *DeleteRouteInput) (*DeleteRouteOutput, error) {
+	req, out := c.DeleteRouteRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteRouteTable = "DeleteRouteTable"
+
+// DeleteRouteTableRequest generates a request for the DeleteRouteTable operation.
+func (c *EC2) DeleteRouteTableRequest(input *DeleteRouteTableInput) (req *aws.Request, output *DeleteRouteTableOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteRouteTable,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteRouteTableInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteRouteTableOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes the specified route table. You must disassociate the route table
+// from any subnets before you can delete it. You can't delete the main route
+// table.
+func (c *EC2) DeleteRouteTable(input *DeleteRouteTableInput) (*DeleteRouteTableOutput, error) {
+	req, out := c.DeleteRouteTableRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteSecurityGroup = "DeleteSecurityGroup"
+
+// DeleteSecurityGroupRequest generates a request for the DeleteSecurityGroup operation.
+func (c *EC2) DeleteSecurityGroupRequest(input *DeleteSecurityGroupInput) (req *aws.Request, output *DeleteSecurityGroupOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteSecurityGroup,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteSecurityGroupInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteSecurityGroupOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes a security group.
+//
+// If you attempt to delete a security group that is associated with an instance,
+// or is referenced by another security group, the operation fails with InvalidGroup.InUse
+// in EC2-Classic or DependencyViolation in EC2-VPC.
+func (c *EC2) DeleteSecurityGroup(input *DeleteSecurityGroupInput) (*DeleteSecurityGroupOutput, error) {
+	req, out := c.DeleteSecurityGroupRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteSnapshot = "DeleteSnapshot"
+
+// DeleteSnapshotRequest generates a request for the DeleteSnapshot operation.
+func (c *EC2) DeleteSnapshotRequest(input *DeleteSnapshotInput) (req *aws.Request, output *DeleteSnapshotOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteSnapshot,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteSnapshotInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteSnapshotOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes the specified snapshot.
+//
+// When you make periodic snapshots of a volume, the snapshots are incremental,
+// and only the blocks on the device that have changed since your last snapshot
+// are saved in the new snapshot. When you delete a snapshot, only the data
+// not needed for any other snapshot is removed. So regardless of which prior
+// snapshots have been deleted, all active snapshots will have access to all
+// the information needed to restore the volume.
+//
+// You cannot delete a snapshot of the root device of an EBS volume used by
+// a registered AMI. You must first de-register the AMI before you can delete
+// the snapshot.
+//
+// For more information, see Deleting an Amazon EBS Snapshot (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-deleting-snapshot.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) DeleteSnapshot(input *DeleteSnapshotInput) (*DeleteSnapshotOutput, error) {
+	req, out := c.DeleteSnapshotRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteSpotDatafeedSubscription = "DeleteSpotDatafeedSubscription"
+
+// DeleteSpotDatafeedSubscriptionRequest generates a request for the DeleteSpotDatafeedSubscription operation.
+func (c *EC2) DeleteSpotDatafeedSubscriptionRequest(input *DeleteSpotDatafeedSubscriptionInput) (req *aws.Request, output *DeleteSpotDatafeedSubscriptionOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteSpotDatafeedSubscription,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteSpotDatafeedSubscriptionInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteSpotDatafeedSubscriptionOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes the data feed for Spot Instances. For more information, see Spot
+// Instance Data Feed (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-data-feeds.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) DeleteSpotDatafeedSubscription(input *DeleteSpotDatafeedSubscriptionInput) (*DeleteSpotDatafeedSubscriptionOutput, error) {
+	req, out := c.DeleteSpotDatafeedSubscriptionRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteSubnet = "DeleteSubnet"
+
+// DeleteSubnetRequest generates a request for the DeleteSubnet operation.
+func (c *EC2) DeleteSubnetRequest(input *DeleteSubnetInput) (req *aws.Request, output *DeleteSubnetOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteSubnet,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteSubnetInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteSubnetOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes the specified subnet. You must terminate all running instances in
+// the subnet before you can delete the subnet.
+func (c *EC2) DeleteSubnet(input *DeleteSubnetInput) (*DeleteSubnetOutput, error) {
+	req, out := c.DeleteSubnetRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteTags = "DeleteTags"
+
+// DeleteTagsRequest generates a request for the DeleteTags operation.
+func (c *EC2) DeleteTagsRequest(input *DeleteTagsInput) (req *aws.Request, output *DeleteTagsOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteTags,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteTagsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteTagsOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes the specified set of tags from the specified set of resources. This
+// call is designed to follow a DescribeTags request.
+//
+// For more information about tags, see Tagging Your Resources (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) DeleteTags(input *DeleteTagsInput) (*DeleteTagsOutput, error) {
+	req, out := c.DeleteTagsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteVPC = "DeleteVpc"
+
+// DeleteVPCRequest generates a request for the DeleteVPC operation.
+func (c *EC2) DeleteVPCRequest(input *DeleteVPCInput) (req *aws.Request, output *DeleteVPCOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteVPC,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteVPCInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteVPCOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes the specified VPC. You must detach or delete all gateways and resources
+// that are associated with the VPC before you can delete it. For example, you
+// must terminate all instances running in the VPC, delete all security groups
+// associated with the VPC (except the default one), delete all route tables
+// associated with the VPC (except the default one), and so on.
+func (c *EC2) DeleteVPC(input *DeleteVPCInput) (*DeleteVPCOutput, error) {
+	req, out := c.DeleteVPCRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteVPCEndpoints = "DeleteVpcEndpoints"
+
+// DeleteVPCEndpointsRequest generates a request for the DeleteVPCEndpoints operation.
+func (c *EC2) DeleteVPCEndpointsRequest(input *DeleteVPCEndpointsInput) (req *aws.Request, output *DeleteVPCEndpointsOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteVPCEndpoints,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteVPCEndpointsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteVPCEndpointsOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes one or more specified VPC endpoints. Deleting the endpoint also deletes
+// the endpoint routes in the route tables that were associated with the endpoint.
+func (c *EC2) DeleteVPCEndpoints(input *DeleteVPCEndpointsInput) (*DeleteVPCEndpointsOutput, error) {
+	req, out := c.DeleteVPCEndpointsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteVPCPeeringConnection = "DeleteVpcPeeringConnection"
+
+// DeleteVPCPeeringConnectionRequest generates a request for the DeleteVPCPeeringConnection operation.
+func (c *EC2) DeleteVPCPeeringConnectionRequest(input *DeleteVPCPeeringConnectionInput) (req *aws.Request, output *DeleteVPCPeeringConnectionOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteVPCPeeringConnection,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteVPCPeeringConnectionInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteVPCPeeringConnectionOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes a VPC peering connection. Either the owner of the requester VPC or
+// the owner of the peer VPC can delete the VPC peering connection if it's in
+// the active state. The owner of the requester VPC can delete a VPC peering
+// connection in the pending-acceptance state.
+func (c *EC2) DeleteVPCPeeringConnection(input *DeleteVPCPeeringConnectionInput) (*DeleteVPCPeeringConnectionOutput, error) {
+	req, out := c.DeleteVPCPeeringConnectionRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteVPNConnection = "DeleteVpnConnection"
+
+// DeleteVPNConnectionRequest generates a request for the DeleteVPNConnection operation.
+func (c *EC2) DeleteVPNConnectionRequest(input *DeleteVPNConnectionInput) (req *aws.Request, output *DeleteVPNConnectionOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteVPNConnection,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteVPNConnectionInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteVPNConnectionOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes the specified VPN connection.
+//
+// If you're deleting the VPC and its associated components, we recommend that
+// you detach the virtual private gateway from the VPC and delete the VPC before
+// deleting the VPN connection. If you believe that the tunnel credentials for
+// your VPN connection have been compromised, you can delete the VPN connection
+// and create a new one that has new keys, without needing to delete the VPC
+// or virtual private gateway. If you create a new VPN connection, you must
+// reconfigure the customer gateway using the new configuration information
+// returned with the new VPN connection ID.
+func (c *EC2) DeleteVPNConnection(input *DeleteVPNConnectionInput) (*DeleteVPNConnectionOutput, error) {
+	req, out := c.DeleteVPNConnectionRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteVPNConnectionRoute = "DeleteVpnConnectionRoute"
+
+// DeleteVPNConnectionRouteRequest generates a request for the DeleteVPNConnectionRoute operation.
+func (c *EC2) DeleteVPNConnectionRouteRequest(input *DeleteVPNConnectionRouteInput) (req *aws.Request, output *DeleteVPNConnectionRouteOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteVPNConnectionRoute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteVPNConnectionRouteInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteVPNConnectionRouteOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes the specified static route associated with a VPN connection between
+// an existing virtual private gateway and a VPN customer gateway. The static
+// route allows traffic to be routed from the virtual private gateway to the
+// VPN customer gateway.
+func (c *EC2) DeleteVPNConnectionRoute(input *DeleteVPNConnectionRouteInput) (*DeleteVPNConnectionRouteOutput, error) {
+	req, out := c.DeleteVPNConnectionRouteRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteVPNGateway = "DeleteVpnGateway"
+
+// DeleteVPNGatewayRequest generates a request for the DeleteVPNGateway operation.
+func (c *EC2) DeleteVPNGatewayRequest(input *DeleteVPNGatewayInput) (req *aws.Request, output *DeleteVPNGatewayOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteVPNGateway,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteVPNGatewayInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteVPNGatewayOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes the specified virtual private gateway. We recommend that before you
+// delete a virtual private gateway, you detach it from the VPC and delete the
+// VPN connection. Note that you don't need to delete the virtual private gateway
+// if you plan to delete and recreate the VPN connection between your VPC and
+// your network.
+func (c *EC2) DeleteVPNGateway(input *DeleteVPNGatewayInput) (*DeleteVPNGatewayOutput, error) {
+	req, out := c.DeleteVPNGatewayRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeleteVolume = "DeleteVolume"
+
+// DeleteVolumeRequest generates a request for the DeleteVolume operation.
+func (c *EC2) DeleteVolumeRequest(input *DeleteVolumeInput) (req *aws.Request, output *DeleteVolumeOutput) {
+	op := &aws.Operation{
+		Name:       opDeleteVolume,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteVolumeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeleteVolumeOutput{}
+	req.Data = output
+	return
+}
+
+// Deletes the specified EBS volume. The volume must be in the available state
+// (not attached to an instance).
+//
+//  The volume may remain in the deleting state for several minutes.
+//
+//  For more information, see Deleting an Amazon EBS Volume (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-deleting-volume.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) DeleteVolume(input *DeleteVolumeInput) (*DeleteVolumeOutput, error) {
+	req, out := c.DeleteVolumeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDeregisterImage = "DeregisterImage"
+
+// DeregisterImageRequest generates a request for the DeregisterImage operation.
+func (c *EC2) DeregisterImageRequest(input *DeregisterImageInput) (req *aws.Request, output *DeregisterImageOutput) {
+	op := &aws.Operation{
+		Name:       opDeregisterImage,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeregisterImageInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DeregisterImageOutput{}
+	req.Data = output
+	return
+}
+
+// Deregisters the specified AMI. After you deregister an AMI, it can't be used
+// to launch new instances.
+//
+// This command does not delete the AMI.
+func (c *EC2) DeregisterImage(input *DeregisterImageInput) (*DeregisterImageOutput, error) {
+	req, out := c.DeregisterImageRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeAccountAttributes = "DescribeAccountAttributes"
+
+// DescribeAccountAttributesRequest generates a request for the DescribeAccountAttributes operation.
+func (c *EC2) DescribeAccountAttributesRequest(input *DescribeAccountAttributesInput) (req *aws.Request, output *DescribeAccountAttributesOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeAccountAttributes,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeAccountAttributesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeAccountAttributesOutput{}
+	req.Data = output
+	return
+}
+
+// Describes attributes of your AWS account. The following are the supported
+// account attributes:
+//
+//   supported-platforms: Indicates whether your account can launch instances
+// into EC2-Classic and EC2-VPC, or only into EC2-VPC.
+//
+//   default-vpc: The ID of the default VPC for your account, or none.
+//
+//   max-instances: The maximum number of On-Demand instances that you can
+// run.
+//
+//   vpc-max-security-groups-per-interface: The maximum number of security
+// groups that you can assign to a network interface.
+//
+//   max-elastic-ips: The maximum number of Elastic IP addresses that you can
+// allocate for use with EC2-Classic.
+//
+//   vpc-max-elastic-ips: The maximum number of Elastic IP addresses that you
+// can allocate for use with EC2-VPC.
+func (c *EC2) DescribeAccountAttributes(input *DescribeAccountAttributesInput) (*DescribeAccountAttributesOutput, error) {
+	req, out := c.DescribeAccountAttributesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeAddresses = "DescribeAddresses"
+
+// DescribeAddressesRequest generates a request for the DescribeAddresses operation.
+func (c *EC2) DescribeAddressesRequest(input *DescribeAddressesInput) (req *aws.Request, output *DescribeAddressesOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeAddresses,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeAddressesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeAddressesOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your Elastic IP addresses.
+//
+// An Elastic IP address is for use in either the EC2-Classic platform or in
+// a VPC. For more information, see Elastic IP Addresses (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) DescribeAddresses(input *DescribeAddressesInput) (*DescribeAddressesOutput, error) {
+	req, out := c.DescribeAddressesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeAvailabilityZones = "DescribeAvailabilityZones"
+
+// DescribeAvailabilityZonesRequest generates a request for the DescribeAvailabilityZones operation.
+func (c *EC2) DescribeAvailabilityZonesRequest(input *DescribeAvailabilityZonesInput) (req *aws.Request, output *DescribeAvailabilityZonesOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeAvailabilityZones,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeAvailabilityZonesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeAvailabilityZonesOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of the Availability Zones that are available to you.
+// The results include zones only for the region you're currently using. If
+// there is an event impacting an Availability Zone, you can use this request
+// to view the state and any provided message for that Availability Zone.
+//
+// For more information, see Regions and Availability Zones (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) DescribeAvailabilityZones(input *DescribeAvailabilityZonesInput) (*DescribeAvailabilityZonesOutput, error) {
+	req, out := c.DescribeAvailabilityZonesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeBundleTasks = "DescribeBundleTasks"
+
+// DescribeBundleTasksRequest generates a request for the DescribeBundleTasks operation.
+func (c *EC2) DescribeBundleTasksRequest(input *DescribeBundleTasksInput) (req *aws.Request, output *DescribeBundleTasksOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeBundleTasks,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeBundleTasksInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeBundleTasksOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your bundling tasks.
+//
+// Completed bundle tasks are listed for only a limited time. If your bundle
+// task is no longer in the list, you can still register an AMI from it. Just
+// use RegisterImage with the Amazon S3 bucket name and image manifest name
+// you provided to the bundle task.
+func (c *EC2) DescribeBundleTasks(input *DescribeBundleTasksInput) (*DescribeBundleTasksOutput, error) {
+	req, out := c.DescribeBundleTasksRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeClassicLinkInstances = "DescribeClassicLinkInstances"
+
+// DescribeClassicLinkInstancesRequest generates a request for the DescribeClassicLinkInstances operation.
+func (c *EC2) DescribeClassicLinkInstancesRequest(input *DescribeClassicLinkInstancesInput) (req *aws.Request, output *DescribeClassicLinkInstancesOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeClassicLinkInstances,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeClassicLinkInstancesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeClassicLinkInstancesOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your linked EC2-Classic instances. This request
+// only returns information about EC2-Classic instances linked to a VPC through
+// ClassicLink; you cannot use this request to return information about other
+// instances.
+func (c *EC2) DescribeClassicLinkInstances(input *DescribeClassicLinkInstancesInput) (*DescribeClassicLinkInstancesOutput, error) {
+	req, out := c.DescribeClassicLinkInstancesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeConversionTasks = "DescribeConversionTasks"
+
+// DescribeConversionTasksRequest generates a request for the DescribeConversionTasks operation.
+func (c *EC2) DescribeConversionTasksRequest(input *DescribeConversionTasksInput) (req *aws.Request, output *DescribeConversionTasksOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeConversionTasks,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeConversionTasksInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeConversionTasksOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your conversion tasks. For more information, see
+// Using the Command Line Tools to Import Your Virtual Machine to Amazon EC2
+// (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UploadingYourInstancesandVolumes.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) DescribeConversionTasks(input *DescribeConversionTasksInput) (*DescribeConversionTasksOutput, error) {
+	req, out := c.DescribeConversionTasksRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeCustomerGateways = "DescribeCustomerGateways"
+
+// DescribeCustomerGatewaysRequest generates a request for the DescribeCustomerGateways operation.
+func (c *EC2) DescribeCustomerGatewaysRequest(input *DescribeCustomerGatewaysInput) (req *aws.Request, output *DescribeCustomerGatewaysOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeCustomerGateways,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeCustomerGatewaysInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeCustomerGatewaysOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your VPN customer gateways.
+//
+// For more information about VPN customer gateways, see Adding a Hardware
+// Virtual Private Gateway to Your VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_VPN.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) DescribeCustomerGateways(input *DescribeCustomerGatewaysInput) (*DescribeCustomerGatewaysOutput, error) {
+	req, out := c.DescribeCustomerGatewaysRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeDHCPOptions = "DescribeDhcpOptions"
+
+// DescribeDHCPOptionsRequest generates a request for the DescribeDHCPOptions operation.
+func (c *EC2) DescribeDHCPOptionsRequest(input *DescribeDHCPOptionsInput) (req *aws.Request, output *DescribeDHCPOptionsOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeDHCPOptions,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeDHCPOptionsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeDHCPOptionsOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your DHCP options sets.
+//
+// For more information about DHCP options sets, see DHCP Options Sets (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_DHCP_Options.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) DescribeDHCPOptions(input *DescribeDHCPOptionsInput) (*DescribeDHCPOptionsOutput, error) {
+	req, out := c.DescribeDHCPOptionsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeExportTasks = "DescribeExportTasks"
+
+// DescribeExportTasksRequest generates a request for the DescribeExportTasks operation.
+func (c *EC2) DescribeExportTasksRequest(input *DescribeExportTasksInput) (req *aws.Request, output *DescribeExportTasksOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeExportTasks,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeExportTasksInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeExportTasksOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your export tasks.
+func (c *EC2) DescribeExportTasks(input *DescribeExportTasksInput) (*DescribeExportTasksOutput, error) {
+	req, out := c.DescribeExportTasksRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeFlowLogs = "DescribeFlowLogs"
+
+// DescribeFlowLogsRequest generates a request for the DescribeFlowLogs operation.
+func (c *EC2) DescribeFlowLogsRequest(input *DescribeFlowLogsInput) (req *aws.Request, output *DescribeFlowLogsOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeFlowLogs,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeFlowLogsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeFlowLogsOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more flow logs. To view the information in your flow logs
+// (the log streams for the network interfaces), you must use the CloudWatch
+// Logs console or the CloudWatch Logs API.
+func (c *EC2) DescribeFlowLogs(input *DescribeFlowLogsInput) (*DescribeFlowLogsOutput, error) {
+	req, out := c.DescribeFlowLogsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeImageAttribute = "DescribeImageAttribute"
+
+// DescribeImageAttributeRequest generates a request for the DescribeImageAttribute operation.
+func (c *EC2) DescribeImageAttributeRequest(input *DescribeImageAttributeInput) (req *aws.Request, output *DescribeImageAttributeOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeImageAttribute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeImageAttributeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeImageAttributeOutput{}
+	req.Data = output
+	return
+}
+
+// Describes the specified attribute of the specified AMI. You can specify only
+// one attribute at a time.
+func (c *EC2) DescribeImageAttribute(input *DescribeImageAttributeInput) (*DescribeImageAttributeOutput, error) {
+	req, out := c.DescribeImageAttributeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeImages = "DescribeImages"
+
+// DescribeImagesRequest generates a request for the DescribeImages operation.
+func (c *EC2) DescribeImagesRequest(input *DescribeImagesInput) (req *aws.Request, output *DescribeImagesOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeImages,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeImagesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeImagesOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of the images (AMIs, AKIs, and ARIs) available to you.
+// Images available to you include public images, private images that you own,
+// and private images owned by other AWS accounts but for which you have explicit
+// launch permissions.
+//
+// Deregistered images are included in the returned results for an unspecified
+// interval after deregistration.
+func (c *EC2) DescribeImages(input *DescribeImagesInput) (*DescribeImagesOutput, error) {
+	req, out := c.DescribeImagesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeImportImageTasks = "DescribeImportImageTasks"
+
+// DescribeImportImageTasksRequest generates a request for the DescribeImportImageTasks operation.
+func (c *EC2) DescribeImportImageTasksRequest(input *DescribeImportImageTasksInput) (req *aws.Request, output *DescribeImportImageTasksOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeImportImageTasks,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeImportImageTasksInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeImportImageTasksOutput{}
+	req.Data = output
+	return
+}
+
+// Displays details about an import virtual machine or import snapshot tasks
+// that are already created.
+func (c *EC2) DescribeImportImageTasks(input *DescribeImportImageTasksInput) (*DescribeImportImageTasksOutput, error) {
+	req, out := c.DescribeImportImageTasksRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeImportSnapshotTasks = "DescribeImportSnapshotTasks"
+
+// DescribeImportSnapshotTasksRequest generates a request for the DescribeImportSnapshotTasks operation.
+func (c *EC2) DescribeImportSnapshotTasksRequest(input *DescribeImportSnapshotTasksInput) (req *aws.Request, output *DescribeImportSnapshotTasksOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeImportSnapshotTasks,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeImportSnapshotTasksInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeImportSnapshotTasksOutput{}
+	req.Data = output
+	return
+}
+
+// Describes your import snapshot tasks.
+func (c *EC2) DescribeImportSnapshotTasks(input *DescribeImportSnapshotTasksInput) (*DescribeImportSnapshotTasksOutput, error) {
+	req, out := c.DescribeImportSnapshotTasksRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeInstanceAttribute = "DescribeInstanceAttribute"
+
+// DescribeInstanceAttributeRequest generates a request for the DescribeInstanceAttribute operation.
+func (c *EC2) DescribeInstanceAttributeRequest(input *DescribeInstanceAttributeInput) (req *aws.Request, output *DescribeInstanceAttributeOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeInstanceAttribute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeInstanceAttributeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeInstanceAttributeOutput{}
+	req.Data = output
+	return
+}
+
+// Describes the specified attribute of the specified instance. You can specify
+// only one attribute at a time. Valid attribute values are: instanceType |
+// kernel | ramdisk | userData | disableApiTermination | instanceInitiatedShutdownBehavior
+// | rootDeviceName | blockDeviceMapping | productCodes | sourceDestCheck |
+// groupSet | ebsOptimized | sriovNetSupport
+func (c *EC2) DescribeInstanceAttribute(input *DescribeInstanceAttributeInput) (*DescribeInstanceAttributeOutput, error) {
+	req, out := c.DescribeInstanceAttributeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeInstanceStatus = "DescribeInstanceStatus"
+
+// DescribeInstanceStatusRequest generates a request for the DescribeInstanceStatus operation.
+func (c *EC2) DescribeInstanceStatusRequest(input *DescribeInstanceStatusInput) (req *aws.Request, output *DescribeInstanceStatusOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeInstanceStatus,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &aws.Paginator{
+			InputTokens:     []string{"NextToken"},
+			OutputTokens:    []string{"NextToken"},
+			LimitToken:      "MaxResults",
+			TruncationToken: "",
+		},
+	}
+
+	if input == nil {
+		input = &DescribeInstanceStatusInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeInstanceStatusOutput{}
+	req.Data = output
+	return
+}
+
+// Describes the status of one or more instances.
+//
+// Instance status includes the following components:
+//
+//   Status checks - Amazon EC2 performs status checks on running EC2 instances
+// to identify hardware and software issues. For more information, see Status
+// Checks for Your Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-system-instance-status-check.html)
+// and Troubleshooting Instances with Failed Status Checks (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstances.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+//
+//   Scheduled events - Amazon EC2 can schedule events (such as reboot, stop,
+// or terminate) for your instances related to hardware issues, software updates,
+// or system maintenance. For more information, see Scheduled Events for Your
+// Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-instances-status-check_sched.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+//
+//   Instance state - You can manage your instances from the moment you launch
+// them through their termination. For more information, see Instance Lifecycle
+// (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-lifecycle.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) DescribeInstanceStatus(input *DescribeInstanceStatusInput) (*DescribeInstanceStatusOutput, error) {
+	req, out := c.DescribeInstanceStatusRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+func (c *EC2) DescribeInstanceStatusPages(input *DescribeInstanceStatusInput, fn func(p *DescribeInstanceStatusOutput, lastPage bool) (shouldContinue bool)) error {
+	page, _ := c.DescribeInstanceStatusRequest(input)
+	return page.EachPage(func(p interface{}, lastPage bool) bool {
+		return fn(p.(*DescribeInstanceStatusOutput), lastPage)
+	})
+}
+
+const opDescribeInstances = "DescribeInstances"
+
+// DescribeInstancesRequest generates a request for the DescribeInstances operation.
+func (c *EC2) DescribeInstancesRequest(input *DescribeInstancesInput) (req *aws.Request, output *DescribeInstancesOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeInstances,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &aws.Paginator{
+			InputTokens:     []string{"NextToken"},
+			OutputTokens:    []string{"NextToken"},
+			LimitToken:      "MaxResults",
+			TruncationToken: "",
+		},
+	}
+
+	if input == nil {
+		input = &DescribeInstancesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeInstancesOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your instances.
+//
+// If you specify one or more instance IDs, Amazon EC2 returns information
+// for those instances. If you do not specify instance IDs, Amazon EC2 returns
+// information for all relevant instances. If you specify an instance ID that
+// is not valid, an error is returned. If you specify an instance that you do
+// not own, it is not included in the returned results.
+//
+// Recently terminated instances might appear in the returned results. This
+// interval is usually less than one hour.
+func (c *EC2) DescribeInstances(input *DescribeInstancesInput) (*DescribeInstancesOutput, error) {
+	req, out := c.DescribeInstancesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+func (c *EC2) DescribeInstancesPages(input *DescribeInstancesInput, fn func(p *DescribeInstancesOutput, lastPage bool) (shouldContinue bool)) error {
+	page, _ := c.DescribeInstancesRequest(input)
+	return page.EachPage(func(p interface{}, lastPage bool) bool {
+		return fn(p.(*DescribeInstancesOutput), lastPage)
+	})
+}
+
+const opDescribeInternetGateways = "DescribeInternetGateways"
+
+// DescribeInternetGatewaysRequest generates a request for the DescribeInternetGateways operation.
+func (c *EC2) DescribeInternetGatewaysRequest(input *DescribeInternetGatewaysInput) (req *aws.Request, output *DescribeInternetGatewaysOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeInternetGateways,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeInternetGatewaysInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeInternetGatewaysOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your Internet gateways.
+func (c *EC2) DescribeInternetGateways(input *DescribeInternetGatewaysInput) (*DescribeInternetGatewaysOutput, error) {
+	req, out := c.DescribeInternetGatewaysRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeKeyPairs = "DescribeKeyPairs"
+
+// DescribeKeyPairsRequest generates a request for the DescribeKeyPairs operation.
+func (c *EC2) DescribeKeyPairsRequest(input *DescribeKeyPairsInput) (req *aws.Request, output *DescribeKeyPairsOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeKeyPairs,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeKeyPairsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeKeyPairsOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your key pairs.
+//
+// For more information about key pairs, see Key Pairs (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) DescribeKeyPairs(input *DescribeKeyPairsInput) (*DescribeKeyPairsOutput, error) {
+	req, out := c.DescribeKeyPairsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeMovingAddresses = "DescribeMovingAddresses"
+
+// DescribeMovingAddressesRequest generates a request for the DescribeMovingAddresses operation.
+func (c *EC2) DescribeMovingAddressesRequest(input *DescribeMovingAddressesInput) (req *aws.Request, output *DescribeMovingAddressesOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeMovingAddresses,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeMovingAddressesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeMovingAddressesOutput{}
+	req.Data = output
+	return
+}
+
+// Describes your Elastic IP addresses that are being moved to the EC2-VPC platform,
+// or that are being restored to the EC2-Classic platform. This request does
+// not return information about any other Elastic IP addresses in your account.
+func (c *EC2) DescribeMovingAddresses(input *DescribeMovingAddressesInput) (*DescribeMovingAddressesOutput, error) {
+	req, out := c.DescribeMovingAddressesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeNetworkACLs = "DescribeNetworkAcls"
+
+// DescribeNetworkACLsRequest generates a request for the DescribeNetworkACLs operation.
+func (c *EC2) DescribeNetworkACLsRequest(input *DescribeNetworkACLsInput) (req *aws.Request, output *DescribeNetworkACLsOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeNetworkACLs,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeNetworkACLsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeNetworkACLsOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your network ACLs.
+//
+// For more information about network ACLs, see Network ACLs (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_ACLs.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) DescribeNetworkACLs(input *DescribeNetworkACLsInput) (*DescribeNetworkACLsOutput, error) {
+	req, out := c.DescribeNetworkACLsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeNetworkInterfaceAttribute = "DescribeNetworkInterfaceAttribute"
+
+// DescribeNetworkInterfaceAttributeRequest generates a request for the DescribeNetworkInterfaceAttribute operation.
+func (c *EC2) DescribeNetworkInterfaceAttributeRequest(input *DescribeNetworkInterfaceAttributeInput) (req *aws.Request, output *DescribeNetworkInterfaceAttributeOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeNetworkInterfaceAttribute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeNetworkInterfaceAttributeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeNetworkInterfaceAttributeOutput{}
+	req.Data = output
+	return
+}
+
+// Describes a network interface attribute. You can specify only one attribute
+// at a time.
+func (c *EC2) DescribeNetworkInterfaceAttribute(input *DescribeNetworkInterfaceAttributeInput) (*DescribeNetworkInterfaceAttributeOutput, error) {
+	req, out := c.DescribeNetworkInterfaceAttributeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeNetworkInterfaces = "DescribeNetworkInterfaces"
+
+// DescribeNetworkInterfacesRequest generates a request for the DescribeNetworkInterfaces operation.
+func (c *EC2) DescribeNetworkInterfacesRequest(input *DescribeNetworkInterfacesInput) (req *aws.Request, output *DescribeNetworkInterfacesOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeNetworkInterfaces,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeNetworkInterfacesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeNetworkInterfacesOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your network interfaces.
+func (c *EC2) DescribeNetworkInterfaces(input *DescribeNetworkInterfacesInput) (*DescribeNetworkInterfacesOutput, error) {
+	req, out := c.DescribeNetworkInterfacesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribePlacementGroups = "DescribePlacementGroups"
+
+// DescribePlacementGroupsRequest generates a request for the DescribePlacementGroups operation.
+func (c *EC2) DescribePlacementGroupsRequest(input *DescribePlacementGroupsInput) (req *aws.Request, output *DescribePlacementGroupsOutput) {
+	op := &aws.Operation{
+		Name:       opDescribePlacementGroups,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribePlacementGroupsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribePlacementGroupsOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your placement groups. For more information about
+// placement groups and cluster instances, see Cluster Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using_cluster_computing.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) DescribePlacementGroups(input *DescribePlacementGroupsInput) (*DescribePlacementGroupsOutput, error) {
+	req, out := c.DescribePlacementGroupsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribePrefixLists = "DescribePrefixLists"
+
+// DescribePrefixListsRequest generates a request for the DescribePrefixLists operation.
+func (c *EC2) DescribePrefixListsRequest(input *DescribePrefixListsInput) (req *aws.Request, output *DescribePrefixListsOutput) {
+	op := &aws.Operation{
+		Name:       opDescribePrefixLists,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribePrefixListsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribePrefixListsOutput{}
+	req.Data = output
+	return
+}
+
+// Describes available AWS services in a prefix list format, which includes
+// the prefix list name and prefix list ID of the service and the IP address
+// range for the service. A prefix list ID is required for creating an outbound
+// security group rule that allows traffic from a VPC to access an AWS service
+// through a VPC endpoint.
+func (c *EC2) DescribePrefixLists(input *DescribePrefixListsInput) (*DescribePrefixListsOutput, error) {
+	req, out := c.DescribePrefixListsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeRegions = "DescribeRegions"
+
+// DescribeRegionsRequest generates a request for the DescribeRegions operation.
+func (c *EC2) DescribeRegionsRequest(input *DescribeRegionsInput) (req *aws.Request, output *DescribeRegionsOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeRegions,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeRegionsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeRegionsOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more regions that are currently available to you.
+//
+// For a list of the regions supported by Amazon EC2, see Regions and Endpoints
+// (http://docs.aws.amazon.com/general/latest/gr/rande.html#ec2_region).
+func (c *EC2) DescribeRegions(input *DescribeRegionsInput) (*DescribeRegionsOutput, error) {
+	req, out := c.DescribeRegionsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeReservedInstances = "DescribeReservedInstances"
+
+// DescribeReservedInstancesRequest generates a request for the DescribeReservedInstances operation.
+func (c *EC2) DescribeReservedInstancesRequest(input *DescribeReservedInstancesInput) (req *aws.Request, output *DescribeReservedInstancesOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeReservedInstances,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeReservedInstancesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeReservedInstancesOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of the Reserved Instances that you purchased.
+//
+// For more information about Reserved Instances, see Reserved Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts-on-demand-reserved-instances.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) DescribeReservedInstances(input *DescribeReservedInstancesInput) (*DescribeReservedInstancesOutput, error) {
+	req, out := c.DescribeReservedInstancesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeReservedInstancesListings = "DescribeReservedInstancesListings"
+
+// DescribeReservedInstancesListingsRequest generates a request for the DescribeReservedInstancesListings operation.
+func (c *EC2) DescribeReservedInstancesListingsRequest(input *DescribeReservedInstancesListingsInput) (req *aws.Request, output *DescribeReservedInstancesListingsOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeReservedInstancesListings,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeReservedInstancesListingsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeReservedInstancesListingsOutput{}
+	req.Data = output
+	return
+}
+
+// Describes your account's Reserved Instance listings in the Reserved Instance
+// Marketplace.
+//
+// The Reserved Instance Marketplace matches sellers who want to resell Reserved
+// Instance capacity that they no longer need with buyers who want to purchase
+// additional capacity. Reserved Instances bought and sold through the Reserved
+// Instance Marketplace work like any other Reserved Instances.
+//
+// As a seller, you choose to list some or all of your Reserved Instances,
+// and you specify the upfront price to receive for them. Your Reserved Instances
+// are then listed in the Reserved Instance Marketplace and are available for
+// purchase.
+//
+// As a buyer, you specify the configuration of the Reserved Instance to purchase,
+// and the Marketplace matches what you're searching for with what's available.
+// The Marketplace first sells the lowest priced Reserved Instances to you,
+// and continues to sell available Reserved Instance listings to you until your
+// demand is met. You are charged based on the total price of all of the listings
+// that you purchase.
+//
+// For more information, see Reserved Instance Marketplace (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) DescribeReservedInstancesListings(input *DescribeReservedInstancesListingsInput) (*DescribeReservedInstancesListingsOutput, error) {
+	req, out := c.DescribeReservedInstancesListingsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeReservedInstancesModifications = "DescribeReservedInstancesModifications"
+
+// DescribeReservedInstancesModificationsRequest generates a request for the DescribeReservedInstancesModifications operation.
+func (c *EC2) DescribeReservedInstancesModificationsRequest(input *DescribeReservedInstancesModificationsInput) (req *aws.Request, output *DescribeReservedInstancesModificationsOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeReservedInstancesModifications,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &aws.Paginator{
+			InputTokens:     []string{"NextToken"},
+			OutputTokens:    []string{"NextToken"},
+			LimitToken:      "",
+			TruncationToken: "",
+		},
+	}
+
+	if input == nil {
+		input = &DescribeReservedInstancesModificationsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeReservedInstancesModificationsOutput{}
+	req.Data = output
+	return
+}
+
+// Describes the modifications made to your Reserved Instances. If no parameter
+// is specified, information about all your Reserved Instances modification
+// requests is returned. If a modification ID is specified, only information
+// about the specific modification is returned.
+//
+// For more information, see Modifying Reserved Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-modifying.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) DescribeReservedInstancesModifications(input *DescribeReservedInstancesModificationsInput) (*DescribeReservedInstancesModificationsOutput, error) {
+	req, out := c.DescribeReservedInstancesModificationsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+func (c *EC2) DescribeReservedInstancesModificationsPages(input *DescribeReservedInstancesModificationsInput, fn func(p *DescribeReservedInstancesModificationsOutput, lastPage bool) (shouldContinue bool)) error {
+	page, _ := c.DescribeReservedInstancesModificationsRequest(input)
+	return page.EachPage(func(p interface{}, lastPage bool) bool {
+		return fn(p.(*DescribeReservedInstancesModificationsOutput), lastPage)
+	})
+}
+
+const opDescribeReservedInstancesOfferings = "DescribeReservedInstancesOfferings"
+
+// DescribeReservedInstancesOfferingsRequest generates a request for the DescribeReservedInstancesOfferings operation.
+func (c *EC2) DescribeReservedInstancesOfferingsRequest(input *DescribeReservedInstancesOfferingsInput) (req *aws.Request, output *DescribeReservedInstancesOfferingsOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeReservedInstancesOfferings,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &aws.Paginator{
+			InputTokens:     []string{"NextToken"},
+			OutputTokens:    []string{"NextToken"},
+			LimitToken:      "MaxResults",
+			TruncationToken: "",
+		},
+	}
+
+	if input == nil {
+		input = &DescribeReservedInstancesOfferingsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeReservedInstancesOfferingsOutput{}
+	req.Data = output
+	return
+}
+
+// Describes Reserved Instance offerings that are available for purchase. With
+// Reserved Instances, you purchase the right to launch instances for a period
+// of time. During that time period, you do not receive insufficient capacity
+// errors, and you pay a lower usage rate than the rate charged for On-Demand
+// instances for the actual time used.
+//
+// For more information, see Reserved Instance Marketplace (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) DescribeReservedInstancesOfferings(input *DescribeReservedInstancesOfferingsInput) (*DescribeReservedInstancesOfferingsOutput, error) {
+	req, out := c.DescribeReservedInstancesOfferingsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+func (c *EC2) DescribeReservedInstancesOfferingsPages(input *DescribeReservedInstancesOfferingsInput, fn func(p *DescribeReservedInstancesOfferingsOutput, lastPage bool) (shouldContinue bool)) error {
+	page, _ := c.DescribeReservedInstancesOfferingsRequest(input)
+	return page.EachPage(func(p interface{}, lastPage bool) bool {
+		return fn(p.(*DescribeReservedInstancesOfferingsOutput), lastPage)
+	})
+}
+
+const opDescribeRouteTables = "DescribeRouteTables"
+
+// DescribeRouteTablesRequest generates a request for the DescribeRouteTables operation.
+func (c *EC2) DescribeRouteTablesRequest(input *DescribeRouteTablesInput) (req *aws.Request, output *DescribeRouteTablesOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeRouteTables,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeRouteTablesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeRouteTablesOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your route tables.
+//
+// Each subnet in your VPC must be associated with a route table. If a subnet
+// is not explicitly associated with any route table, it is implicitly associated
+// with the main route table. This command does not return the subnet ID for
+// implicit associations.
+//
+// For more information about route tables, see Route Tables (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Route_Tables.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) DescribeRouteTables(input *DescribeRouteTablesInput) (*DescribeRouteTablesOutput, error) {
+	req, out := c.DescribeRouteTablesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeSecurityGroups = "DescribeSecurityGroups"
+
+// DescribeSecurityGroupsRequest generates a request for the DescribeSecurityGroups operation.
+func (c *EC2) DescribeSecurityGroupsRequest(input *DescribeSecurityGroupsInput) (req *aws.Request, output *DescribeSecurityGroupsOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeSecurityGroups,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeSecurityGroupsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeSecurityGroupsOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your security groups.
+//
+// A security group is for use with instances either in the EC2-Classic platform
+// or in a specific VPC. For more information, see Amazon EC2 Security Groups
+// (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html)
+// in the Amazon Elastic Compute Cloud User Guide and Security Groups for Your
+// VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_SecurityGroups.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) DescribeSecurityGroups(input *DescribeSecurityGroupsInput) (*DescribeSecurityGroupsOutput, error) {
+	req, out := c.DescribeSecurityGroupsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeSnapshotAttribute = "DescribeSnapshotAttribute"
+
+// DescribeSnapshotAttributeRequest generates a request for the DescribeSnapshotAttribute operation.
+func (c *EC2) DescribeSnapshotAttributeRequest(input *DescribeSnapshotAttributeInput) (req *aws.Request, output *DescribeSnapshotAttributeOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeSnapshotAttribute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeSnapshotAttributeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeSnapshotAttributeOutput{}
+	req.Data = output
+	return
+}
+
+// Describes the specified attribute of the specified snapshot. You can specify
+// only one attribute at a time.
+//
+// For more information about EBS snapshots, see Amazon EBS Snapshots in the
+// Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) DescribeSnapshotAttribute(input *DescribeSnapshotAttributeInput) (*DescribeSnapshotAttributeOutput, error) {
+	req, out := c.DescribeSnapshotAttributeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeSnapshots = "DescribeSnapshots"
+
+// DescribeSnapshotsRequest generates a request for the DescribeSnapshots operation.
+func (c *EC2) DescribeSnapshotsRequest(input *DescribeSnapshotsInput) (req *aws.Request, output *DescribeSnapshotsOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeSnapshots,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &aws.Paginator{
+			InputTokens:     []string{"NextToken"},
+			OutputTokens:    []string{"NextToken"},
+			LimitToken:      "",
+			TruncationToken: "",
+		},
+	}
+
+	if input == nil {
+		input = &DescribeSnapshotsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeSnapshotsOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of the EBS snapshots available to you. Available snapshots
+// include public snapshots available for any AWS account to launch, private
+// snapshots that you own, and private snapshots owned by another AWS account
+// but for which you've been given explicit create volume permissions.
+//
+// The create volume permissions fall into the following categories:
+//
+//   public: The owner of the snapshot granted create volume permissions for
+// the snapshot to the all group. All AWS accounts have create volume permissions
+// for these snapshots.  explicit: The owner of the snapshot granted create
+// volume permissions to a specific AWS account.  implicit: An AWS account has
+// implicit create volume permissions for all snapshots it owns.  The list of
+// snapshots returned can be modified by specifying snapshot IDs, snapshot owners,
+// or AWS accounts with create volume permissions. If no options are specified,
+// Amazon EC2 returns all snapshots for which you have create volume permissions.
+//
+// If you specify one or more snapshot IDs, only snapshots that have the specified
+// IDs are returned. If you specify an invalid snapshot ID, an error is returned.
+// If you specify a snapshot ID for which you do not have access, it is not
+// included in the returned results.
+//
+// If you specify one or more snapshot owners, only snapshots from the specified
+// owners and for which you have access are returned. The results can include
+// the AWS account IDs of the specified owners, amazon for snapshots owned by
+// Amazon, or self for snapshots that you own.
+//
+// If you specify a list of restorable users, only snapshots with create snapshot
+// permissions for those users are returned. You can specify AWS account IDs
+// (if you own the snapshots), self for snapshots for which you own or have
+// explicit permissions, or all for public snapshots.
+//
+// If you are describing a long list of snapshots, you can paginate the output
+// to make the list more manageable. The MaxResults parameter sets the maximum
+// number of results returned in a single page. If the list of results exceeds
+// your MaxResults value, then that number of results is returned along with
+// a NextToken value that can be passed to a subsequent DescribeSnapshots request
+// to retrieve the remaining results.
+//
+// For more information about EBS snapshots, see Amazon EBS Snapshots in the
+// Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) DescribeSnapshots(input *DescribeSnapshotsInput) (*DescribeSnapshotsOutput, error) {
+	req, out := c.DescribeSnapshotsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+func (c *EC2) DescribeSnapshotsPages(input *DescribeSnapshotsInput, fn func(p *DescribeSnapshotsOutput, lastPage bool) (shouldContinue bool)) error {
+	page, _ := c.DescribeSnapshotsRequest(input)
+	return page.EachPage(func(p interface{}, lastPage bool) bool {
+		return fn(p.(*DescribeSnapshotsOutput), lastPage)
+	})
+}
+
+const opDescribeSpotDatafeedSubscription = "DescribeSpotDatafeedSubscription"
+
+// DescribeSpotDatafeedSubscriptionRequest generates a request for the DescribeSpotDatafeedSubscription operation.
+func (c *EC2) DescribeSpotDatafeedSubscriptionRequest(input *DescribeSpotDatafeedSubscriptionInput) (req *aws.Request, output *DescribeSpotDatafeedSubscriptionOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeSpotDatafeedSubscription,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeSpotDatafeedSubscriptionInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeSpotDatafeedSubscriptionOutput{}
+	req.Data = output
+	return
+}
+
+// Describes the data feed for Spot Instances. For more information, see Spot
+// Instance Data Feed (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-data-feeds.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) DescribeSpotDatafeedSubscription(input *DescribeSpotDatafeedSubscriptionInput) (*DescribeSpotDatafeedSubscriptionOutput, error) {
+	req, out := c.DescribeSpotDatafeedSubscriptionRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeSpotFleetInstances = "DescribeSpotFleetInstances"
+
+// DescribeSpotFleetInstancesRequest generates a request for the DescribeSpotFleetInstances operation.
+func (c *EC2) DescribeSpotFleetInstancesRequest(input *DescribeSpotFleetInstancesInput) (req *aws.Request, output *DescribeSpotFleetInstancesOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeSpotFleetInstances,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeSpotFleetInstancesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeSpotFleetInstancesOutput{}
+	req.Data = output
+	return
+}
+
+// Describes the running instances for the specified Spot fleet.
+func (c *EC2) DescribeSpotFleetInstances(input *DescribeSpotFleetInstancesInput) (*DescribeSpotFleetInstancesOutput, error) {
+	req, out := c.DescribeSpotFleetInstancesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeSpotFleetRequestHistory = "DescribeSpotFleetRequestHistory"
+
+// DescribeSpotFleetRequestHistoryRequest generates a request for the DescribeSpotFleetRequestHistory operation.
+func (c *EC2) DescribeSpotFleetRequestHistoryRequest(input *DescribeSpotFleetRequestHistoryInput) (req *aws.Request, output *DescribeSpotFleetRequestHistoryOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeSpotFleetRequestHistory,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeSpotFleetRequestHistoryInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeSpotFleetRequestHistoryOutput{}
+	req.Data = output
+	return
+}
+
+// Describes the events for the specified Spot fleet request during the specified
+// time.
+//
+// Spot fleet events are delayed by up to 30 seconds before they can be described.
+// This ensures that you can query by the last evaluated time and not miss a
+// recorded event.
+func (c *EC2) DescribeSpotFleetRequestHistory(input *DescribeSpotFleetRequestHistoryInput) (*DescribeSpotFleetRequestHistoryOutput, error) {
+	req, out := c.DescribeSpotFleetRequestHistoryRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeSpotFleetRequests = "DescribeSpotFleetRequests"
+
+// DescribeSpotFleetRequestsRequest generates a request for the DescribeSpotFleetRequests operation.
+func (c *EC2) DescribeSpotFleetRequestsRequest(input *DescribeSpotFleetRequestsInput) (req *aws.Request, output *DescribeSpotFleetRequestsOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeSpotFleetRequests,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeSpotFleetRequestsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeSpotFleetRequestsOutput{}
+	req.Data = output
+	return
+}
+
+// Describes your Spot fleet requests.
+func (c *EC2) DescribeSpotFleetRequests(input *DescribeSpotFleetRequestsInput) (*DescribeSpotFleetRequestsOutput, error) {
+	req, out := c.DescribeSpotFleetRequestsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeSpotInstanceRequests = "DescribeSpotInstanceRequests"
+
+// DescribeSpotInstanceRequestsRequest generates a request for the DescribeSpotInstanceRequests operation.
+func (c *EC2) DescribeSpotInstanceRequestsRequest(input *DescribeSpotInstanceRequestsInput) (req *aws.Request, output *DescribeSpotInstanceRequestsOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeSpotInstanceRequests,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeSpotInstanceRequestsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeSpotInstanceRequestsOutput{}
+	req.Data = output
+	return
+}
+
+// Describes the Spot Instance requests that belong to your account. Spot Instances
+// are instances that Amazon EC2 launches when the bid price that you specify
+// exceeds the current Spot Price. Amazon EC2 periodically sets the Spot Price
+// based on available Spot Instance capacity and current Spot Instance requests.
+// For more information, see Spot Instance Requests (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-requests.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+//
+// You can use DescribeSpotInstanceRequests to find a running Spot Instance
+// by examining the response. If the status of the Spot Instance is fulfilled,
+// the instance ID appears in the response and contains the identifier of the
+// instance. Alternatively, you can use DescribeInstances with a filter to look
+// for instances where the instance lifecycle is spot.
+func (c *EC2) DescribeSpotInstanceRequests(input *DescribeSpotInstanceRequestsInput) (*DescribeSpotInstanceRequestsOutput, error) {
+	req, out := c.DescribeSpotInstanceRequestsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeSpotPriceHistory = "DescribeSpotPriceHistory"
+
+// DescribeSpotPriceHistoryRequest generates a request for the DescribeSpotPriceHistory operation.
+func (c *EC2) DescribeSpotPriceHistoryRequest(input *DescribeSpotPriceHistoryInput) (req *aws.Request, output *DescribeSpotPriceHistoryOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeSpotPriceHistory,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &aws.Paginator{
+			InputTokens:     []string{"NextToken"},
+			OutputTokens:    []string{"NextToken"},
+			LimitToken:      "MaxResults",
+			TruncationToken: "",
+		},
+	}
+
+	if input == nil {
+		input = &DescribeSpotPriceHistoryInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeSpotPriceHistoryOutput{}
+	req.Data = output
+	return
+}
+
+// Describes the Spot Price history. The prices returned are listed in chronological
+// order, from the oldest to the most recent, for up to the past 90 days. For
+// more information, see Spot Instance Pricing History (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances-history.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+//
+// When you specify a start and end time, this operation returns the prices
+// of the instance types within the time range that you specified and the time
+// when the price changed. The price is valid within the time period that you
+// specified; the response merely indicates the last time that the price changed.
+func (c *EC2) DescribeSpotPriceHistory(input *DescribeSpotPriceHistoryInput) (*DescribeSpotPriceHistoryOutput, error) {
+	req, out := c.DescribeSpotPriceHistoryRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+func (c *EC2) DescribeSpotPriceHistoryPages(input *DescribeSpotPriceHistoryInput, fn func(p *DescribeSpotPriceHistoryOutput, lastPage bool) (shouldContinue bool)) error {
+	page, _ := c.DescribeSpotPriceHistoryRequest(input)
+	return page.EachPage(func(p interface{}, lastPage bool) bool {
+		return fn(p.(*DescribeSpotPriceHistoryOutput), lastPage)
+	})
+}
+
+const opDescribeSubnets = "DescribeSubnets"
+
+// DescribeSubnetsRequest generates a request for the DescribeSubnets operation.
+func (c *EC2) DescribeSubnetsRequest(input *DescribeSubnetsInput) (req *aws.Request, output *DescribeSubnetsOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeSubnets,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeSubnetsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeSubnetsOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your subnets.
+//
+// For more information about subnets, see Your VPC and Subnets (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Subnets.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) DescribeSubnets(input *DescribeSubnetsInput) (*DescribeSubnetsOutput, error) {
+	req, out := c.DescribeSubnetsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeTags = "DescribeTags"
+
+// DescribeTagsRequest generates a request for the DescribeTags operation.
+func (c *EC2) DescribeTagsRequest(input *DescribeTagsInput) (req *aws.Request, output *DescribeTagsOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeTags,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeTagsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeTagsOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of the tags for your EC2 resources.
+//
+// For more information about tags, see Tagging Your Resources (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) DescribeTags(input *DescribeTagsInput) (*DescribeTagsOutput, error) {
+	req, out := c.DescribeTagsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeVPCAttribute = "DescribeVpcAttribute"
+
+// DescribeVPCAttributeRequest generates a request for the DescribeVPCAttribute operation.
+func (c *EC2) DescribeVPCAttributeRequest(input *DescribeVPCAttributeInput) (req *aws.Request, output *DescribeVPCAttributeOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeVPCAttribute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeVPCAttributeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeVPCAttributeOutput{}
+	req.Data = output
+	return
+}
+
+// Describes the specified attribute of the specified VPC. You can specify only
+// one attribute at a time.
+func (c *EC2) DescribeVPCAttribute(input *DescribeVPCAttributeInput) (*DescribeVPCAttributeOutput, error) {
+	req, out := c.DescribeVPCAttributeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeVPCClassicLink = "DescribeVpcClassicLink"
+
+// DescribeVPCClassicLinkRequest generates a request for the DescribeVPCClassicLink operation.
+func (c *EC2) DescribeVPCClassicLinkRequest(input *DescribeVPCClassicLinkInput) (req *aws.Request, output *DescribeVPCClassicLinkOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeVPCClassicLink,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeVPCClassicLinkInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeVPCClassicLinkOutput{}
+	req.Data = output
+	return
+}
+
+// Describes the ClassicLink status of one or more VPCs.
+func (c *EC2) DescribeVPCClassicLink(input *DescribeVPCClassicLinkInput) (*DescribeVPCClassicLinkOutput, error) {
+	req, out := c.DescribeVPCClassicLinkRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeVPCEndpointServices = "DescribeVpcEndpointServices"
+
+// DescribeVPCEndpointServicesRequest generates a request for the DescribeVPCEndpointServices operation.
+func (c *EC2) DescribeVPCEndpointServicesRequest(input *DescribeVPCEndpointServicesInput) (req *aws.Request, output *DescribeVPCEndpointServicesOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeVPCEndpointServices,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeVPCEndpointServicesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeVPCEndpointServicesOutput{}
+	req.Data = output
+	return
+}
+
+// Describes all supported AWS services that can be specified when creating
+// a VPC endpoint.
+func (c *EC2) DescribeVPCEndpointServices(input *DescribeVPCEndpointServicesInput) (*DescribeVPCEndpointServicesOutput, error) {
+	req, out := c.DescribeVPCEndpointServicesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeVPCEndpoints = "DescribeVpcEndpoints"
+
+// DescribeVPCEndpointsRequest generates a request for the DescribeVPCEndpoints operation.
+func (c *EC2) DescribeVPCEndpointsRequest(input *DescribeVPCEndpointsInput) (req *aws.Request, output *DescribeVPCEndpointsOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeVPCEndpoints,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeVPCEndpointsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeVPCEndpointsOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your VPC endpoints.
+func (c *EC2) DescribeVPCEndpoints(input *DescribeVPCEndpointsInput) (*DescribeVPCEndpointsOutput, error) {
+	req, out := c.DescribeVPCEndpointsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeVPCPeeringConnections = "DescribeVpcPeeringConnections"
+
+// DescribeVPCPeeringConnectionsRequest generates a request for the DescribeVPCPeeringConnections operation.
+func (c *EC2) DescribeVPCPeeringConnectionsRequest(input *DescribeVPCPeeringConnectionsInput) (req *aws.Request, output *DescribeVPCPeeringConnectionsOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeVPCPeeringConnections,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeVPCPeeringConnectionsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeVPCPeeringConnectionsOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your VPC peering connections.
+func (c *EC2) DescribeVPCPeeringConnections(input *DescribeVPCPeeringConnectionsInput) (*DescribeVPCPeeringConnectionsOutput, error) {
+	req, out := c.DescribeVPCPeeringConnectionsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeVPCs = "DescribeVpcs"
+
+// DescribeVPCsRequest generates a request for the DescribeVPCs operation.
+func (c *EC2) DescribeVPCsRequest(input *DescribeVPCsInput) (req *aws.Request, output *DescribeVPCsOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeVPCs,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeVPCsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeVPCsOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your VPCs.
+func (c *EC2) DescribeVPCs(input *DescribeVPCsInput) (*DescribeVPCsOutput, error) {
+	req, out := c.DescribeVPCsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeVPNConnections = "DescribeVpnConnections"
+
+// DescribeVPNConnectionsRequest generates a request for the DescribeVPNConnections operation.
+func (c *EC2) DescribeVPNConnectionsRequest(input *DescribeVPNConnectionsInput) (req *aws.Request, output *DescribeVPNConnectionsOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeVPNConnections,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeVPNConnectionsInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeVPNConnectionsOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your VPN connections.
+//
+// For more information about VPN connections, see Adding a Hardware Virtual
+// Private Gateway to Your VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_VPN.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) DescribeVPNConnections(input *DescribeVPNConnectionsInput) (*DescribeVPNConnectionsOutput, error) {
+	req, out := c.DescribeVPNConnectionsRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeVPNGateways = "DescribeVpnGateways"
+
+// DescribeVPNGatewaysRequest generates a request for the DescribeVPNGateways operation.
+func (c *EC2) DescribeVPNGatewaysRequest(input *DescribeVPNGatewaysInput) (req *aws.Request, output *DescribeVPNGatewaysOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeVPNGateways,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeVPNGatewaysInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeVPNGatewaysOutput{}
+	req.Data = output
+	return
+}
+
+// Describes one or more of your virtual private gateways.
+//
+// For more information about virtual private gateways, see Adding an IPsec
+// Hardware VPN to Your VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_VPN.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) DescribeVPNGateways(input *DescribeVPNGatewaysInput) (*DescribeVPNGatewaysOutput, error) {
+	req, out := c.DescribeVPNGatewaysRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeVolumeAttribute = "DescribeVolumeAttribute"
+
+// DescribeVolumeAttributeRequest generates a request for the DescribeVolumeAttribute operation.
+func (c *EC2) DescribeVolumeAttributeRequest(input *DescribeVolumeAttributeInput) (req *aws.Request, output *DescribeVolumeAttributeOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeVolumeAttribute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DescribeVolumeAttributeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeVolumeAttributeOutput{}
+	req.Data = output
+	return
+}
+
+// Describes the specified attribute of the specified volume. You can specify
+// only one attribute at a time.
+//
+// For more information about EBS volumes, see Amazon EBS Volumes in the Amazon
+// Elastic Compute Cloud User Guide.
+func (c *EC2) DescribeVolumeAttribute(input *DescribeVolumeAttributeInput) (*DescribeVolumeAttributeOutput, error) {
+	req, out := c.DescribeVolumeAttributeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDescribeVolumeStatus = "DescribeVolumeStatus"
+
+// DescribeVolumeStatusRequest generates a request for the DescribeVolumeStatus operation.
+func (c *EC2) DescribeVolumeStatusRequest(input *DescribeVolumeStatusInput) (req *aws.Request, output *DescribeVolumeStatusOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeVolumeStatus,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &aws.Paginator{
+			InputTokens:     []string{"NextToken"},
+			OutputTokens:    []string{"NextToken"},
+			LimitToken:      "MaxResults",
+			TruncationToken: "",
+		},
+	}
+
+	if input == nil {
+		input = &DescribeVolumeStatusInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeVolumeStatusOutput{}
+	req.Data = output
+	return
+}
+
+// Describes the status of the specified volumes. Volume status provides the
+// result of the checks performed on your volumes to determine events that can
+// impair the performance of your volumes. The performance of a volume can be
+// affected if an issue occurs on the volume's underlying host. If the volume's
+// underlying host experiences a power outage or system issue, after the system
+// is restored, there could be data inconsistencies on the volume. Volume events
+// notify you if this occurs. Volume actions notify you if any action needs
+// to be taken in response to the event.
+//
+// The DescribeVolumeStatus operation provides the following information about
+// the specified volumes:
+//
+// Status: Reflects the current status of the volume. The possible values are
+// ok, impaired , warning, or insufficient-data. If all checks pass, the overall
+// status of the volume is ok. If the check fails, the overall status is impaired.
+// If the status is insufficient-data, then the checks may still be taking place
+// on your volume at the time. We recommend that you retry the request. For
+// more information on volume status, see Monitoring the Status of Your Volumes
+// (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-volume-status.html).
+//
+// Events: Reflect the cause of a volume status and may require you to take
+// action. For example, if your volume returns an impaired status, then the
+// volume event might be potential-data-inconsistency. This means that your
+// volume has been affected by an issue with the underlying host, has all I/O
+// operations disabled, and may have inconsistent data.
+//
+// Actions: Reflect the actions you may have to take in response to an event.
+// For example, if the status of the volume is impaired and the volume event
+// shows potential-data-inconsistency, then the action shows enable-volume-io.
+// This means that you may want to enable the I/O operations for the volume
+// by calling the EnableVolumeIO action and then check the volume for data consistency.
+//
+//  Volume status is based on the volume status checks, and does not reflect
+// the volume state. Therefore, volume status does not indicate volumes in the
+// error state (for example, when a volume is incapable of accepting I/O.)
+func (c *EC2) DescribeVolumeStatus(input *DescribeVolumeStatusInput) (*DescribeVolumeStatusOutput, error) {
+	req, out := c.DescribeVolumeStatusRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+func (c *EC2) DescribeVolumeStatusPages(input *DescribeVolumeStatusInput, fn func(p *DescribeVolumeStatusOutput, lastPage bool) (shouldContinue bool)) error {
+	page, _ := c.DescribeVolumeStatusRequest(input)
+	return page.EachPage(func(p interface{}, lastPage bool) bool {
+		return fn(p.(*DescribeVolumeStatusOutput), lastPage)
+	})
+}
+
+const opDescribeVolumes = "DescribeVolumes"
+
+// DescribeVolumesRequest generates a request for the DescribeVolumes operation.
+func (c *EC2) DescribeVolumesRequest(input *DescribeVolumesInput) (req *aws.Request, output *DescribeVolumesOutput) {
+	op := &aws.Operation{
+		Name:       opDescribeVolumes,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &aws.Paginator{
+			InputTokens:     []string{"NextToken"},
+			OutputTokens:    []string{"NextToken"},
+			LimitToken:      "MaxResults",
+			TruncationToken: "",
+		},
+	}
+
+	if input == nil {
+		input = &DescribeVolumesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DescribeVolumesOutput{}
+	req.Data = output
+	return
+}
+
+// Describes the specified EBS volumes.
+//
+// If you are describing a long list of volumes, you can paginate the output
+// to make the list more manageable. The MaxResults parameter sets the maximum
+// number of results returned in a single page. If the list of results exceeds
+// your MaxResults value, then that number of results is returned along with
+// a NextToken value that can be passed to a subsequent DescribeVolumes request
+// to retrieve the remaining results.
+//
+// For more information about EBS volumes, see Amazon EBS Volumes in the Amazon
+// Elastic Compute Cloud User Guide.
+func (c *EC2) DescribeVolumes(input *DescribeVolumesInput) (*DescribeVolumesOutput, error) {
+	req, out := c.DescribeVolumesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+func (c *EC2) DescribeVolumesPages(input *DescribeVolumesInput, fn func(p *DescribeVolumesOutput, lastPage bool) (shouldContinue bool)) error {
+	page, _ := c.DescribeVolumesRequest(input)
+	return page.EachPage(func(p interface{}, lastPage bool) bool {
+		return fn(p.(*DescribeVolumesOutput), lastPage)
+	})
+}
+
+const opDetachClassicLinkVPC = "DetachClassicLinkVpc"
+
+// DetachClassicLinkVPCRequest generates a request for the DetachClassicLinkVPC operation.
+func (c *EC2) DetachClassicLinkVPCRequest(input *DetachClassicLinkVPCInput) (req *aws.Request, output *DetachClassicLinkVPCOutput) {
+	op := &aws.Operation{
+		Name:       opDetachClassicLinkVPC,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DetachClassicLinkVPCInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DetachClassicLinkVPCOutput{}
+	req.Data = output
+	return
+}
+
+// Unlinks (detaches) a linked EC2-Classic instance from a VPC. After the instance
+// has been unlinked, the VPC security groups are no longer associated with
+// it. An instance is automatically unlinked from a VPC when it's stopped.
+func (c *EC2) DetachClassicLinkVPC(input *DetachClassicLinkVPCInput) (*DetachClassicLinkVPCOutput, error) {
+	req, out := c.DetachClassicLinkVPCRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDetachInternetGateway = "DetachInternetGateway"
+
+// DetachInternetGatewayRequest generates a request for the DetachInternetGateway operation.
+func (c *EC2) DetachInternetGatewayRequest(input *DetachInternetGatewayInput) (req *aws.Request, output *DetachInternetGatewayOutput) {
+	op := &aws.Operation{
+		Name:       opDetachInternetGateway,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DetachInternetGatewayInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DetachInternetGatewayOutput{}
+	req.Data = output
+	return
+}
+
+// Detaches an Internet gateway from a VPC, disabling connectivity between the
+// Internet and the VPC. The VPC must not contain any running instances with
+// Elastic IP addresses.
+func (c *EC2) DetachInternetGateway(input *DetachInternetGatewayInput) (*DetachInternetGatewayOutput, error) {
+	req, out := c.DetachInternetGatewayRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDetachNetworkInterface = "DetachNetworkInterface"
+
+// DetachNetworkInterfaceRequest generates a request for the DetachNetworkInterface operation.
+func (c *EC2) DetachNetworkInterfaceRequest(input *DetachNetworkInterfaceInput) (req *aws.Request, output *DetachNetworkInterfaceOutput) {
+	op := &aws.Operation{
+		Name:       opDetachNetworkInterface,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DetachNetworkInterfaceInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DetachNetworkInterfaceOutput{}
+	req.Data = output
+	return
+}
+
+// Detaches a network interface from an instance.
+func (c *EC2) DetachNetworkInterface(input *DetachNetworkInterfaceInput) (*DetachNetworkInterfaceOutput, error) {
+	req, out := c.DetachNetworkInterfaceRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDetachVPNGateway = "DetachVpnGateway"
+
+// DetachVPNGatewayRequest generates a request for the DetachVPNGateway operation.
+func (c *EC2) DetachVPNGatewayRequest(input *DetachVPNGatewayInput) (req *aws.Request, output *DetachVPNGatewayOutput) {
+	op := &aws.Operation{
+		Name:       opDetachVPNGateway,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DetachVPNGatewayInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DetachVPNGatewayOutput{}
+	req.Data = output
+	return
+}
+
+// Detaches a virtual private gateway from a VPC. You do this if you're planning
+// to turn off the VPC and not use it anymore. You can confirm a virtual private
+// gateway has been completely detached from a VPC by describing the virtual
+// private gateway (any attachments to the virtual private gateway are also
+// described).
+//
+// You must wait for the attachment's state to switch to detached before you
+// can delete the VPC or attach a different VPC to the virtual private gateway.
+func (c *EC2) DetachVPNGateway(input *DetachVPNGatewayInput) (*DetachVPNGatewayOutput, error) {
+	req, out := c.DetachVPNGatewayRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDetachVolume = "DetachVolume"
+
+// DetachVolumeRequest generates a request for the DetachVolume operation.
+func (c *EC2) DetachVolumeRequest(input *DetachVolumeInput) (req *aws.Request, output *VolumeAttachment) {
+	op := &aws.Operation{
+		Name:       opDetachVolume,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DetachVolumeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &VolumeAttachment{}
+	req.Data = output
+	return
+}
+
+// Detaches an EBS volume from an instance. Make sure to unmount any file systems
+// on the device within your operating system before detaching the volume. Failure
+// to do so results in the volume being stuck in a busy state while detaching.
+//
+// If an Amazon EBS volume is the root device of an instance, it can't be detached
+// while the instance is running. To detach the root volume, stop the instance
+// first.
+//
+// When a volume with an AWS Marketplace product code is detached from an instance,
+// the product code is no longer associated with the instance.
+//
+// For more information, see Detaching an Amazon EBS Volume (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-detaching-volume.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) DetachVolume(input *DetachVolumeInput) (*VolumeAttachment, error) {
+	req, out := c.DetachVolumeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDisableVGWRoutePropagation = "DisableVgwRoutePropagation"
+
+// DisableVGWRoutePropagationRequest generates a request for the DisableVGWRoutePropagation operation.
+func (c *EC2) DisableVGWRoutePropagationRequest(input *DisableVGWRoutePropagationInput) (req *aws.Request, output *DisableVGWRoutePropagationOutput) {
+	op := &aws.Operation{
+		Name:       opDisableVGWRoutePropagation,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DisableVGWRoutePropagationInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DisableVGWRoutePropagationOutput{}
+	req.Data = output
+	return
+}
+
+// Disables a virtual private gateway (VGW) from propagating routes to a specified
+// route table of a VPC.
+func (c *EC2) DisableVGWRoutePropagation(input *DisableVGWRoutePropagationInput) (*DisableVGWRoutePropagationOutput, error) {
+	req, out := c.DisableVGWRoutePropagationRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDisableVPCClassicLink = "DisableVpcClassicLink"
+
+// DisableVPCClassicLinkRequest generates a request for the DisableVPCClassicLink operation.
+func (c *EC2) DisableVPCClassicLinkRequest(input *DisableVPCClassicLinkInput) (req *aws.Request, output *DisableVPCClassicLinkOutput) {
+	op := &aws.Operation{
+		Name:       opDisableVPCClassicLink,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DisableVPCClassicLinkInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DisableVPCClassicLinkOutput{}
+	req.Data = output
+	return
+}
+
+// Disables ClassicLink for a VPC. You cannot disable ClassicLink for a VPC
+// that has EC2-Classic instances linked to it.
+func (c *EC2) DisableVPCClassicLink(input *DisableVPCClassicLinkInput) (*DisableVPCClassicLinkOutput, error) {
+	req, out := c.DisableVPCClassicLinkRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDisassociateAddress = "DisassociateAddress"
+
+// DisassociateAddressRequest generates a request for the DisassociateAddress operation.
+func (c *EC2) DisassociateAddressRequest(input *DisassociateAddressInput) (req *aws.Request, output *DisassociateAddressOutput) {
+	op := &aws.Operation{
+		Name:       opDisassociateAddress,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DisassociateAddressInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DisassociateAddressOutput{}
+	req.Data = output
+	return
+}
+
+// Disassociates an Elastic IP address from the instance or network interface
+// it's associated with.
+//
+// An Elastic IP address is for use in either the EC2-Classic platform or in
+// a VPC. For more information, see Elastic IP Addresses (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+//
+// This is an idempotent operation. If you perform the operation more than
+// once, Amazon EC2 doesn't return an error.
+func (c *EC2) DisassociateAddress(input *DisassociateAddressInput) (*DisassociateAddressOutput, error) {
+	req, out := c.DisassociateAddressRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opDisassociateRouteTable = "DisassociateRouteTable"
+
+// DisassociateRouteTableRequest generates a request for the DisassociateRouteTable operation.
+func (c *EC2) DisassociateRouteTableRequest(input *DisassociateRouteTableInput) (req *aws.Request, output *DisassociateRouteTableOutput) {
+	op := &aws.Operation{
+		Name:       opDisassociateRouteTable,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DisassociateRouteTableInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &DisassociateRouteTableOutput{}
+	req.Data = output
+	return
+}
+
+// Disassociates a subnet from a route table.
+//
+// After you perform this action, the subnet no longer uses the routes in the
+// route table. Instead, it uses the routes in the VPC's main route table. For
+// more information about route tables, see Route Tables (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Route_Tables.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) DisassociateRouteTable(input *DisassociateRouteTableInput) (*DisassociateRouteTableOutput, error) {
+	req, out := c.DisassociateRouteTableRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opEnableVGWRoutePropagation = "EnableVgwRoutePropagation"
+
+// EnableVGWRoutePropagationRequest generates a request for the EnableVGWRoutePropagation operation.
+func (c *EC2) EnableVGWRoutePropagationRequest(input *EnableVGWRoutePropagationInput) (req *aws.Request, output *EnableVGWRoutePropagationOutput) {
+	op := &aws.Operation{
+		Name:       opEnableVGWRoutePropagation,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &EnableVGWRoutePropagationInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &EnableVGWRoutePropagationOutput{}
+	req.Data = output
+	return
+}
+
+// Enables a virtual private gateway (VGW) to propagate routes to the specified
+// route table of a VPC.
+func (c *EC2) EnableVGWRoutePropagation(input *EnableVGWRoutePropagationInput) (*EnableVGWRoutePropagationOutput, error) {
+	req, out := c.EnableVGWRoutePropagationRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opEnableVPCClassicLink = "EnableVpcClassicLink"
+
+// EnableVPCClassicLinkRequest generates a request for the EnableVPCClassicLink operation.
+func (c *EC2) EnableVPCClassicLinkRequest(input *EnableVPCClassicLinkInput) (req *aws.Request, output *EnableVPCClassicLinkOutput) {
+	op := &aws.Operation{
+		Name:       opEnableVPCClassicLink,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &EnableVPCClassicLinkInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &EnableVPCClassicLinkOutput{}
+	req.Data = output
+	return
+}
+
+// Enables a VPC for ClassicLink. You can then link EC2-Classic instances to
+// your ClassicLink-enabled VPC to allow communication over private IP addresses.
+// You cannot enable your VPC for ClassicLink if any of your VPC's route tables
+// have existing routes for address ranges within the 10.0.0.0/8 IP address
+// range, excluding local routes for VPCs in the 10.0.0.0/16 and 10.1.0.0/16
+// IP address ranges. For more information, see ClassicLink (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/vpc-classiclink.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) EnableVPCClassicLink(input *EnableVPCClassicLinkInput) (*EnableVPCClassicLinkOutput, error) {
+	req, out := c.EnableVPCClassicLinkRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opEnableVolumeIO = "EnableVolumeIO"
+
+// EnableVolumeIORequest generates a request for the EnableVolumeIO operation.
+func (c *EC2) EnableVolumeIORequest(input *EnableVolumeIOInput) (req *aws.Request, output *EnableVolumeIOOutput) {
+	op := &aws.Operation{
+		Name:       opEnableVolumeIO,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &EnableVolumeIOInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &EnableVolumeIOOutput{}
+	req.Data = output
+	return
+}
+
+// Enables I/O operations for a volume that had I/O operations disabled because
+// the data on the volume was potentially inconsistent.
+func (c *EC2) EnableVolumeIO(input *EnableVolumeIOInput) (*EnableVolumeIOOutput, error) {
+	req, out := c.EnableVolumeIORequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opGetConsoleOutput = "GetConsoleOutput"
+
+// GetConsoleOutputRequest generates a request for the GetConsoleOutput operation.
+func (c *EC2) GetConsoleOutputRequest(input *GetConsoleOutputInput) (req *aws.Request, output *GetConsoleOutputOutput) {
+	op := &aws.Operation{
+		Name:       opGetConsoleOutput,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetConsoleOutputInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &GetConsoleOutputOutput{}
+	req.Data = output
+	return
+}
+
+// Gets the console output for the specified instance.
+//
+// Instances do not have a physical monitor through which you can view their
+// console output. They also lack physical controls that allow you to power
+// up, reboot, or shut them down. To allow these actions, we provide them through
+// the Amazon EC2 API and command line interface.
+//
+// Instance console output is buffered and posted shortly after instance boot,
+// reboot, and termination. Amazon EC2 preserves the most recent 64 KB output
+// which is available for at least one hour after the most recent post.
+//
+// For Linux instances, the instance console output displays the exact console
+// output that would normally be displayed on a physical monitor attached to
+// a computer. This output is buffered because the instance produces it and
+// then posts it to a store where the instance's owner can retrieve it.
+//
+// For Windows instances, the instance console output includes output from
+// the EC2Config service.
+func (c *EC2) GetConsoleOutput(input *GetConsoleOutputInput) (*GetConsoleOutputOutput, error) {
+	req, out := c.GetConsoleOutputRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opGetPasswordData = "GetPasswordData"
+
+// GetPasswordDataRequest generates a request for the GetPasswordData operation.
+func (c *EC2) GetPasswordDataRequest(input *GetPasswordDataInput) (req *aws.Request, output *GetPasswordDataOutput) {
+	op := &aws.Operation{
+		Name:       opGetPasswordData,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetPasswordDataInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &GetPasswordDataOutput{}
+	req.Data = output
+	return
+}
+
+// Retrieves the encrypted administrator password for an instance running Windows.
+//
+// The Windows password is generated at boot if the EC2Config service plugin,
+// Ec2SetPassword, is enabled. This usually only happens the first time an AMI
+// is launched, and then Ec2SetPassword is automatically disabled. The password
+// is not generated for rebundled AMIs unless Ec2SetPassword is enabled before
+// bundling.
+//
+// The password is encrypted using the key pair that you specified when you
+// launched the instance. You must provide the corresponding key pair file.
+//
+// Password generation and encryption takes a few moments. We recommend that
+// you wait up to 15 minutes after launching an instance before trying to retrieve
+// the generated password.
+func (c *EC2) GetPasswordData(input *GetPasswordDataInput) (*GetPasswordDataOutput, error) {
+	req, out := c.GetPasswordDataRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opImportImage = "ImportImage"
+
+// ImportImageRequest generates a request for the ImportImage operation.
+func (c *EC2) ImportImageRequest(input *ImportImageInput) (req *aws.Request, output *ImportImageOutput) {
+	op := &aws.Operation{
+		Name:       opImportImage,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ImportImageInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ImportImageOutput{}
+	req.Data = output
+	return
+}
+
+// Import single or multi-volume disk images or EBS snapshots into an Amazon
+// Machine Image (AMI).
+func (c *EC2) ImportImage(input *ImportImageInput) (*ImportImageOutput, error) {
+	req, out := c.ImportImageRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opImportInstance = "ImportInstance"
+
+// ImportInstanceRequest generates a request for the ImportInstance operation.
+func (c *EC2) ImportInstanceRequest(input *ImportInstanceInput) (req *aws.Request, output *ImportInstanceOutput) {
+	op := &aws.Operation{
+		Name:       opImportInstance,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ImportInstanceInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ImportInstanceOutput{}
+	req.Data = output
+	return
+}
+
+// Creates an import instance task using metadata from the specified disk image.
+// ImportInstance only supports single-volume VMs. To import multi-volume VMs,
+// use ImportImage. After importing the image, you then upload it using the
+// ec2-import-volume command in the EC2 command line tools. For more information,
+// see Using the Command Line Tools to Import Your Virtual Machine to Amazon
+// EC2 (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UploadingYourInstancesandVolumes.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) ImportInstance(input *ImportInstanceInput) (*ImportInstanceOutput, error) {
+	req, out := c.ImportInstanceRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opImportKeyPair = "ImportKeyPair"
+
+// ImportKeyPairRequest generates a request for the ImportKeyPair operation.
+func (c *EC2) ImportKeyPairRequest(input *ImportKeyPairInput) (req *aws.Request, output *ImportKeyPairOutput) {
+	op := &aws.Operation{
+		Name:       opImportKeyPair,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ImportKeyPairInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ImportKeyPairOutput{}
+	req.Data = output
+	return
+}
+
+// Imports the public key from an RSA key pair that you created with a third-party
+// tool. Compare this with CreateKeyPair, in which AWS creates the key pair
+// and gives the keys to you (AWS keeps a copy of the public key). With ImportKeyPair,
+// you create the key pair and give AWS just the public key. The private key
+// is never transferred between you and AWS.
+//
+// For more information about key pairs, see Key Pairs (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) ImportKeyPair(input *ImportKeyPairInput) (*ImportKeyPairOutput, error) {
+	req, out := c.ImportKeyPairRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opImportSnapshot = "ImportSnapshot"
+
+// ImportSnapshotRequest generates a request for the ImportSnapshot operation.
+func (c *EC2) ImportSnapshotRequest(input *ImportSnapshotInput) (req *aws.Request, output *ImportSnapshotOutput) {
+	op := &aws.Operation{
+		Name:       opImportSnapshot,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ImportSnapshotInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ImportSnapshotOutput{}
+	req.Data = output
+	return
+}
+
+// Imports a disk into an EBS snapshot.
+func (c *EC2) ImportSnapshot(input *ImportSnapshotInput) (*ImportSnapshotOutput, error) {
+	req, out := c.ImportSnapshotRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opImportVolume = "ImportVolume"
+
+// ImportVolumeRequest generates a request for the ImportVolume operation.
+func (c *EC2) ImportVolumeRequest(input *ImportVolumeInput) (req *aws.Request, output *ImportVolumeOutput) {
+	op := &aws.Operation{
+		Name:       opImportVolume,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ImportVolumeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ImportVolumeOutput{}
+	req.Data = output
+	return
+}
+
+// Creates an import volume task using metadata from the specified disk image.
+// After importing the image, you then upload it using the ec2-import-volume
+// command in the Amazon EC2 command-line interface (CLI) tools. For more information,
+// see Using the Command Line Tools to Import Your Virtual Machine to Amazon
+// EC2 (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UploadingYourInstancesandVolumes.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) ImportVolume(input *ImportVolumeInput) (*ImportVolumeOutput, error) {
+	req, out := c.ImportVolumeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opModifyImageAttribute = "ModifyImageAttribute"
+
+// ModifyImageAttributeRequest generates a request for the ModifyImageAttribute operation.
+func (c *EC2) ModifyImageAttributeRequest(input *ModifyImageAttributeInput) (req *aws.Request, output *ModifyImageAttributeOutput) {
+	op := &aws.Operation{
+		Name:       opModifyImageAttribute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ModifyImageAttributeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ModifyImageAttributeOutput{}
+	req.Data = output
+	return
+}
+
+// Modifies the specified attribute of the specified AMI. You can specify only
+// one attribute at a time.
+//
+// AWS Marketplace product codes cannot be modified. Images with an AWS Marketplace
+// product code cannot be made public.
+func (c *EC2) ModifyImageAttribute(input *ModifyImageAttributeInput) (*ModifyImageAttributeOutput, error) {
+	req, out := c.ModifyImageAttributeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opModifyInstanceAttribute = "ModifyInstanceAttribute"
+
+// ModifyInstanceAttributeRequest generates a request for the ModifyInstanceAttribute operation.
+func (c *EC2) ModifyInstanceAttributeRequest(input *ModifyInstanceAttributeInput) (req *aws.Request, output *ModifyInstanceAttributeOutput) {
+	op := &aws.Operation{
+		Name:       opModifyInstanceAttribute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ModifyInstanceAttributeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ModifyInstanceAttributeOutput{}
+	req.Data = output
+	return
+}
+
+// Modifies the specified attribute of the specified instance. You can specify
+// only one attribute at a time.
+//
+// To modify some attributes, the instance must be stopped. For more information,
+// see Modifying Attributes of a Stopped Instance (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_ChangingAttributesWhileInstanceStopped.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) ModifyInstanceAttribute(input *ModifyInstanceAttributeInput) (*ModifyInstanceAttributeOutput, error) {
+	req, out := c.ModifyInstanceAttributeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opModifyNetworkInterfaceAttribute = "ModifyNetworkInterfaceAttribute"
+
+// ModifyNetworkInterfaceAttributeRequest generates a request for the ModifyNetworkInterfaceAttribute operation.
+func (c *EC2) ModifyNetworkInterfaceAttributeRequest(input *ModifyNetworkInterfaceAttributeInput) (req *aws.Request, output *ModifyNetworkInterfaceAttributeOutput) {
+	op := &aws.Operation{
+		Name:       opModifyNetworkInterfaceAttribute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ModifyNetworkInterfaceAttributeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ModifyNetworkInterfaceAttributeOutput{}
+	req.Data = output
+	return
+}
+
+// Modifies the specified network interface attribute. You can specify only
+// one attribute at a time.
+func (c *EC2) ModifyNetworkInterfaceAttribute(input *ModifyNetworkInterfaceAttributeInput) (*ModifyNetworkInterfaceAttributeOutput, error) {
+	req, out := c.ModifyNetworkInterfaceAttributeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opModifyReservedInstances = "ModifyReservedInstances"
+
+// ModifyReservedInstancesRequest generates a request for the ModifyReservedInstances operation.
+func (c *EC2) ModifyReservedInstancesRequest(input *ModifyReservedInstancesInput) (req *aws.Request, output *ModifyReservedInstancesOutput) {
+	op := &aws.Operation{
+		Name:       opModifyReservedInstances,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ModifyReservedInstancesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ModifyReservedInstancesOutput{}
+	req.Data = output
+	return
+}
+
+// Modifies the Availability Zone, instance count, instance type, or network
+// platform (EC2-Classic or EC2-VPC) of your Reserved Instances. The Reserved
+// Instances to be modified must be identical, except for Availability Zone,
+// network platform, and instance type.
+//
+// For more information, see Modifying Reserved Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-modifying.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) ModifyReservedInstances(input *ModifyReservedInstancesInput) (*ModifyReservedInstancesOutput, error) {
+	req, out := c.ModifyReservedInstancesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opModifySnapshotAttribute = "ModifySnapshotAttribute"
+
+// ModifySnapshotAttributeRequest generates a request for the ModifySnapshotAttribute operation.
+func (c *EC2) ModifySnapshotAttributeRequest(input *ModifySnapshotAttributeInput) (req *aws.Request, output *ModifySnapshotAttributeOutput) {
+	op := &aws.Operation{
+		Name:       opModifySnapshotAttribute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ModifySnapshotAttributeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ModifySnapshotAttributeOutput{}
+	req.Data = output
+	return
+}
+
+// Adds or removes permission settings for the specified snapshot. You may add
+// or remove specified AWS account IDs from a snapshot's list of create volume
+// permissions, but you cannot do both in a single API call. If you need to
+// both add and remove account IDs for a snapshot, you must use multiple API
+// calls.
+//
+// For more information on modifying snapshot permissions, see Sharing Snapshots
+// (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-modifying-snapshot-permissions.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+//
+//  Snapshots with AWS Marketplace product codes cannot be made public.
+func (c *EC2) ModifySnapshotAttribute(input *ModifySnapshotAttributeInput) (*ModifySnapshotAttributeOutput, error) {
+	req, out := c.ModifySnapshotAttributeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opModifySubnetAttribute = "ModifySubnetAttribute"
+
+// ModifySubnetAttributeRequest generates a request for the ModifySubnetAttribute operation.
+func (c *EC2) ModifySubnetAttributeRequest(input *ModifySubnetAttributeInput) (req *aws.Request, output *ModifySubnetAttributeOutput) {
+	op := &aws.Operation{
+		Name:       opModifySubnetAttribute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ModifySubnetAttributeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ModifySubnetAttributeOutput{}
+	req.Data = output
+	return
+}
+
+// Modifies a subnet attribute.
+func (c *EC2) ModifySubnetAttribute(input *ModifySubnetAttributeInput) (*ModifySubnetAttributeOutput, error) {
+	req, out := c.ModifySubnetAttributeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opModifyVPCAttribute = "ModifyVpcAttribute"
+
+// ModifyVPCAttributeRequest generates a request for the ModifyVPCAttribute operation.
+func (c *EC2) ModifyVPCAttributeRequest(input *ModifyVPCAttributeInput) (req *aws.Request, output *ModifyVPCAttributeOutput) {
+	op := &aws.Operation{
+		Name:       opModifyVPCAttribute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ModifyVPCAttributeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ModifyVPCAttributeOutput{}
+	req.Data = output
+	return
+}
+
+// Modifies the specified attribute of the specified VPC.
+func (c *EC2) ModifyVPCAttribute(input *ModifyVPCAttributeInput) (*ModifyVPCAttributeOutput, error) {
+	req, out := c.ModifyVPCAttributeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opModifyVPCEndpoint = "ModifyVpcEndpoint"
+
+// ModifyVPCEndpointRequest generates a request for the ModifyVPCEndpoint operation.
+func (c *EC2) ModifyVPCEndpointRequest(input *ModifyVPCEndpointInput) (req *aws.Request, output *ModifyVPCEndpointOutput) {
+	op := &aws.Operation{
+		Name:       opModifyVPCEndpoint,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ModifyVPCEndpointInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ModifyVPCEndpointOutput{}
+	req.Data = output
+	return
+}
+
+// Modifies attributes of a specified VPC endpoint. You can modify the policy
+// associated with the endpoint, and you can add and remove route tables associated
+// with the endpoint.
+func (c *EC2) ModifyVPCEndpoint(input *ModifyVPCEndpointInput) (*ModifyVPCEndpointOutput, error) {
+	req, out := c.ModifyVPCEndpointRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opModifyVolumeAttribute = "ModifyVolumeAttribute"
+
+// ModifyVolumeAttributeRequest generates a request for the ModifyVolumeAttribute operation.
+func (c *EC2) ModifyVolumeAttributeRequest(input *ModifyVolumeAttributeInput) (req *aws.Request, output *ModifyVolumeAttributeOutput) {
+	op := &aws.Operation{
+		Name:       opModifyVolumeAttribute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ModifyVolumeAttributeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ModifyVolumeAttributeOutput{}
+	req.Data = output
+	return
+}
+
+// Modifies a volume attribute.
+//
+// By default, all I/O operations for the volume are suspended when the data
+// on the volume is determined to be potentially inconsistent, to prevent undetectable,
+// latent data corruption. The I/O access to the volume can be resumed by first
+// enabling I/O access and then checking the data consistency on your volume.
+//
+// You can change the default behavior to resume I/O operations. We recommend
+// that you change this only for boot volumes or for volumes that are stateless
+// or disposable.
+func (c *EC2) ModifyVolumeAttribute(input *ModifyVolumeAttributeInput) (*ModifyVolumeAttributeOutput, error) {
+	req, out := c.ModifyVolumeAttributeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opMonitorInstances = "MonitorInstances"
+
+// MonitorInstancesRequest generates a request for the MonitorInstances operation.
+func (c *EC2) MonitorInstancesRequest(input *MonitorInstancesInput) (req *aws.Request, output *MonitorInstancesOutput) {
+	op := &aws.Operation{
+		Name:       opMonitorInstances,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &MonitorInstancesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &MonitorInstancesOutput{}
+	req.Data = output
+	return
+}
+
+// Enables monitoring for a running instance. For more information about monitoring
+// instances, see Monitoring Your Instances and Volumes (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-cloudwatch.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) MonitorInstances(input *MonitorInstancesInput) (*MonitorInstancesOutput, error) {
+	req, out := c.MonitorInstancesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opMoveAddressToVPC = "MoveAddressToVpc"
+
+// MoveAddressToVPCRequest generates a request for the MoveAddressToVPC operation.
+func (c *EC2) MoveAddressToVPCRequest(input *MoveAddressToVPCInput) (req *aws.Request, output *MoveAddressToVPCOutput) {
+	op := &aws.Operation{
+		Name:       opMoveAddressToVPC,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &MoveAddressToVPCInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &MoveAddressToVPCOutput{}
+	req.Data = output
+	return
+}
+
+// Moves an Elastic IP address from the EC2-Classic platform to the EC2-VPC
+// platform. The Elastic IP address must be allocated to your account, and it
+// must not be associated with an instance. After the Elastic IP address is
+// moved, it is no longer available for use in the EC2-Classic platform, unless
+// you move it back using the RestoreAddressToClassic request. You cannot move
+// an Elastic IP address that's allocated for use in the EC2-VPC platform to
+// the EC2-Classic platform.
+func (c *EC2) MoveAddressToVPC(input *MoveAddressToVPCInput) (*MoveAddressToVPCOutput, error) {
+	req, out := c.MoveAddressToVPCRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opPurchaseReservedInstancesOffering = "PurchaseReservedInstancesOffering"
+
+// PurchaseReservedInstancesOfferingRequest generates a request for the PurchaseReservedInstancesOffering operation.
+func (c *EC2) PurchaseReservedInstancesOfferingRequest(input *PurchaseReservedInstancesOfferingInput) (req *aws.Request, output *PurchaseReservedInstancesOfferingOutput) {
+	op := &aws.Operation{
+		Name:       opPurchaseReservedInstancesOffering,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &PurchaseReservedInstancesOfferingInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &PurchaseReservedInstancesOfferingOutput{}
+	req.Data = output
+	return
+}
+
+// Purchases a Reserved Instance for use with your account. With Amazon EC2
+// Reserved Instances, you obtain a capacity reservation for a certain instance
+// configuration over a specified period of time and pay a lower hourly rate
+// compared to on-Demand Instance pricing.
+//
+// Use DescribeReservedInstancesOfferings to get a list of Reserved Instance
+// offerings that match your specifications. After you've purchased a Reserved
+// Instance, you can check for your new Reserved Instance with DescribeReservedInstances.
+//
+// For more information, see Reserved Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts-on-demand-reserved-instances.html)
+// and Reserved Instance Marketplace (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) PurchaseReservedInstancesOffering(input *PurchaseReservedInstancesOfferingInput) (*PurchaseReservedInstancesOfferingOutput, error) {
+	req, out := c.PurchaseReservedInstancesOfferingRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opRebootInstances = "RebootInstances"
+
+// RebootInstancesRequest generates a request for the RebootInstances operation.
+func (c *EC2) RebootInstancesRequest(input *RebootInstancesInput) (req *aws.Request, output *RebootInstancesOutput) {
+	op := &aws.Operation{
+		Name:       opRebootInstances,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &RebootInstancesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &RebootInstancesOutput{}
+	req.Data = output
+	return
+}
+
+// Requests a reboot of one or more instances. This operation is asynchronous;
+// it only queues a request to reboot the specified instances. The operation
+// succeeds if the instances are valid and belong to you. Requests to reboot
+// terminated instances are ignored.
+//
+// If a Linux/Unix instance does not cleanly shut down within four minutes,
+// Amazon EC2 performs a hard reboot.
+//
+// For more information about troubleshooting, see Getting Console Output and
+// Rebooting Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-console.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) RebootInstances(input *RebootInstancesInput) (*RebootInstancesOutput, error) {
+	req, out := c.RebootInstancesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opRegisterImage = "RegisterImage"
+
+// RegisterImageRequest generates a request for the RegisterImage operation.
+func (c *EC2) RegisterImageRequest(input *RegisterImageInput) (req *aws.Request, output *RegisterImageOutput) {
+	op := &aws.Operation{
+		Name:       opRegisterImage,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &RegisterImageInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &RegisterImageOutput{}
+	req.Data = output
+	return
+}
+
+// Registers an AMI. When you're creating an AMI, this is the final step you
+// must complete before you can launch an instance from the AMI. This step is
+// required if you're creating an instance store-backed Linux or Windows AMI.
+// For more information, see Creating an Instance Store-Backed Linux AMI (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-instance-store.html)
+// and Creating an Instance Store-Backed Windows AMI (http://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/Creating_InstanceStoreBacked_WinAMI.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+//
+// For Amazon EBS-backed instances, CreateImage creates and registers the AMI
+// in a single request, so you don't have to register the AMI yourself.
+//
+// You can also use RegisterImage to create an Amazon EBS-backed AMI from a
+// snapshot of a root device volume. For more information, see Launching an
+// Instance from a Backup (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-launch-snapshot.html)
+// in the Amazon Elastic Compute Cloud User Guide. Note that although you can
+// create a Windows AMI from a snapshot, you can't launch an instance from the
+// AMI - use the CreateImage command instead.
+//
+// If needed, you can deregister an AMI at any time. Any modifications you
+// make to an AMI backed by an instance store volume invalidates its registration.
+// If you make changes to an image, deregister the previous image and register
+// the new image.
+//
+// You can't register an image where a secondary (non-root) snapshot has AWS
+// Marketplace product codes.
+func (c *EC2) RegisterImage(input *RegisterImageInput) (*RegisterImageOutput, error) {
+	req, out := c.RegisterImageRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opRejectVPCPeeringConnection = "RejectVpcPeeringConnection"
+
+// RejectVPCPeeringConnectionRequest generates a request for the RejectVPCPeeringConnection operation.
+func (c *EC2) RejectVPCPeeringConnectionRequest(input *RejectVPCPeeringConnectionInput) (req *aws.Request, output *RejectVPCPeeringConnectionOutput) {
+	op := &aws.Operation{
+		Name:       opRejectVPCPeeringConnection,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &RejectVPCPeeringConnectionInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &RejectVPCPeeringConnectionOutput{}
+	req.Data = output
+	return
+}
+
+// Rejects a VPC peering connection request. The VPC peering connection must
+// be in the pending-acceptance state. Use the DescribeVpcPeeringConnections
+// request to view your outstanding VPC peering connection requests. To delete
+// an active VPC peering connection, or to delete a VPC peering connection request
+// that you initiated, use DeleteVpcPeeringConnection.
+func (c *EC2) RejectVPCPeeringConnection(input *RejectVPCPeeringConnectionInput) (*RejectVPCPeeringConnectionOutput, error) {
+	req, out := c.RejectVPCPeeringConnectionRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opReleaseAddress = "ReleaseAddress"
+
+// ReleaseAddressRequest generates a request for the ReleaseAddress operation.
+func (c *EC2) ReleaseAddressRequest(input *ReleaseAddressInput) (req *aws.Request, output *ReleaseAddressOutput) {
+	op := &aws.Operation{
+		Name:       opReleaseAddress,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ReleaseAddressInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ReleaseAddressOutput{}
+	req.Data = output
+	return
+}
+
+// Releases the specified Elastic IP address.
+//
+// After releasing an Elastic IP address, it is released to the IP address
+// pool and might be unavailable to you. Be sure to update your DNS records
+// and any servers or devices that communicate with the address. If you attempt
+// to release an Elastic IP address that you already released, you'll get an
+// AuthFailure error if the address is already allocated to another AWS account.
+//
+// [EC2-Classic, default VPC] Releasing an Elastic IP address automatically
+// disassociates it from any instance that it's associated with. To disassociate
+// an Elastic IP address without releasing it, use DisassociateAddress.
+//
+// [Nondefault VPC] You must use DisassociateAddress to disassociate the Elastic
+// IP address before you try to release it. Otherwise, Amazon EC2 returns an
+// error (InvalidIPAddress.InUse).
+func (c *EC2) ReleaseAddress(input *ReleaseAddressInput) (*ReleaseAddressOutput, error) {
+	req, out := c.ReleaseAddressRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opReplaceNetworkACLAssociation = "ReplaceNetworkAclAssociation"
+
+// ReplaceNetworkACLAssociationRequest generates a request for the ReplaceNetworkACLAssociation operation.
+func (c *EC2) ReplaceNetworkACLAssociationRequest(input *ReplaceNetworkACLAssociationInput) (req *aws.Request, output *ReplaceNetworkACLAssociationOutput) {
+	op := &aws.Operation{
+		Name:       opReplaceNetworkACLAssociation,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ReplaceNetworkACLAssociationInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ReplaceNetworkACLAssociationOutput{}
+	req.Data = output
+	return
+}
+
+// Changes which network ACL a subnet is associated with. By default when you
+// create a subnet, it's automatically associated with the default network ACL.
+// For more information about network ACLs, see Network ACLs (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_ACLs.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) ReplaceNetworkACLAssociation(input *ReplaceNetworkACLAssociationInput) (*ReplaceNetworkACLAssociationOutput, error) {
+	req, out := c.ReplaceNetworkACLAssociationRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opReplaceNetworkACLEntry = "ReplaceNetworkAclEntry"
+
+// ReplaceNetworkACLEntryRequest generates a request for the ReplaceNetworkACLEntry operation.
+func (c *EC2) ReplaceNetworkACLEntryRequest(input *ReplaceNetworkACLEntryInput) (req *aws.Request, output *ReplaceNetworkACLEntryOutput) {
+	op := &aws.Operation{
+		Name:       opReplaceNetworkACLEntry,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ReplaceNetworkACLEntryInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ReplaceNetworkACLEntryOutput{}
+	req.Data = output
+	return
+}
+
+// Replaces an entry (rule) in a network ACL. For more information about network
+// ACLs, see Network ACLs (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_ACLs.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) ReplaceNetworkACLEntry(input *ReplaceNetworkACLEntryInput) (*ReplaceNetworkACLEntryOutput, error) {
+	req, out := c.ReplaceNetworkACLEntryRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opReplaceRoute = "ReplaceRoute"
+
+// ReplaceRouteRequest generates a request for the ReplaceRoute operation.
+func (c *EC2) ReplaceRouteRequest(input *ReplaceRouteInput) (req *aws.Request, output *ReplaceRouteOutput) {
+	op := &aws.Operation{
+		Name:       opReplaceRoute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ReplaceRouteInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ReplaceRouteOutput{}
+	req.Data = output
+	return
+}
+
+// Replaces an existing route within a route table in a VPC. You must provide
+// only one of the following: Internet gateway or virtual private gateway, NAT
+// instance, VPC peering connection, or network interface.
+//
+// For more information about route tables, see Route Tables (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Route_Tables.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) ReplaceRoute(input *ReplaceRouteInput) (*ReplaceRouteOutput, error) {
+	req, out := c.ReplaceRouteRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opReplaceRouteTableAssociation = "ReplaceRouteTableAssociation"
+
+// ReplaceRouteTableAssociationRequest generates a request for the ReplaceRouteTableAssociation operation.
+func (c *EC2) ReplaceRouteTableAssociationRequest(input *ReplaceRouteTableAssociationInput) (req *aws.Request, output *ReplaceRouteTableAssociationOutput) {
+	op := &aws.Operation{
+		Name:       opReplaceRouteTableAssociation,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ReplaceRouteTableAssociationInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ReplaceRouteTableAssociationOutput{}
+	req.Data = output
+	return
+}
+
+// Changes the route table associated with a given subnet in a VPC. After the
+// operation completes, the subnet uses the routes in the new route table it's
+// associated with. For more information about route tables, see Route Tables
+// (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Route_Tables.html)
+// in the Amazon Virtual Private Cloud User Guide.
+//
+// You can also use ReplaceRouteTableAssociation to change which table is the
+// main route table in the VPC. You just specify the main route table's association
+// ID and the route table to be the new main route table.
+func (c *EC2) ReplaceRouteTableAssociation(input *ReplaceRouteTableAssociationInput) (*ReplaceRouteTableAssociationOutput, error) {
+	req, out := c.ReplaceRouteTableAssociationRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opReportInstanceStatus = "ReportInstanceStatus"
+
+// ReportInstanceStatusRequest generates a request for the ReportInstanceStatus operation.
+func (c *EC2) ReportInstanceStatusRequest(input *ReportInstanceStatusInput) (req *aws.Request, output *ReportInstanceStatusOutput) {
+	op := &aws.Operation{
+		Name:       opReportInstanceStatus,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ReportInstanceStatusInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ReportInstanceStatusOutput{}
+	req.Data = output
+	return
+}
+
+// Submits feedback about the status of an instance. The instance must be in
+// the running state. If your experience with the instance differs from the
+// instance status returned by DescribeInstanceStatus, use ReportInstanceStatus
+// to report your experience with the instance. Amazon EC2 collects this information
+// to improve the accuracy of status checks.
+//
+// Use of this action does not change the value returned by DescribeInstanceStatus.
+func (c *EC2) ReportInstanceStatus(input *ReportInstanceStatusInput) (*ReportInstanceStatusOutput, error) {
+	req, out := c.ReportInstanceStatusRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opRequestSpotFleet = "RequestSpotFleet"
+
+// RequestSpotFleetRequest generates a request for the RequestSpotFleet operation.
+func (c *EC2) RequestSpotFleetRequest(input *RequestSpotFleetInput) (req *aws.Request, output *RequestSpotFleetOutput) {
+	op := &aws.Operation{
+		Name:       opRequestSpotFleet,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &RequestSpotFleetInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &RequestSpotFleetOutput{}
+	req.Data = output
+	return
+}
+
+// Creates a Spot fleet request.
+//
+// For more information, see Spot Fleets (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) RequestSpotFleet(input *RequestSpotFleetInput) (*RequestSpotFleetOutput, error) {
+	req, out := c.RequestSpotFleetRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opRequestSpotInstances = "RequestSpotInstances"
+
+// RequestSpotInstancesRequest generates a request for the RequestSpotInstances operation.
+func (c *EC2) RequestSpotInstancesRequest(input *RequestSpotInstancesInput) (req *aws.Request, output *RequestSpotInstancesOutput) {
+	op := &aws.Operation{
+		Name:       opRequestSpotInstances,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &RequestSpotInstancesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &RequestSpotInstancesOutput{}
+	req.Data = output
+	return
+}
+
+// Creates a Spot Instance request. Spot Instances are instances that Amazon
+// EC2 launches when the bid price that you specify exceeds the current Spot
+// Price. Amazon EC2 periodically sets the Spot Price based on available Spot
+// Instance capacity and current Spot Instance requests. For more information,
+// see Spot Instance Requests (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-requests.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) RequestSpotInstances(input *RequestSpotInstancesInput) (*RequestSpotInstancesOutput, error) {
+	req, out := c.RequestSpotInstancesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opResetImageAttribute = "ResetImageAttribute"
+
+// ResetImageAttributeRequest generates a request for the ResetImageAttribute operation.
+func (c *EC2) ResetImageAttributeRequest(input *ResetImageAttributeInput) (req *aws.Request, output *ResetImageAttributeOutput) {
+	op := &aws.Operation{
+		Name:       opResetImageAttribute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ResetImageAttributeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ResetImageAttributeOutput{}
+	req.Data = output
+	return
+}
+
+// Resets an attribute of an AMI to its default value.
+//
+//  The productCodes attribute can't be reset.
+func (c *EC2) ResetImageAttribute(input *ResetImageAttributeInput) (*ResetImageAttributeOutput, error) {
+	req, out := c.ResetImageAttributeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opResetInstanceAttribute = "ResetInstanceAttribute"
+
+// ResetInstanceAttributeRequest generates a request for the ResetInstanceAttribute operation.
+func (c *EC2) ResetInstanceAttributeRequest(input *ResetInstanceAttributeInput) (req *aws.Request, output *ResetInstanceAttributeOutput) {
+	op := &aws.Operation{
+		Name:       opResetInstanceAttribute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ResetInstanceAttributeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ResetInstanceAttributeOutput{}
+	req.Data = output
+	return
+}
+
+// Resets an attribute of an instance to its default value. To reset the kernel
+// or ramdisk, the instance must be in a stopped state. To reset the SourceDestCheck,
+// the instance can be either running or stopped.
+//
+// The SourceDestCheck attribute controls whether source/destination checking
+// is enabled. The default value is true, which means checking is enabled. This
+// value must be false for a NAT instance to perform NAT. For more information,
+// see NAT Instances (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_NAT_Instance.html)
+// in the Amazon Virtual Private Cloud User Guide.
+func (c *EC2) ResetInstanceAttribute(input *ResetInstanceAttributeInput) (*ResetInstanceAttributeOutput, error) {
+	req, out := c.ResetInstanceAttributeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opResetNetworkInterfaceAttribute = "ResetNetworkInterfaceAttribute"
+
+// ResetNetworkInterfaceAttributeRequest generates a request for the ResetNetworkInterfaceAttribute operation.
+func (c *EC2) ResetNetworkInterfaceAttributeRequest(input *ResetNetworkInterfaceAttributeInput) (req *aws.Request, output *ResetNetworkInterfaceAttributeOutput) {
+	op := &aws.Operation{
+		Name:       opResetNetworkInterfaceAttribute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ResetNetworkInterfaceAttributeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ResetNetworkInterfaceAttributeOutput{}
+	req.Data = output
+	return
+}
+
+// Resets a network interface attribute. You can specify only one attribute
+// at a time.
+func (c *EC2) ResetNetworkInterfaceAttribute(input *ResetNetworkInterfaceAttributeInput) (*ResetNetworkInterfaceAttributeOutput, error) {
+	req, out := c.ResetNetworkInterfaceAttributeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opResetSnapshotAttribute = "ResetSnapshotAttribute"
+
+// ResetSnapshotAttributeRequest generates a request for the ResetSnapshotAttribute operation.
+func (c *EC2) ResetSnapshotAttributeRequest(input *ResetSnapshotAttributeInput) (req *aws.Request, output *ResetSnapshotAttributeOutput) {
+	op := &aws.Operation{
+		Name:       opResetSnapshotAttribute,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ResetSnapshotAttributeInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &ResetSnapshotAttributeOutput{}
+	req.Data = output
+	return
+}
+
+// Resets permission settings for the specified snapshot.
+//
+// For more information on modifying snapshot permissions, see Sharing Snapshots
+// (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-modifying-snapshot-permissions.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) ResetSnapshotAttribute(input *ResetSnapshotAttributeInput) (*ResetSnapshotAttributeOutput, error) {
+	req, out := c.ResetSnapshotAttributeRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opRestoreAddressToClassic = "RestoreAddressToClassic"
+
+// RestoreAddressToClassicRequest generates a request for the RestoreAddressToClassic operation.
+func (c *EC2) RestoreAddressToClassicRequest(input *RestoreAddressToClassicInput) (req *aws.Request, output *RestoreAddressToClassicOutput) {
+	op := &aws.Operation{
+		Name:       opRestoreAddressToClassic,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &RestoreAddressToClassicInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &RestoreAddressToClassicOutput{}
+	req.Data = output
+	return
+}
+
+// Restores an Elastic IP address that was previously moved to the EC2-VPC platform
+// back to the EC2-Classic platform. You cannot move an Elastic IP address that
+// was originally allocated for use in EC2-VPC. The Elastic IP address must
+// not be associated with an instance or network interface.
+func (c *EC2) RestoreAddressToClassic(input *RestoreAddressToClassicInput) (*RestoreAddressToClassicOutput, error) {
+	req, out := c.RestoreAddressToClassicRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opRevokeSecurityGroupEgress = "RevokeSecurityGroupEgress"
+
+// RevokeSecurityGroupEgressRequest generates a request for the RevokeSecurityGroupEgress operation.
+func (c *EC2) RevokeSecurityGroupEgressRequest(input *RevokeSecurityGroupEgressInput) (req *aws.Request, output *RevokeSecurityGroupEgressOutput) {
+	op := &aws.Operation{
+		Name:       opRevokeSecurityGroupEgress,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &RevokeSecurityGroupEgressInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &RevokeSecurityGroupEgressOutput{}
+	req.Data = output
+	return
+}
+
+// Removes one or more egress rules from a security group for EC2-VPC. The values
+// that you specify in the revoke request (for example, ports) must match the
+// existing rule's values for the rule to be revoked.
+//
+// Each rule consists of the protocol and the CIDR range or source security
+// group. For the TCP and UDP protocols, you must also specify the destination
+// port or range of ports. For the ICMP protocol, you must also specify the
+// ICMP type and code.
+//
+// Rule changes are propagated to instances within the security group as quickly
+// as possible. However, a small delay might occur.
+func (c *EC2) RevokeSecurityGroupEgress(input *RevokeSecurityGroupEgressInput) (*RevokeSecurityGroupEgressOutput, error) {
+	req, out := c.RevokeSecurityGroupEgressRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opRevokeSecurityGroupIngress = "RevokeSecurityGroupIngress"
+
+// RevokeSecurityGroupIngressRequest generates a request for the RevokeSecurityGroupIngress operation.
+func (c *EC2) RevokeSecurityGroupIngressRequest(input *RevokeSecurityGroupIngressInput) (req *aws.Request, output *RevokeSecurityGroupIngressOutput) {
+	op := &aws.Operation{
+		Name:       opRevokeSecurityGroupIngress,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &RevokeSecurityGroupIngressInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &RevokeSecurityGroupIngressOutput{}
+	req.Data = output
+	return
+}
+
+// Removes one or more ingress rules from a security group. The values that
+// you specify in the revoke request (for example, ports) must match the existing
+// rule's values for the rule to be removed.
+//
+// Each rule consists of the protocol and the CIDR range or source security
+// group. For the TCP and UDP protocols, you must also specify the destination
+// port or range of ports. For the ICMP protocol, you must also specify the
+// ICMP type and code.
+//
+// Rule changes are propagated to instances within the security group as quickly
+// as possible. However, a small delay might occur.
+func (c *EC2) RevokeSecurityGroupIngress(input *RevokeSecurityGroupIngressInput) (*RevokeSecurityGroupIngressOutput, error) {
+	req, out := c.RevokeSecurityGroupIngressRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opRunInstances = "RunInstances"
+
+// RunInstancesRequest generates a request for the RunInstances operation.
+func (c *EC2) RunInstancesRequest(input *RunInstancesInput) (req *aws.Request, output *Reservation) {
+	op := &aws.Operation{
+		Name:       opRunInstances,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &RunInstancesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &Reservation{}
+	req.Data = output
+	return
+}
+
+// Launches the specified number of instances using an AMI for which you have
+// permissions.
+//
+// When you launch an instance, it enters the pending state. After the instance
+// is ready for you, it enters the running state. To check the state of your
+// instance, call DescribeInstances.
+//
+// If you don't specify a security group when launching an instance, Amazon
+// EC2 uses the default security group. For more information, see Security Groups
+// (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+//
+// Linux instances have access to the public key of the key pair at boot. You
+// can use this key to provide secure access to the instance. Amazon EC2 public
+// images use this feature to provide secure access without passwords. For more
+// information, see Key Pairs (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+//
+// You can provide optional user data when launching an instance. For more
+// information, see Instance Metadata (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AESDG-chapter-instancedata.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+//
+// If any of the AMIs have a product code attached for which the user has not
+// subscribed, RunInstances fails.
+//
+// T2 instance types can only be launched into a VPC. If you do not have a
+// default VPC, or if you do not specify a subnet ID in the request, RunInstances
+// fails.
+//
+// For more information about troubleshooting, see What To Do If An Instance
+// Immediately Terminates (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_InstanceStraightToTerminated.html),
+// and Troubleshooting Connecting to Your Instance (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesConnecting.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) RunInstances(input *RunInstancesInput) (*Reservation, error) {
+	req, out := c.RunInstancesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opStartInstances = "StartInstances"
+
+// StartInstancesRequest generates a request for the StartInstances operation.
+func (c *EC2) StartInstancesRequest(input *StartInstancesInput) (req *aws.Request, output *StartInstancesOutput) {
+	op := &aws.Operation{
+		Name:       opStartInstances,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &StartInstancesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &StartInstancesOutput{}
+	req.Data = output
+	return
+}
+
+// Starts an Amazon EBS-backed AMI that you've previously stopped.
+//
+// Instances that use Amazon EBS volumes as their root devices can be quickly
+// stopped and started. When an instance is stopped, the compute resources are
+// released and you are not billed for hourly instance usage. However, your
+// root partition Amazon EBS volume remains, continues to persist your data,
+// and you are charged for Amazon EBS volume usage. You can restart your instance
+// at any time. Each time you transition an instance from stopped to started,
+// Amazon EC2 charges a full instance hour, even if transitions happen multiple
+// times within a single hour.
+//
+// Before stopping an instance, make sure it is in a state from which it can
+// be restarted. Stopping an instance does not preserve data stored in RAM.
+//
+// Performing this operation on an instance that uses an instance store as
+// its root device returns an error.
+//
+// For more information, see Stopping Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Stop_Start.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) StartInstances(input *StartInstancesInput) (*StartInstancesOutput, error) {
+	req, out := c.StartInstancesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opStopInstances = "StopInstances"
+
+// StopInstancesRequest generates a request for the StopInstances operation.
+func (c *EC2) StopInstancesRequest(input *StopInstancesInput) (req *aws.Request, output *StopInstancesOutput) {
+	op := &aws.Operation{
+		Name:       opStopInstances,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &StopInstancesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &StopInstancesOutput{}
+	req.Data = output
+	return
+}
+
+// Stops an Amazon EBS-backed instance. Each time you transition an instance
+// from stopped to started, Amazon EC2 charges a full instance hour, even if
+// transitions happen multiple times within a single hour.
+//
+// You can't start or stop Spot Instances.
+//
+// Instances that use Amazon EBS volumes as their root devices can be quickly
+// stopped and started. When an instance is stopped, the compute resources are
+// released and you are not billed for hourly instance usage. However, your
+// root partition Amazon EBS volume remains, continues to persist your data,
+// and you are charged for Amazon EBS volume usage. You can restart your instance
+// at any time.
+//
+// Before stopping an instance, make sure it is in a state from which it can
+// be restarted. Stopping an instance does not preserve data stored in RAM.
+//
+// Performing this operation on an instance that uses an instance store as
+// its root device returns an error.
+//
+// You can stop, start, and terminate EBS-backed instances. You can only terminate
+// instance store-backed instances. What happens to an instance differs if you
+// stop it or terminate it. For example, when you stop an instance, the root
+// device and any other devices attached to the instance persist. When you terminate
+// an instance, the root device and any other devices attached during the instance
+// launch are automatically deleted. For more information about the differences
+// between stopping and terminating instances, see Instance Lifecycle (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-lifecycle.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+//
+// For more information about troubleshooting, see Troubleshooting Stopping
+// Your Instance (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesStopping.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) StopInstances(input *StopInstancesInput) (*StopInstancesOutput, error) {
+	req, out := c.StopInstancesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opTerminateInstances = "TerminateInstances"
+
+// TerminateInstancesRequest generates a request for the TerminateInstances operation.
+func (c *EC2) TerminateInstancesRequest(input *TerminateInstancesInput) (req *aws.Request, output *TerminateInstancesOutput) {
+	op := &aws.Operation{
+		Name:       opTerminateInstances,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &TerminateInstancesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &TerminateInstancesOutput{}
+	req.Data = output
+	return
+}
+
+// Shuts down one or more instances. This operation is idempotent; if you terminate
+// an instance more than once, each call succeeds.
+//
+// Terminated instances remain visible after termination (for approximately
+// one hour).
+//
+// By default, Amazon EC2 deletes all EBS volumes that were attached when the
+// instance launched. Volumes attached after instance launch continue running.
+//
+// You can stop, start, and terminate EBS-backed instances. You can only terminate
+// instance store-backed instances. What happens to an instance differs if you
+// stop it or terminate it. For example, when you stop an instance, the root
+// device and any other devices attached to the instance persist. When you terminate
+// an instance, the root device and any other devices attached during the instance
+// launch are automatically deleted. For more information about the differences
+// between stopping and terminating instances, see Instance Lifecycle (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-lifecycle.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+//
+// For more information about troubleshooting, see Troubleshooting Terminating
+// Your Instance (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesShuttingDown.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) TerminateInstances(input *TerminateInstancesInput) (*TerminateInstancesOutput, error) {
+	req, out := c.TerminateInstancesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opUnassignPrivateIPAddresses = "UnassignPrivateIpAddresses"
+
+// UnassignPrivateIPAddressesRequest generates a request for the UnassignPrivateIPAddresses operation.
+func (c *EC2) UnassignPrivateIPAddressesRequest(input *UnassignPrivateIPAddressesInput) (req *aws.Request, output *UnassignPrivateIPAddressesOutput) {
+	op := &aws.Operation{
+		Name:       opUnassignPrivateIPAddresses,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UnassignPrivateIPAddressesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &UnassignPrivateIPAddressesOutput{}
+	req.Data = output
+	return
+}
+
+// Unassigns one or more secondary private IP addresses from a network interface.
+func (c *EC2) UnassignPrivateIPAddresses(input *UnassignPrivateIPAddressesInput) (*UnassignPrivateIPAddressesOutput, error) {
+	req, out := c.UnassignPrivateIPAddressesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+const opUnmonitorInstances = "UnmonitorInstances"
+
+// UnmonitorInstancesRequest generates a request for the UnmonitorInstances operation.
+func (c *EC2) UnmonitorInstancesRequest(input *UnmonitorInstancesInput) (req *aws.Request, output *UnmonitorInstancesOutput) {
+	op := &aws.Operation{
+		Name:       opUnmonitorInstances,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UnmonitorInstancesInput{}
+	}
+
+	req = c.newRequest(op, input, output)
+	output = &UnmonitorInstancesOutput{}
+	req.Data = output
+	return
+}
+
+// Disables monitoring for a running instance. For more information about monitoring
+// instances, see Monitoring Your Instances and Volumes (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-cloudwatch.html)
+// in the Amazon Elastic Compute Cloud User Guide.
+func (c *EC2) UnmonitorInstances(input *UnmonitorInstancesInput) (*UnmonitorInstancesOutput, error) {
+	req, out := c.UnmonitorInstancesRequest(input)
+	err := req.Send()
+	return out, err
+}
+
+type AcceptVPCPeeringConnectionInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the VPC peering connection.
+	VPCPeeringConnectionID *string `locationName:"vpcPeeringConnectionId" type:"string"`
+
+	metadataAcceptVPCPeeringConnectionInput `json:"-" xml:"-"`
+}
+
+type metadataAcceptVPCPeeringConnectionInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AcceptVPCPeeringConnectionInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AcceptVPCPeeringConnectionInput) GoString() string {
+	return s.String()
+}
+
+type AcceptVPCPeeringConnectionOutput struct {
+	// Information about the VPC peering connection.
+	VPCPeeringConnection *VPCPeeringConnection `locationName:"vpcPeeringConnection" type:"structure"`
+
+	metadataAcceptVPCPeeringConnectionOutput `json:"-" xml:"-"`
+}
+
+type metadataAcceptVPCPeeringConnectionOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AcceptVPCPeeringConnectionOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AcceptVPCPeeringConnectionOutput) GoString() string {
+	return s.String()
+}
+
+// Describes an account attribute.
+type AccountAttribute struct {
+	// The name of the account attribute.
+	AttributeName *string `locationName:"attributeName" type:"string"`
+
+	// One or more values for the account attribute.
+	AttributeValues []*AccountAttributeValue `locationName:"attributeValueSet" locationNameList:"item" type:"list"`
+
+	metadataAccountAttribute `json:"-" xml:"-"`
+}
+
+type metadataAccountAttribute struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AccountAttribute) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AccountAttribute) GoString() string {
+	return s.String()
+}
+
+// Describes a value of an account attribute.
+type AccountAttributeValue struct {
+	// The value of the attribute.
+	AttributeValue *string `locationName:"attributeValue" type:"string"`
+
+	metadataAccountAttributeValue `json:"-" xml:"-"`
+}
+
+type metadataAccountAttributeValue struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AccountAttributeValue) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AccountAttributeValue) GoString() string {
+	return s.String()
+}
+
+// Describes a running instance in a Spot fleet.
+type ActiveInstance struct {
+	// The ID of the instance.
+	InstanceID *string `locationName:"instanceId" type:"string"`
+
+	// The instance type.
+	InstanceType *string `locationName:"instanceType" type:"string"`
+
+	// The ID of the Spot Instance request.
+	SpotInstanceRequestID *string `locationName:"spotInstanceRequestId" type:"string"`
+
+	metadataActiveInstance `json:"-" xml:"-"`
+}
+
+type metadataActiveInstance struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ActiveInstance) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ActiveInstance) GoString() string {
+	return s.String()
+}
+
+// Describes an Elastic IP address.
+type Address struct {
+	// The ID representing the allocation of the address for use with EC2-VPC.
+	AllocationID *string `locationName:"allocationId" type:"string"`
+
+	// The ID representing the association of the address with an instance in a
+	// VPC.
+	AssociationID *string `locationName:"associationId" type:"string"`
+
+	// Indicates whether this Elastic IP address is for use with instances in EC2-Classic
+	// (standard) or instances in a VPC (vpc).
+	Domain *string `locationName:"domain" type:"string" enum:"DomainType"`
+
+	// The ID of the instance that the address is associated with (if any).
+	InstanceID *string `locationName:"instanceId" type:"string"`
+
+	// The ID of the network interface.
+	NetworkInterfaceID *string `locationName:"networkInterfaceId" type:"string"`
+
+	// The ID of the AWS account that owns the network interface.
+	NetworkInterfaceOwnerID *string `locationName:"networkInterfaceOwnerId" type:"string"`
+
+	// The private IP address associated with the Elastic IP address.
+	PrivateIPAddress *string `locationName:"privateIpAddress" type:"string"`
+
+	// The Elastic IP address.
+	PublicIP *string `locationName:"publicIp" type:"string"`
+
+	metadataAddress `json:"-" xml:"-"`
+}
+
+type metadataAddress struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s Address) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Address) GoString() string {
+	return s.String()
+}
+
+type AllocateAddressInput struct {
+	// Set to vpc to allocate the address for use with instances in a VPC.
+	//
+	// Default: The address is for use with instances in EC2-Classic.
+	Domain *string `type:"string" enum:"DomainType"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	metadataAllocateAddressInput `json:"-" xml:"-"`
+}
+
+type metadataAllocateAddressInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AllocateAddressInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AllocateAddressInput) GoString() string {
+	return s.String()
+}
+
+type AllocateAddressOutput struct {
+	// [EC2-VPC] The ID that AWS assigns to represent the allocation of the Elastic
+	// IP address for use with instances in a VPC.
+	AllocationID *string `locationName:"allocationId" type:"string"`
+
+	// Indicates whether this Elastic IP address is for use with instances in EC2-Classic
+	// (standard) or instances in a VPC (vpc).
+	Domain *string `locationName:"domain" type:"string" enum:"DomainType"`
+
+	// The Elastic IP address.
+	PublicIP *string `locationName:"publicIp" type:"string"`
+
+	metadataAllocateAddressOutput `json:"-" xml:"-"`
+}
+
+type metadataAllocateAddressOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AllocateAddressOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AllocateAddressOutput) GoString() string {
+	return s.String()
+}
+
+type AssignPrivateIPAddressesInput struct {
+	// Indicates whether to allow an IP address that is already assigned to another
+	// network interface or instance to be reassigned to the specified network interface.
+	AllowReassignment *bool `locationName:"allowReassignment" type:"boolean"`
+
+	// The ID of the network interface.
+	NetworkInterfaceID *string `locationName:"networkInterfaceId" type:"string" required:"true"`
+
+	// One or more IP addresses to be assigned as a secondary private IP address
+	// to the network interface. You can't specify this parameter when also specifying
+	// a number of secondary IP addresses.
+	//
+	// If you don't specify an IP address, Amazon EC2 automatically selects an
+	// IP address within the subnet range.
+	PrivateIPAddresses []*string `locationName:"privateIpAddress" locationNameList:"PrivateIpAddress" type:"list"`
+
+	// The number of secondary IP addresses to assign to the network interface.
+	// You can't specify this parameter when also specifying private IP addresses.
+	SecondaryPrivateIPAddressCount *int64 `locationName:"secondaryPrivateIpAddressCount" type:"integer"`
+
+	metadataAssignPrivateIPAddressesInput `json:"-" xml:"-"`
+}
+
+type metadataAssignPrivateIPAddressesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AssignPrivateIPAddressesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AssignPrivateIPAddressesInput) GoString() string {
+	return s.String()
+}
+
+type AssignPrivateIPAddressesOutput struct {
+	metadataAssignPrivateIPAddressesOutput `json:"-" xml:"-"`
+}
+
+type metadataAssignPrivateIPAddressesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AssignPrivateIPAddressesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AssignPrivateIPAddressesOutput) GoString() string {
+	return s.String()
+}
+
+type AssociateAddressInput struct {
+	// [EC2-VPC] The allocation ID. This is required for EC2-VPC.
+	AllocationID *string `locationName:"AllocationId" type:"string"`
+
+	// [EC2-VPC] Allows an Elastic IP address that is already associated with an
+	// instance or network interface to be re-associated with the specified instance
+	// or network interface. Otherwise, the operation fails.
+	//
+	// Default: false
+	AllowReassociation *bool `locationName:"allowReassociation" type:"boolean"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the instance. This is required for EC2-Classic. For EC2-VPC, you
+	// can specify either the instance ID or the network interface ID, but not both.
+	// The operation fails if you specify an instance ID unless exactly one network
+	// interface is attached.
+	InstanceID *string `locationName:"InstanceId" type:"string"`
+
+	// [EC2-VPC] The ID of the network interface. If the instance has more than
+	// one network interface, you must specify a network interface ID.
+	NetworkInterfaceID *string `locationName:"networkInterfaceId" type:"string"`
+
+	// [EC2-VPC] The primary or secondary private IP address to associate with the
+	// Elastic IP address. If no private IP address is specified, the Elastic IP
+	// address is associated with the primary private IP address.
+	PrivateIPAddress *string `locationName:"privateIpAddress" type:"string"`
+
+	// The Elastic IP address. This is required for EC2-Classic.
+	PublicIP *string `locationName:"PublicIp" type:"string"`
+
+	metadataAssociateAddressInput `json:"-" xml:"-"`
+}
+
+type metadataAssociateAddressInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AssociateAddressInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AssociateAddressInput) GoString() string {
+	return s.String()
+}
+
+type AssociateAddressOutput struct {
+	// [EC2-VPC] The ID that represents the association of the Elastic IP address
+	// with an instance.
+	AssociationID *string `locationName:"associationId" type:"string"`
+
+	metadataAssociateAddressOutput `json:"-" xml:"-"`
+}
+
+type metadataAssociateAddressOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AssociateAddressOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AssociateAddressOutput) GoString() string {
+	return s.String()
+}
+
+type AssociateDHCPOptionsInput struct {
+	// The ID of the DHCP options set, or default to associate no DHCP options with
+	// the VPC.
+	DHCPOptionsID *string `locationName:"DhcpOptionsId" type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"VpcId" type:"string" required:"true"`
+
+	metadataAssociateDHCPOptionsInput `json:"-" xml:"-"`
+}
+
+type metadataAssociateDHCPOptionsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AssociateDHCPOptionsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AssociateDHCPOptionsInput) GoString() string {
+	return s.String()
+}
+
+type AssociateDHCPOptionsOutput struct {
+	metadataAssociateDHCPOptionsOutput `json:"-" xml:"-"`
+}
+
+type metadataAssociateDHCPOptionsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AssociateDHCPOptionsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AssociateDHCPOptionsOutput) GoString() string {
+	return s.String()
+}
+
+type AssociateRouteTableInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the route table.
+	RouteTableID *string `locationName:"routeTableId" type:"string" required:"true"`
+
+	// The ID of the subnet.
+	SubnetID *string `locationName:"subnetId" type:"string" required:"true"`
+
+	metadataAssociateRouteTableInput `json:"-" xml:"-"`
+}
+
+type metadataAssociateRouteTableInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AssociateRouteTableInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AssociateRouteTableInput) GoString() string {
+	return s.String()
+}
+
+type AssociateRouteTableOutput struct {
+	// The route table association ID (needed to disassociate the route table).
+	AssociationID *string `locationName:"associationId" type:"string"`
+
+	metadataAssociateRouteTableOutput `json:"-" xml:"-"`
+}
+
+type metadataAssociateRouteTableOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AssociateRouteTableOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AssociateRouteTableOutput) GoString() string {
+	return s.String()
+}
+
+type AttachClassicLinkVPCInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of one or more of the VPC's security groups. You cannot specify security
+	// groups from a different VPC.
+	Groups []*string `locationName:"SecurityGroupId" locationNameList:"groupId" type:"list" required:"true"`
+
+	// The ID of an EC2-Classic instance to link to the ClassicLink-enabled VPC.
+	InstanceID *string `locationName:"instanceId" type:"string" required:"true"`
+
+	// The ID of a ClassicLink-enabled VPC.
+	VPCID *string `locationName:"vpcId" type:"string" required:"true"`
+
+	metadataAttachClassicLinkVPCInput `json:"-" xml:"-"`
+}
+
+type metadataAttachClassicLinkVPCInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AttachClassicLinkVPCInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AttachClassicLinkVPCInput) GoString() string {
+	return s.String()
+}
+
+type AttachClassicLinkVPCOutput struct {
+	// Returns true if the request succeeds; otherwise, it returns an error.
+	Return *bool `locationName:"return" type:"boolean"`
+
+	metadataAttachClassicLinkVPCOutput `json:"-" xml:"-"`
+}
+
+type metadataAttachClassicLinkVPCOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AttachClassicLinkVPCOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AttachClassicLinkVPCOutput) GoString() string {
+	return s.String()
+}
+
+type AttachInternetGatewayInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the Internet gateway.
+	InternetGatewayID *string `locationName:"internetGatewayId" type:"string" required:"true"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"vpcId" type:"string" required:"true"`
+
+	metadataAttachInternetGatewayInput `json:"-" xml:"-"`
+}
+
+type metadataAttachInternetGatewayInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AttachInternetGatewayInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AttachInternetGatewayInput) GoString() string {
+	return s.String()
+}
+
+type AttachInternetGatewayOutput struct {
+	metadataAttachInternetGatewayOutput `json:"-" xml:"-"`
+}
+
+type metadataAttachInternetGatewayOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AttachInternetGatewayOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AttachInternetGatewayOutput) GoString() string {
+	return s.String()
+}
+
+type AttachNetworkInterfaceInput struct {
+	// The index of the device for the network interface attachment.
+	DeviceIndex *int64 `locationName:"deviceIndex" type:"integer" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the instance.
+	InstanceID *string `locationName:"instanceId" type:"string" required:"true"`
+
+	// The ID of the network interface.
+	NetworkInterfaceID *string `locationName:"networkInterfaceId" type:"string" required:"true"`
+
+	metadataAttachNetworkInterfaceInput `json:"-" xml:"-"`
+}
+
+type metadataAttachNetworkInterfaceInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AttachNetworkInterfaceInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AttachNetworkInterfaceInput) GoString() string {
+	return s.String()
+}
+
+type AttachNetworkInterfaceOutput struct {
+	// The ID of the network interface attachment.
+	AttachmentID *string `locationName:"attachmentId" type:"string"`
+
+	metadataAttachNetworkInterfaceOutput `json:"-" xml:"-"`
+}
+
+type metadataAttachNetworkInterfaceOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AttachNetworkInterfaceOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AttachNetworkInterfaceOutput) GoString() string {
+	return s.String()
+}
+
+type AttachVPNGatewayInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"VpcId" type:"string" required:"true"`
+
+	// The ID of the virtual private gateway.
+	VPNGatewayID *string `locationName:"VpnGatewayId" type:"string" required:"true"`
+
+	metadataAttachVPNGatewayInput `json:"-" xml:"-"`
+}
+
+type metadataAttachVPNGatewayInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AttachVPNGatewayInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AttachVPNGatewayInput) GoString() string {
+	return s.String()
+}
+
+type AttachVPNGatewayOutput struct {
+	// Information about the attachment.
+	VPCAttachment *VPCAttachment `locationName:"attachment" type:"structure"`
+
+	metadataAttachVPNGatewayOutput `json:"-" xml:"-"`
+}
+
+type metadataAttachVPNGatewayOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AttachVPNGatewayOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AttachVPNGatewayOutput) GoString() string {
+	return s.String()
+}
+
+type AttachVolumeInput struct {
+	// The device name to expose to the instance (for example, /dev/sdh or xvdh).
+	Device *string `type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the instance.
+	InstanceID *string `locationName:"InstanceId" type:"string" required:"true"`
+
+	// The ID of the EBS volume. The volume and instance must be within the same
+	// Availability Zone.
+	VolumeID *string `locationName:"VolumeId" type:"string" required:"true"`
+
+	metadataAttachVolumeInput `json:"-" xml:"-"`
+}
+
+type metadataAttachVolumeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AttachVolumeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AttachVolumeInput) GoString() string {
+	return s.String()
+}
+
+// The value to use when a resource attribute accepts a Boolean value.
+type AttributeBooleanValue struct {
+	// Valid values are true or false.
+	Value *bool `locationName:"value" type:"boolean"`
+
+	metadataAttributeBooleanValue `json:"-" xml:"-"`
+}
+
+type metadataAttributeBooleanValue struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AttributeBooleanValue) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AttributeBooleanValue) GoString() string {
+	return s.String()
+}
+
+// The value to use for a resource attribute.
+type AttributeValue struct {
+	// Valid values are case-sensitive and vary by action.
+	Value *string `locationName:"value" type:"string"`
+
+	metadataAttributeValue `json:"-" xml:"-"`
+}
+
+type metadataAttributeValue struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AttributeValue) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AttributeValue) GoString() string {
+	return s.String()
+}
+
+type AuthorizeSecurityGroupEgressInput struct {
+	// The CIDR IP address range. You can't specify this parameter when specifying
+	// a source security group.
+	CIDRIP *string `locationName:"cidrIp" type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The start of port range for the TCP and UDP protocols, or an ICMP type number.
+	// For the ICMP type number, use -1 to specify all ICMP types.
+	FromPort *int64 `locationName:"fromPort" type:"integer"`
+
+	// The ID of the security group.
+	GroupID *string `locationName:"groupId" type:"string" required:"true"`
+
+	// A set of IP permissions. You can't specify a destination security group and
+	// a CIDR IP address range.
+	IPPermissions []*IPPermission `locationName:"ipPermissions" locationNameList:"item" type:"list"`
+
+	// The IP protocol name (tcp, udp, icmp) or number (see Protocol Numbers (http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml)).
+	// Use -1 to specify all.
+	IPProtocol *string `locationName:"ipProtocol" type:"string"`
+
+	// The name of a destination security group. To authorize outbound access to
+	// a destination security group, we recommend that you use a set of IP permissions
+	// instead.
+	SourceSecurityGroupName *string `locationName:"sourceSecurityGroupName" type:"string"`
+
+	// The AWS account number for a destination security group. To authorize outbound
+	// access to a destination security group, we recommend that you use a set of
+	// IP permissions instead.
+	SourceSecurityGroupOwnerID *string `locationName:"sourceSecurityGroupOwnerId" type:"string"`
+
+	// The end of port range for the TCP and UDP protocols, or an ICMP code number.
+	// For the ICMP code number, use -1 to specify all ICMP codes for the ICMP type.
+	ToPort *int64 `locationName:"toPort" type:"integer"`
+
+	metadataAuthorizeSecurityGroupEgressInput `json:"-" xml:"-"`
+}
+
+type metadataAuthorizeSecurityGroupEgressInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AuthorizeSecurityGroupEgressInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AuthorizeSecurityGroupEgressInput) GoString() string {
+	return s.String()
+}
+
+type AuthorizeSecurityGroupEgressOutput struct {
+	metadataAuthorizeSecurityGroupEgressOutput `json:"-" xml:"-"`
+}
+
+type metadataAuthorizeSecurityGroupEgressOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AuthorizeSecurityGroupEgressOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AuthorizeSecurityGroupEgressOutput) GoString() string {
+	return s.String()
+}
+
+type AuthorizeSecurityGroupIngressInput struct {
+	// The CIDR IP address range. You can't specify this parameter when specifying
+	// a source security group.
+	CIDRIP *string `locationName:"CidrIp" type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The start of port range for the TCP and UDP protocols, or an ICMP type number.
+	// For the ICMP type number, use -1 to specify all ICMP types.
+	FromPort *int64 `type:"integer"`
+
+	// The ID of the security group. Required for a nondefault VPC.
+	GroupID *string `locationName:"GroupId" type:"string"`
+
+	// [EC2-Classic, default VPC] The name of the security group.
+	GroupName *string `type:"string"`
+
+	// A set of IP permissions. Can be used to specify multiple rules in a single
+	// command.
+	IPPermissions []*IPPermission `locationName:"IpPermissions" locationNameList:"item" type:"list"`
+
+	// The IP protocol name (tcp, udp, icmp) or number (see Protocol Numbers (http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml)).
+	// (VPC only) Use -1 to specify all.
+	IPProtocol *string `locationName:"IpProtocol" type:"string"`
+
+	// [EC2-Classic, default VPC] The name of the source security group. You can't
+	// specify this parameter in combination with the following parameters: the
+	// CIDR IP address range, the start of the port range, the IP protocol, and
+	// the end of the port range. For EC2-VPC, the source security group must be
+	// in the same VPC.
+	SourceSecurityGroupName *string `type:"string"`
+
+	// [EC2-Classic, default VPC] The AWS account number for the source security
+	// group. For EC2-VPC, the source security group must be in the same VPC. You
+	// can't specify this parameter in combination with the following parameters:
+	// the CIDR IP address range, the IP protocol, the start of the port range,
+	// and the end of the port range. Creates rules that grant full ICMP, UDP, and
+	// TCP access. To create a rule with a specific IP protocol and port range,
+	// use a set of IP permissions instead.
+	SourceSecurityGroupOwnerID *string `locationName:"SourceSecurityGroupOwnerId" type:"string"`
+
+	// The end of port range for the TCP and UDP protocols, or an ICMP code number.
+	// For the ICMP code number, use -1 to specify all ICMP codes for the ICMP type.
+	ToPort *int64 `type:"integer"`
+
+	metadataAuthorizeSecurityGroupIngressInput `json:"-" xml:"-"`
+}
+
+type metadataAuthorizeSecurityGroupIngressInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AuthorizeSecurityGroupIngressInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AuthorizeSecurityGroupIngressInput) GoString() string {
+	return s.String()
+}
+
+type AuthorizeSecurityGroupIngressOutput struct {
+	metadataAuthorizeSecurityGroupIngressOutput `json:"-" xml:"-"`
+}
+
+type metadataAuthorizeSecurityGroupIngressOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AuthorizeSecurityGroupIngressOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AuthorizeSecurityGroupIngressOutput) GoString() string {
+	return s.String()
+}
+
+// Describes an Availability Zone.
+type AvailabilityZone struct {
+	// Any messages about the Availability Zone.
+	Messages []*AvailabilityZoneMessage `locationName:"messageSet" locationNameList:"item" type:"list"`
+
+	// The name of the region.
+	RegionName *string `locationName:"regionName" type:"string"`
+
+	// The state of the Availability Zone (available | impaired | unavailable).
+	State *string `locationName:"zoneState" type:"string" enum:"AvailabilityZoneState"`
+
+	// The name of the Availability Zone.
+	ZoneName *string `locationName:"zoneName" type:"string"`
+
+	metadataAvailabilityZone `json:"-" xml:"-"`
+}
+
+type metadataAvailabilityZone struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AvailabilityZone) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AvailabilityZone) GoString() string {
+	return s.String()
+}
+
+// Describes a message about an Availability Zone.
+type AvailabilityZoneMessage struct {
+	// The message about the Availability Zone.
+	Message *string `locationName:"message" type:"string"`
+
+	metadataAvailabilityZoneMessage `json:"-" xml:"-"`
+}
+
+type metadataAvailabilityZoneMessage struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s AvailabilityZoneMessage) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AvailabilityZoneMessage) GoString() string {
+	return s.String()
+}
+
+type BlobAttributeValue struct {
+	Value []byte `locationName:"value" type:"blob"`
+
+	metadataBlobAttributeValue `json:"-" xml:"-"`
+}
+
+type metadataBlobAttributeValue struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s BlobAttributeValue) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s BlobAttributeValue) GoString() string {
+	return s.String()
+}
+
+// Describes a block device mapping.
+type BlockDeviceMapping struct {
+	// The device name exposed to the instance (for example, /dev/sdh or xvdh).
+	DeviceName *string `locationName:"deviceName" type:"string"`
+
+	// Parameters used to automatically set up EBS volumes when the instance is
+	// launched.
+	EBS *EBSBlockDevice `locationName:"ebs" type:"structure"`
+
+	// Suppresses the specified device included in the block device mapping of the
+	// AMI.
+	NoDevice *string `locationName:"noDevice" type:"string"`
+
+	// The virtual device name (ephemeralN). Instance store volumes are numbered
+	// starting from 0. An instance type with 2 available instance store volumes
+	// can specify mappings for ephemeral0 and ephemeral1.The number of available
+	// instance store volumes depends on the instance type. After you connect to
+	// the instance, you must mount the volume.
+	//
+	// Constraints: For M3 instances, you must specify instance store volumes in
+	// the block device mapping for the instance. When you launch an M3 instance,
+	// we ignore any instance store volumes specified in the block device mapping
+	// for the AMI.
+	VirtualName *string `locationName:"virtualName" type:"string"`
+
+	metadataBlockDeviceMapping `json:"-" xml:"-"`
+}
+
+type metadataBlockDeviceMapping struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s BlockDeviceMapping) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s BlockDeviceMapping) GoString() string {
+	return s.String()
+}
+
+type BundleInstanceInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the instance to bundle.
+	//
+	// Type: String
+	//
+	// Default: None
+	//
+	// Required: Yes
+	InstanceID *string `locationName:"InstanceId" type:"string" required:"true"`
+
+	// The bucket in which to store the AMI. You can specify a bucket that you already
+	// own or a new bucket that Amazon EC2 creates on your behalf. If you specify
+	// a bucket that belongs to someone else, Amazon EC2 returns an error.
+	Storage *Storage `type:"structure" required:"true"`
+
+	metadataBundleInstanceInput `json:"-" xml:"-"`
+}
+
+type metadataBundleInstanceInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s BundleInstanceInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s BundleInstanceInput) GoString() string {
+	return s.String()
+}
+
+type BundleInstanceOutput struct {
+	// Information about the bundle task.
+	BundleTask *BundleTask `locationName:"bundleInstanceTask" type:"structure"`
+
+	metadataBundleInstanceOutput `json:"-" xml:"-"`
+}
+
+type metadataBundleInstanceOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s BundleInstanceOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s BundleInstanceOutput) GoString() string {
+	return s.String()
+}
+
+// Describes a bundle task.
+type BundleTask struct {
+	// The ID of the bundle task.
+	BundleID *string `locationName:"bundleId" type:"string"`
+
+	// If the task fails, a description of the error.
+	BundleTaskError *BundleTaskError `locationName:"error" type:"structure"`
+
+	// The ID of the instance associated with this bundle task.
+	InstanceID *string `locationName:"instanceId" type:"string"`
+
+	// The level of task completion, as a percent (for example, 20%).
+	Progress *string `locationName:"progress" type:"string"`
+
+	// The time this task started.
+	StartTime *time.Time `locationName:"startTime" type:"timestamp" timestampFormat:"iso8601"`
+
+	// The state of the task.
+	State *string `locationName:"state" type:"string" enum:"BundleTaskState"`
+
+	// The Amazon S3 storage locations.
+	Storage *Storage `locationName:"storage" type:"structure"`
+
+	// The time of the most recent update for the task.
+	UpdateTime *time.Time `locationName:"updateTime" type:"timestamp" timestampFormat:"iso8601"`
+
+	metadataBundleTask `json:"-" xml:"-"`
+}
+
+type metadataBundleTask struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s BundleTask) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s BundleTask) GoString() string {
+	return s.String()
+}
+
+// Describes an error for BundleInstance.
+type BundleTaskError struct {
+	// The error code.
+	Code *string `locationName:"code" type:"string"`
+
+	// The error message.
+	Message *string `locationName:"message" type:"string"`
+
+	metadataBundleTaskError `json:"-" xml:"-"`
+}
+
+type metadataBundleTaskError struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s BundleTaskError) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s BundleTaskError) GoString() string {
+	return s.String()
+}
+
+type CancelBundleTaskInput struct {
+	// The ID of the bundle task.
+	BundleID *string `locationName:"BundleId" type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	metadataCancelBundleTaskInput `json:"-" xml:"-"`
+}
+
+type metadataCancelBundleTaskInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CancelBundleTaskInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CancelBundleTaskInput) GoString() string {
+	return s.String()
+}
+
+type CancelBundleTaskOutput struct {
+	// Information about the bundle task.
+	BundleTask *BundleTask `locationName:"bundleInstanceTask" type:"structure"`
+
+	metadataCancelBundleTaskOutput `json:"-" xml:"-"`
+}
+
+type metadataCancelBundleTaskOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CancelBundleTaskOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CancelBundleTaskOutput) GoString() string {
+	return s.String()
+}
+
+type CancelConversionTaskInput struct {
+	// The ID of the conversion task.
+	ConversionTaskID *string `locationName:"conversionTaskId" type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The reason for canceling the conversion task.
+	ReasonMessage *string `locationName:"reasonMessage" type:"string"`
+
+	metadataCancelConversionTaskInput `json:"-" xml:"-"`
+}
+
+type metadataCancelConversionTaskInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CancelConversionTaskInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CancelConversionTaskInput) GoString() string {
+	return s.String()
+}
+
+type CancelConversionTaskOutput struct {
+	metadataCancelConversionTaskOutput `json:"-" xml:"-"`
+}
+
+type metadataCancelConversionTaskOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CancelConversionTaskOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CancelConversionTaskOutput) GoString() string {
+	return s.String()
+}
+
+type CancelExportTaskInput struct {
+	// The ID of the export task. This is the ID returned by CreateInstanceExportTask.
+	ExportTaskID *string `locationName:"exportTaskId" type:"string" required:"true"`
+
+	metadataCancelExportTaskInput `json:"-" xml:"-"`
+}
+
+type metadataCancelExportTaskInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CancelExportTaskInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CancelExportTaskInput) GoString() string {
+	return s.String()
+}
+
+type CancelExportTaskOutput struct {
+	metadataCancelExportTaskOutput `json:"-" xml:"-"`
+}
+
+type metadataCancelExportTaskOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CancelExportTaskOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CancelExportTaskOutput) GoString() string {
+	return s.String()
+}
+
+type CancelImportTaskInput struct {
+	// The reason for canceling the task.
+	CancelReason *string `type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `type:"boolean"`
+
+	// The ID of the import image or import snapshot task to be canceled.
+	ImportTaskID *string `locationName:"ImportTaskId" type:"string"`
+
+	metadataCancelImportTaskInput `json:"-" xml:"-"`
+}
+
+type metadataCancelImportTaskInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CancelImportTaskInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CancelImportTaskInput) GoString() string {
+	return s.String()
+}
+
+type CancelImportTaskOutput struct {
+	// The ID of the task being canceled.
+	ImportTaskID *string `locationName:"importTaskId" type:"string"`
+
+	// The current state of the task being canceled.
+	PreviousState *string `locationName:"previousState" type:"string"`
+
+	// The current state of the task being canceled.
+	State *string `locationName:"state" type:"string"`
+
+	metadataCancelImportTaskOutput `json:"-" xml:"-"`
+}
+
+type metadataCancelImportTaskOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CancelImportTaskOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CancelImportTaskOutput) GoString() string {
+	return s.String()
+}
+
+type CancelReservedInstancesListingInput struct {
+	// The ID of the Reserved Instance listing.
+	ReservedInstancesListingID *string `locationName:"reservedInstancesListingId" type:"string" required:"true"`
+
+	metadataCancelReservedInstancesListingInput `json:"-" xml:"-"`
+}
+
+type metadataCancelReservedInstancesListingInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CancelReservedInstancesListingInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CancelReservedInstancesListingInput) GoString() string {
+	return s.String()
+}
+
+type CancelReservedInstancesListingOutput struct {
+	// The Reserved Instance listing.
+	ReservedInstancesListings []*ReservedInstancesListing `locationName:"reservedInstancesListingsSet" locationNameList:"item" type:"list"`
+
+	metadataCancelReservedInstancesListingOutput `json:"-" xml:"-"`
+}
+
+type metadataCancelReservedInstancesListingOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CancelReservedInstancesListingOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CancelReservedInstancesListingOutput) GoString() string {
+	return s.String()
+}
+
+// Describes a Spot fleet error.
+type CancelSpotFleetRequestsError struct {
+	// The error code.
+	Code *string `locationName:"code" type:"string" required:"true" enum:"CancelBatchErrorCode"`
+
+	// The description for the error code.
+	Message *string `locationName:"message" type:"string" required:"true"`
+
+	metadataCancelSpotFleetRequestsError `json:"-" xml:"-"`
+}
+
+type metadataCancelSpotFleetRequestsError struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CancelSpotFleetRequestsError) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CancelSpotFleetRequestsError) GoString() string {
+	return s.String()
+}
+
+// Describes a Spot fleet request that was not successfully canceled.
+type CancelSpotFleetRequestsErrorItem struct {
+	// The error.
+	Error *CancelSpotFleetRequestsError `locationName:"error" type:"structure" required:"true"`
+
+	// The ID of the Spot fleet request.
+	SpotFleetRequestID *string `locationName:"spotFleetRequestId" type:"string" required:"true"`
+
+	metadataCancelSpotFleetRequestsErrorItem `json:"-" xml:"-"`
+}
+
+type metadataCancelSpotFleetRequestsErrorItem struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CancelSpotFleetRequestsErrorItem) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CancelSpotFleetRequestsErrorItem) GoString() string {
+	return s.String()
+}
+
+// Contains the parameters for CancelSpotFleetRequests.
+type CancelSpotFleetRequestsInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The IDs of the Spot fleet requests.
+	SpotFleetRequestIDs []*string `locationName:"spotFleetRequestId" locationNameList:"item" type:"list" required:"true"`
+
+	// Indicates whether to terminate instances for a Spot fleet request if it is
+	// canceled successfully.
+	TerminateInstances *bool `locationName:"terminateInstances" type:"boolean" required:"true"`
+
+	metadataCancelSpotFleetRequestsInput `json:"-" xml:"-"`
+}
+
+type metadataCancelSpotFleetRequestsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CancelSpotFleetRequestsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CancelSpotFleetRequestsInput) GoString() string {
+	return s.String()
+}
+
+// Contains the output of CancelSpotFleetRequests.
+type CancelSpotFleetRequestsOutput struct {
+	// Information about the Spot fleet requests that are successfully canceled.
+	SuccessfulFleetRequests []*CancelSpotFleetRequestsSuccessItem `locationName:"successfulFleetRequestSet" locationNameList:"item" type:"list"`
+
+	// Information about the Spot fleet requests that are not successfully canceled.
+	UnsuccessfulFleetRequests []*CancelSpotFleetRequestsErrorItem `locationName:"unsuccessfulFleetRequestSet" locationNameList:"item" type:"list"`
+
+	metadataCancelSpotFleetRequestsOutput `json:"-" xml:"-"`
+}
+
+type metadataCancelSpotFleetRequestsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CancelSpotFleetRequestsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CancelSpotFleetRequestsOutput) GoString() string {
+	return s.String()
+}
+
+// Describes a Spot fleet request that was successfully canceled.
+type CancelSpotFleetRequestsSuccessItem struct {
+	// The current state of the Spot fleet request.
+	CurrentSpotFleetRequestState *string `locationName:"currentSpotFleetRequestState" type:"string" required:"true" enum:"BatchState"`
+
+	// The previous state of the Spot fleet request.
+	PreviousSpotFleetRequestState *string `locationName:"previousSpotFleetRequestState" type:"string" required:"true" enum:"BatchState"`
+
+	// The ID of the Spot fleet request.
+	SpotFleetRequestID *string `locationName:"spotFleetRequestId" type:"string" required:"true"`
+
+	metadataCancelSpotFleetRequestsSuccessItem `json:"-" xml:"-"`
+}
+
+type metadataCancelSpotFleetRequestsSuccessItem struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CancelSpotFleetRequestsSuccessItem) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CancelSpotFleetRequestsSuccessItem) GoString() string {
+	return s.String()
+}
+
+// Contains the parameters for CancelSpotInstanceRequests.
+type CancelSpotInstanceRequestsInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more Spot Instance request IDs.
+	SpotInstanceRequestIDs []*string `locationName:"SpotInstanceRequestId" locationNameList:"SpotInstanceRequestId" type:"list" required:"true"`
+
+	metadataCancelSpotInstanceRequestsInput `json:"-" xml:"-"`
+}
+
+type metadataCancelSpotInstanceRequestsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CancelSpotInstanceRequestsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CancelSpotInstanceRequestsInput) GoString() string {
+	return s.String()
+}
+
+// Contains the output of CancelSpotInstanceRequests.
+type CancelSpotInstanceRequestsOutput struct {
+	// One or more Spot Instance requests.
+	CancelledSpotInstanceRequests []*CancelledSpotInstanceRequest `locationName:"spotInstanceRequestSet" locationNameList:"item" type:"list"`
+
+	metadataCancelSpotInstanceRequestsOutput `json:"-" xml:"-"`
+}
+
+type metadataCancelSpotInstanceRequestsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CancelSpotInstanceRequestsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CancelSpotInstanceRequestsOutput) GoString() string {
+	return s.String()
+}
+
+// Describes a request to cancel a Spot Instance.
+type CancelledSpotInstanceRequest struct {
+	// The ID of the Spot Instance request.
+	SpotInstanceRequestID *string `locationName:"spotInstanceRequestId" type:"string"`
+
+	// The state of the Spot Instance request.
+	State *string `locationName:"state" type:"string" enum:"CancelSpotInstanceRequestState"`
+
+	metadataCancelledSpotInstanceRequest `json:"-" xml:"-"`
+}
+
+type metadataCancelledSpotInstanceRequest struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CancelledSpotInstanceRequest) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CancelledSpotInstanceRequest) GoString() string {
+	return s.String()
+}
+
+// Describes a linked EC2-Classic instance.
+type ClassicLinkInstance struct {
+	// A list of security groups.
+	Groups []*GroupIdentifier `locationName:"groupSet" locationNameList:"item" type:"list"`
+
+	// The ID of the instance.
+	InstanceID *string `locationName:"instanceId" type:"string"`
+
+	// Any tags assigned to the instance.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"vpcId" type:"string"`
+
+	metadataClassicLinkInstance `json:"-" xml:"-"`
+}
+
+type metadataClassicLinkInstance struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ClassicLinkInstance) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ClassicLinkInstance) GoString() string {
+	return s.String()
+}
+
+// Describes the client-specific data.
+type ClientData struct {
+	// A user-defined comment about the disk upload.
+	Comment *string `type:"string"`
+
+	// The time that the disk upload ends.
+	UploadEnd *time.Time `type:"timestamp" timestampFormat:"iso8601"`
+
+	// The size of the uploaded disk image, in GiB.
+	UploadSize *float64 `type:"double"`
+
+	// The time that the disk upload starts.
+	UploadStart *time.Time `type:"timestamp" timestampFormat:"iso8601"`
+
+	metadataClientData `json:"-" xml:"-"`
+}
+
+type metadataClientData struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ClientData) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ClientData) GoString() string {
+	return s.String()
+}
+
+type ConfirmProductInstanceInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the instance.
+	InstanceID *string `locationName:"InstanceId" type:"string" required:"true"`
+
+	// The product code. This must be a product code that you own.
+	ProductCode *string `type:"string" required:"true"`
+
+	metadataConfirmProductInstanceInput `json:"-" xml:"-"`
+}
+
+type metadataConfirmProductInstanceInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ConfirmProductInstanceInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ConfirmProductInstanceInput) GoString() string {
+	return s.String()
+}
+
+type ConfirmProductInstanceOutput struct {
+	// The AWS account ID of the instance owner. This is only present if the product
+	// code is attached to the instance.
+	OwnerID *string `locationName:"ownerId" type:"string"`
+
+	// The return value of the request. Returns true if the specified product code
+	// is owned by the requester and associated with the specified instance.
+	Return *bool `locationName:"return" type:"boolean"`
+
+	metadataConfirmProductInstanceOutput `json:"-" xml:"-"`
+}
+
+type metadataConfirmProductInstanceOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ConfirmProductInstanceOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ConfirmProductInstanceOutput) GoString() string {
+	return s.String()
+}
+
+// Describes a conversion task.
+type ConversionTask struct {
+	// The ID of the conversion task.
+	ConversionTaskID *string `locationName:"conversionTaskId" type:"string" required:"true"`
+
+	// The time when the task expires. If the upload isn't complete before the expiration
+	// time, we automatically cancel the task.
+	ExpirationTime *string `locationName:"expirationTime" type:"string"`
+
+	// If the task is for importing an instance, this contains information about
+	// the import instance task.
+	ImportInstance *ImportInstanceTaskDetails `locationName:"importInstance" type:"structure"`
+
+	// If the task is for importing a volume, this contains information about the
+	// import volume task.
+	ImportVolume *ImportVolumeTaskDetails `locationName:"importVolume" type:"structure"`
+
+	// The state of the conversion task.
+	State *string `locationName:"state" type:"string" required:"true" enum:"ConversionTaskState"`
+
+	// The status message related to the conversion task.
+	StatusMessage *string `locationName:"statusMessage" type:"string"`
+
+	// Any tags assigned to the task.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	metadataConversionTask `json:"-" xml:"-"`
+}
+
+type metadataConversionTask struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ConversionTask) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ConversionTask) GoString() string {
+	return s.String()
+}
+
+type CopyImageInput struct {
+	// Unique, case-sensitive identifier you provide to ensure idempotency of the
+	// request. For more information, see How to Ensure Idempotency (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Run_Instance_Idempotency.html)
+	// in the Amazon Elastic Compute Cloud User Guide.
+	ClientToken *string `type:"string"`
+
+	// A description for the new AMI in the destination region.
+	Description *string `type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The name of the new AMI in the destination region.
+	Name *string `type:"string" required:"true"`
+
+	// The ID of the AMI to copy.
+	SourceImageID *string `locationName:"SourceImageId" type:"string" required:"true"`
+
+	// The name of the region that contains the AMI to copy.
+	SourceRegion *string `type:"string" required:"true"`
+
+	metadataCopyImageInput `json:"-" xml:"-"`
+}
+
+type metadataCopyImageInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CopyImageInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CopyImageInput) GoString() string {
+	return s.String()
+}
+
+type CopyImageOutput struct {
+	// The ID of the new AMI.
+	ImageID *string `locationName:"imageId" type:"string"`
+
+	metadataCopyImageOutput `json:"-" xml:"-"`
+}
+
+type metadataCopyImageOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CopyImageOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CopyImageOutput) GoString() string {
+	return s.String()
+}
+
+type CopySnapshotInput struct {
+	// A description for the EBS snapshot.
+	Description *string `type:"string"`
+
+	// The destination region to use in the PresignedUrl parameter of a snapshot
+	// copy operation. This parameter is only valid for specifying the destination
+	// region in a PresignedUrl parameter, where it is required.
+	//
+	//  CopySnapshot sends the snapshot copy to the regional endpoint that you
+	// send the HTTP request to, such as ec2.us-east-1.amazonaws.com (in the AWS
+	// CLI, this is specified with the --region parameter or the default region
+	// in your AWS configuration file).
+	DestinationRegion *string `locationName:"destinationRegion" type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// Specifies whether the destination snapshot should be encrypted. There is
+	// no way to create an unencrypted snapshot copy from an encrypted snapshot;
+	// however, you can encrypt a copy of an unencrypted snapshot with this flag.
+	// The default CMK for EBS is used unless a non-default AWS Key Management Service
+	// (AWS KMS) CMK is specified with KmsKeyId. For more information, see Amazon
+	// EBS Encryption (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html)
+	// in the Amazon Elastic Compute Cloud User Guide.
+	Encrypted *bool `locationName:"encrypted" type:"boolean"`
+
+	// The full ARN of the AWS Key Management Service (AWS KMS) CMK to use when
+	// creating the snapshot copy. This parameter is only required if you want to
+	// use a non-default CMK; if this parameter is not specified, the default CMK
+	// for EBS is used. The ARN contains the arn:aws:kms namespace, followed by
+	// the region of the CMK, the AWS account ID of the CMK owner, the key namespace,
+	// and then the CMK ID. For example, arn:aws:kms:us-east-1:012345678910:key/abcd1234-a123-456a-a12b-a123b4cd56ef.
+	// The specified CMK must exist in the region that the snapshot is being copied
+	// to. If a KmsKeyId is specified, the Encrypted flag must also be set.
+	KMSKeyID *string `locationName:"kmsKeyId" type:"string"`
+
+	// The pre-signed URL that facilitates copying an encrypted snapshot. This parameter
+	// is only required when copying an encrypted snapshot with the Amazon EC2 Query
+	// API; it is available as an optional parameter in all other cases. The PresignedUrl
+	// should use the snapshot source endpoint, the CopySnapshot action, and include
+	// the SourceRegion, SourceSnapshotId, and DestinationRegion parameters. The
+	// PresignedUrl must be signed using AWS Signature Version 4. Because EBS snapshots
+	// are stored in Amazon S3, the signing algorithm for this parameter uses the
+	// same logic that is described in Authenticating Requests by Using Query Parameters
+	// (AWS Signature Version 4) (http://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html)
+	// in the Amazon Simple Storage Service API Reference. An invalid or improperly
+	// signed PresignedUrl will cause the copy operation to fail asynchronously,
+	// and the snapshot will move to an error state.
+	PresignedURL *string `locationName:"presignedUrl" type:"string"`
+
+	// The ID of the region that contains the snapshot to be copied.
+	SourceRegion *string `type:"string" required:"true"`
+
+	// The ID of the EBS snapshot to copy.
+	SourceSnapshotID *string `locationName:"SourceSnapshotId" type:"string" required:"true"`
+
+	metadataCopySnapshotInput `json:"-" xml:"-"`
+}
+
+type metadataCopySnapshotInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CopySnapshotInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CopySnapshotInput) GoString() string {
+	return s.String()
+}
+
+type CopySnapshotOutput struct {
+	// The ID of the new snapshot.
+	SnapshotID *string `locationName:"snapshotId" type:"string"`
+
+	metadataCopySnapshotOutput `json:"-" xml:"-"`
+}
+
+type metadataCopySnapshotOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CopySnapshotOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CopySnapshotOutput) GoString() string {
+	return s.String()
+}
+
+type CreateCustomerGatewayInput struct {
+	// For devices that support BGP, the customer gateway's BGP ASN.
+	//
+	// Default: 65000
+	BGPASN *int64 `locationName:"BgpAsn" type:"integer" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The Internet-routable IP address for the customer gateway's outside interface.
+	// The address must be static.
+	PublicIP *string `locationName:"IpAddress" type:"string" required:"true"`
+
+	// The type of VPN connection that this customer gateway supports (ipsec.1).
+	Type *string `type:"string" required:"true" enum:"GatewayType"`
+
+	metadataCreateCustomerGatewayInput `json:"-" xml:"-"`
+}
+
+type metadataCreateCustomerGatewayInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateCustomerGatewayInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateCustomerGatewayInput) GoString() string {
+	return s.String()
+}
+
+type CreateCustomerGatewayOutput struct {
+	// Information about the customer gateway.
+	CustomerGateway *CustomerGateway `locationName:"customerGateway" type:"structure"`
+
+	metadataCreateCustomerGatewayOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateCustomerGatewayOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateCustomerGatewayOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateCustomerGatewayOutput) GoString() string {
+	return s.String()
+}
+
+type CreateDHCPOptionsInput struct {
+	// A DHCP configuration option.
+	DHCPConfigurations []*NewDHCPConfiguration `locationName:"dhcpConfiguration" locationNameList:"item" type:"list" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	metadataCreateDHCPOptionsInput `json:"-" xml:"-"`
+}
+
+type metadataCreateDHCPOptionsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateDHCPOptionsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateDHCPOptionsInput) GoString() string {
+	return s.String()
+}
+
+type CreateDHCPOptionsOutput struct {
+	// A set of DHCP options.
+	DHCPOptions *DHCPOptions `locationName:"dhcpOptions" type:"structure"`
+
+	metadataCreateDHCPOptionsOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateDHCPOptionsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateDHCPOptionsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateDHCPOptionsOutput) GoString() string {
+	return s.String()
+}
+
+type CreateFlowLogsInput struct {
+	// Unique, case-sensitive identifier you provide to ensure the idempotency of
+	// the request. For more information, see How to Ensure Idempotency (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Run_Instance_Idempotency.html).
+	ClientToken *string `type:"string"`
+
+	// The ARN for the IAM role that's used to post flow logs to a CloudWatch Logs
+	// log group.
+	DeliverLogsPermissionARN *string `locationName:"DeliverLogsPermissionArn" type:"string" required:"true"`
+
+	// The name of the CloudWatch log group.
+	LogGroupName *string `type:"string" required:"true"`
+
+	// One or more subnet, network interface, or VPC IDs.
+	ResourceIDs []*string `locationName:"ResourceId" locationNameList:"item" type:"list" required:"true"`
+
+	// The type of resource on which to create the flow log.
+	ResourceType *string `type:"string" required:"true" enum:"FlowLogsResourceType"`
+
+	// The type of traffic to log.
+	TrafficType *string `type:"string" required:"true" enum:"TrafficType"`
+
+	metadataCreateFlowLogsInput `json:"-" xml:"-"`
+}
+
+type metadataCreateFlowLogsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateFlowLogsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateFlowLogsInput) GoString() string {
+	return s.String()
+}
+
+type CreateFlowLogsOutput struct {
+	// Unique, case-sensitive identifier you provide to ensure the idempotency of
+	// the request.
+	ClientToken *string `locationName:"clientToken" type:"string"`
+
+	// The IDs of the flow logs.
+	FlowLogIDs []*string `locationName:"flowLogIdSet" locationNameList:"item" type:"list"`
+
+	// Information about the flow logs that could not be created successfully.
+	Unsuccessful []*UnsuccessfulItem `locationName:"unsuccessful" locationNameList:"item" type:"list"`
+
+	metadataCreateFlowLogsOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateFlowLogsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateFlowLogsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateFlowLogsOutput) GoString() string {
+	return s.String()
+}
+
+type CreateImageInput struct {
+	// Information about one or more block device mappings.
+	BlockDeviceMappings []*BlockDeviceMapping `locationName:"blockDeviceMapping" locationNameList:"BlockDeviceMapping" type:"list"`
+
+	// A description for the new image.
+	Description *string `locationName:"description" type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the instance.
+	InstanceID *string `locationName:"instanceId" type:"string" required:"true"`
+
+	// A name for the new image.
+	//
+	// Constraints: 3-128 alphanumeric characters, parentheses (()), square brackets
+	// ([]), spaces ( ), periods (.), slashes (/), dashes (-), single quotes ('),
+	// at-signs (@), or underscores(_)
+	Name *string `locationName:"name" type:"string" required:"true"`
+
+	// By default, this parameter is set to false, which means Amazon EC2 attempts
+	// to shut down the instance cleanly before image creation and then reboots
+	// the instance. When the parameter is set to true, Amazon EC2 doesn't shut
+	// down the instance before creating the image. When this option is used, file
+	// system integrity on the created image can't be guaranteed.
+	NoReboot *bool `locationName:"noReboot" type:"boolean"`
+
+	metadataCreateImageInput `json:"-" xml:"-"`
+}
+
+type metadataCreateImageInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateImageInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateImageInput) GoString() string {
+	return s.String()
+}
+
+type CreateImageOutput struct {
+	// The ID of the new AMI.
+	ImageID *string `locationName:"imageId" type:"string"`
+
+	metadataCreateImageOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateImageOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateImageOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateImageOutput) GoString() string {
+	return s.String()
+}
+
+type CreateInstanceExportTaskInput struct {
+	// A description for the conversion task or the resource being exported. The
+	// maximum length is 255 bytes.
+	Description *string `locationName:"description" type:"string"`
+
+	// The format and location for an instance export task.
+	ExportToS3Task *ExportToS3TaskSpecification `locationName:"exportToS3" type:"structure"`
+
+	// The ID of the instance.
+	InstanceID *string `locationName:"instanceId" type:"string" required:"true"`
+
+	// The target virtualization environment.
+	TargetEnvironment *string `locationName:"targetEnvironment" type:"string" enum:"ExportEnvironment"`
+
+	metadataCreateInstanceExportTaskInput `json:"-" xml:"-"`
+}
+
+type metadataCreateInstanceExportTaskInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateInstanceExportTaskInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateInstanceExportTaskInput) GoString() string {
+	return s.String()
+}
+
+type CreateInstanceExportTaskOutput struct {
+	// Information about the instance export task.
+	ExportTask *ExportTask `locationName:"exportTask" type:"structure"`
+
+	metadataCreateInstanceExportTaskOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateInstanceExportTaskOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateInstanceExportTaskOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateInstanceExportTaskOutput) GoString() string {
+	return s.String()
+}
+
+type CreateInternetGatewayInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	metadataCreateInternetGatewayInput `json:"-" xml:"-"`
+}
+
+type metadataCreateInternetGatewayInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateInternetGatewayInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateInternetGatewayInput) GoString() string {
+	return s.String()
+}
+
+type CreateInternetGatewayOutput struct {
+	// Information about the Internet gateway.
+	InternetGateway *InternetGateway `locationName:"internetGateway" type:"structure"`
+
+	metadataCreateInternetGatewayOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateInternetGatewayOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateInternetGatewayOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateInternetGatewayOutput) GoString() string {
+	return s.String()
+}
+
+type CreateKeyPairInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// A unique name for the key pair.
+	//
+	// Constraints: Up to 255 ASCII characters
+	KeyName *string `type:"string" required:"true"`
+
+	metadataCreateKeyPairInput `json:"-" xml:"-"`
+}
+
+type metadataCreateKeyPairInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateKeyPairInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateKeyPairInput) GoString() string {
+	return s.String()
+}
+
+// Describes a key pair.
+type CreateKeyPairOutput struct {
+	// The SHA-1 digest of the DER encoded private key.
+	KeyFingerprint *string `locationName:"keyFingerprint" type:"string"`
+
+	// An unencrypted PEM encoded RSA private key.
+	KeyMaterial *string `locationName:"keyMaterial" type:"string"`
+
+	// The name of the key pair.
+	KeyName *string `locationName:"keyName" type:"string"`
+
+	metadataCreateKeyPairOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateKeyPairOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateKeyPairOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateKeyPairOutput) GoString() string {
+	return s.String()
+}
+
+type CreateNetworkACLEntryInput struct {
+	// The network range to allow or deny, in CIDR notation (for example 172.16.0.0/24).
+	CIDRBlock *string `locationName:"cidrBlock" type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// Indicates whether this is an egress rule (rule is applied to traffic leaving
+	// the subnet).
+	Egress *bool `locationName:"egress" type:"boolean" required:"true"`
+
+	// ICMP protocol: The ICMP type and code. Required if specifying ICMP for the
+	// protocol.
+	ICMPTypeCode *ICMPTypeCode `locationName:"Icmp" type:"structure"`
+
+	// The ID of the network ACL.
+	NetworkACLID *string `locationName:"networkAclId" type:"string" required:"true"`
+
+	// TCP or UDP protocols: The range of ports the rule applies to.
+	PortRange *PortRange `locationName:"portRange" type:"structure"`
+
+	// The protocol. A value of -1 means all protocols.
+	Protocol *string `locationName:"protocol" type:"string" required:"true"`
+
+	// Indicates whether to allow or deny the traffic that matches the rule.
+	RuleAction *string `locationName:"ruleAction" type:"string" required:"true" enum:"RuleAction"`
+
+	// The rule number for the entry (for example, 100). ACL entries are processed
+	// in ascending order by rule number.
+	//
+	// Constraints: Positive integer from 1 to 32766
+	RuleNumber *int64 `locationName:"ruleNumber" type:"integer" required:"true"`
+
+	metadataCreateNetworkACLEntryInput `json:"-" xml:"-"`
+}
+
+type metadataCreateNetworkACLEntryInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateNetworkACLEntryInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateNetworkACLEntryInput) GoString() string {
+	return s.String()
+}
+
+type CreateNetworkACLEntryOutput struct {
+	metadataCreateNetworkACLEntryOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateNetworkACLEntryOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateNetworkACLEntryOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateNetworkACLEntryOutput) GoString() string {
+	return s.String()
+}
+
+type CreateNetworkACLInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"vpcId" type:"string" required:"true"`
+
+	metadataCreateNetworkACLInput `json:"-" xml:"-"`
+}
+
+type metadataCreateNetworkACLInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateNetworkACLInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateNetworkACLInput) GoString() string {
+	return s.String()
+}
+
+type CreateNetworkACLOutput struct {
+	// Information about the network ACL.
+	NetworkACL *NetworkACL `locationName:"networkAcl" type:"structure"`
+
+	metadataCreateNetworkACLOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateNetworkACLOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateNetworkACLOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateNetworkACLOutput) GoString() string {
+	return s.String()
+}
+
+type CreateNetworkInterfaceInput struct {
+	// A description for the network interface.
+	Description *string `locationName:"description" type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The IDs of one or more security groups.
+	Groups []*string `locationName:"SecurityGroupId" locationNameList:"SecurityGroupId" type:"list"`
+
+	// The primary private IP address of the network interface. If you don't specify
+	// an IP address, Amazon EC2 selects one for you from the subnet range. If you
+	// specify an IP address, you cannot indicate any IP addresses specified in
+	// privateIpAddresses as primary (only one IP address can be designated as primary).
+	PrivateIPAddress *string `locationName:"privateIpAddress" type:"string"`
+
+	// One or more private IP addresses.
+	PrivateIPAddresses []*PrivateIPAddressSpecification `locationName:"privateIpAddresses" locationNameList:"item" type:"list"`
+
+	// The number of secondary private IP addresses to assign to a network interface.
+	// When you specify a number of secondary IP addresses, Amazon EC2 selects these
+	// IP addresses within the subnet range. You can't specify this option and specify
+	// more than one private IP address using privateIpAddresses.
+	//
+	// The number of IP addresses you can assign to a network interface varies
+	// by instance type. For more information, see Private IP Addresses Per ENI
+	// Per Instance Type (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html#AvailableIpPerENI)
+	// in the Amazon Elastic Compute Cloud User Guide.
+	SecondaryPrivateIPAddressCount *int64 `locationName:"secondaryPrivateIpAddressCount" type:"integer"`
+
+	// The ID of the subnet to associate with the network interface.
+	SubnetID *string `locationName:"subnetId" type:"string" required:"true"`
+
+	metadataCreateNetworkInterfaceInput `json:"-" xml:"-"`
+}
+
+type metadataCreateNetworkInterfaceInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateNetworkInterfaceInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateNetworkInterfaceInput) GoString() string {
+	return s.String()
+}
+
+type CreateNetworkInterfaceOutput struct {
+	// Information about the network interface.
+	NetworkInterface *NetworkInterface `locationName:"networkInterface" type:"structure"`
+
+	metadataCreateNetworkInterfaceOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateNetworkInterfaceOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateNetworkInterfaceOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateNetworkInterfaceOutput) GoString() string {
+	return s.String()
+}
+
+type CreatePlacementGroupInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// A name for the placement group.
+	//
+	// Constraints: Up to 255 ASCII characters
+	GroupName *string `locationName:"groupName" type:"string" required:"true"`
+
+	// The placement strategy.
+	Strategy *string `locationName:"strategy" type:"string" required:"true" enum:"PlacementStrategy"`
+
+	metadataCreatePlacementGroupInput `json:"-" xml:"-"`
+}
+
+type metadataCreatePlacementGroupInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreatePlacementGroupInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreatePlacementGroupInput) GoString() string {
+	return s.String()
+}
+
+type CreatePlacementGroupOutput struct {
+	metadataCreatePlacementGroupOutput `json:"-" xml:"-"`
+}
+
+type metadataCreatePlacementGroupOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreatePlacementGroupOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreatePlacementGroupOutput) GoString() string {
+	return s.String()
+}
+
+type CreateReservedInstancesListingInput struct {
+	// Unique, case-sensitive identifier you provide to ensure idempotency of your
+	// listings. This helps avoid duplicate listings. For more information, see
+	// Ensuring Idempotency (http://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html).
+	ClientToken *string `locationName:"clientToken" type:"string" required:"true"`
+
+	// The number of instances that are a part of a Reserved Instance account to
+	// be listed in the Reserved Instance Marketplace. This number should be less
+	// than or equal to the instance count associated with the Reserved Instance
+	// ID specified in this call.
+	InstanceCount *int64 `locationName:"instanceCount" type:"integer" required:"true"`
+
+	// A list specifying the price of the Reserved Instance for each month remaining
+	// in the Reserved Instance term.
+	PriceSchedules []*PriceScheduleSpecification `locationName:"priceSchedules" locationNameList:"item" type:"list" required:"true"`
+
+	// The ID of the active Reserved Instance.
+	ReservedInstancesID *string `locationName:"reservedInstancesId" type:"string" required:"true"`
+
+	metadataCreateReservedInstancesListingInput `json:"-" xml:"-"`
+}
+
+type metadataCreateReservedInstancesListingInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateReservedInstancesListingInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateReservedInstancesListingInput) GoString() string {
+	return s.String()
+}
+
+type CreateReservedInstancesListingOutput struct {
+	// Information about the Reserved Instances listing.
+	ReservedInstancesListings []*ReservedInstancesListing `locationName:"reservedInstancesListingsSet" locationNameList:"item" type:"list"`
+
+	metadataCreateReservedInstancesListingOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateReservedInstancesListingOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateReservedInstancesListingOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateReservedInstancesListingOutput) GoString() string {
+	return s.String()
+}
+
+type CreateRouteInput struct {
+	// The CIDR address block used for the destination match. Routing decisions
+	// are based on the most specific match.
+	DestinationCIDRBlock *string `locationName:"destinationCidrBlock" type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of an Internet gateway or virtual private gateway attached to your
+	// VPC.
+	GatewayID *string `locationName:"gatewayId" type:"string"`
+
+	// The ID of a NAT instance in your VPC. The operation fails if you specify
+	// an instance ID unless exactly one network interface is attached.
+	InstanceID *string `locationName:"instanceId" type:"string"`
+
+	// The ID of a network interface.
+	NetworkInterfaceID *string `locationName:"networkInterfaceId" type:"string"`
+
+	// The ID of the route table for the route.
+	RouteTableID *string `locationName:"routeTableId" type:"string" required:"true"`
+
+	// The ID of a VPC peering connection.
+	VPCPeeringConnectionID *string `locationName:"vpcPeeringConnectionId" type:"string"`
+
+	metadataCreateRouteInput `json:"-" xml:"-"`
+}
+
+type metadataCreateRouteInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateRouteInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateRouteInput) GoString() string {
+	return s.String()
+}
+
+type CreateRouteOutput struct {
+	// Returns true if the request succeeds; otherwise, it returns an error.
+	Return *bool `locationName:"return" type:"boolean"`
+
+	metadataCreateRouteOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateRouteOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateRouteOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateRouteOutput) GoString() string {
+	return s.String()
+}
+
+type CreateRouteTableInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"vpcId" type:"string" required:"true"`
+
+	metadataCreateRouteTableInput `json:"-" xml:"-"`
+}
+
+type metadataCreateRouteTableInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateRouteTableInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateRouteTableInput) GoString() string {
+	return s.String()
+}
+
+type CreateRouteTableOutput struct {
+	// Information about the route table.
+	RouteTable *RouteTable `locationName:"routeTable" type:"structure"`
+
+	metadataCreateRouteTableOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateRouteTableOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateRouteTableOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateRouteTableOutput) GoString() string {
+	return s.String()
+}
+
+type CreateSecurityGroupInput struct {
+	// A description for the security group. This is informational only.
+	//
+	// Constraints: Up to 255 characters in length
+	//
+	// Constraints for EC2-Classic: ASCII characters
+	//
+	// Constraints for EC2-VPC: a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=&;{}!$*
+	Description *string `locationName:"GroupDescription" type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The name of the security group.
+	//
+	// Constraints: Up to 255 characters in length
+	//
+	// Constraints for EC2-Classic: ASCII characters
+	//
+	// Constraints for EC2-VPC: a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=&;{}!$*
+	GroupName *string `type:"string" required:"true"`
+
+	// [EC2-VPC] The ID of the VPC. Required for EC2-VPC.
+	VPCID *string `locationName:"VpcId" type:"string"`
+
+	metadataCreateSecurityGroupInput `json:"-" xml:"-"`
+}
+
+type metadataCreateSecurityGroupInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateSecurityGroupInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateSecurityGroupInput) GoString() string {
+	return s.String()
+}
+
+type CreateSecurityGroupOutput struct {
+	// The ID of the security group.
+	GroupID *string `locationName:"groupId" type:"string"`
+
+	metadataCreateSecurityGroupOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateSecurityGroupOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateSecurityGroupOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateSecurityGroupOutput) GoString() string {
+	return s.String()
+}
+
+type CreateSnapshotInput struct {
+	// A description for the snapshot.
+	Description *string `type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the EBS volume.
+	VolumeID *string `locationName:"VolumeId" type:"string" required:"true"`
+
+	metadataCreateSnapshotInput `json:"-" xml:"-"`
+}
+
+type metadataCreateSnapshotInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateSnapshotInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateSnapshotInput) GoString() string {
+	return s.String()
+}
+
+// Contains the parameters for CreateSpotDatafeedSubscription.
+type CreateSpotDatafeedSubscriptionInput struct {
+	// The Amazon S3 bucket in which to store the Spot Instance data feed.
+	Bucket *string `locationName:"bucket" type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// A prefix for the data feed file names.
+	Prefix *string `locationName:"prefix" type:"string"`
+
+	metadataCreateSpotDatafeedSubscriptionInput `json:"-" xml:"-"`
+}
+
+type metadataCreateSpotDatafeedSubscriptionInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateSpotDatafeedSubscriptionInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateSpotDatafeedSubscriptionInput) GoString() string {
+	return s.String()
+}
+
+// Contains the output of CreateSpotDatafeedSubscription.
+type CreateSpotDatafeedSubscriptionOutput struct {
+	// The Spot Instance data feed subscription.
+	SpotDatafeedSubscription *SpotDatafeedSubscription `locationName:"spotDatafeedSubscription" type:"structure"`
+
+	metadataCreateSpotDatafeedSubscriptionOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateSpotDatafeedSubscriptionOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateSpotDatafeedSubscriptionOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateSpotDatafeedSubscriptionOutput) GoString() string {
+	return s.String()
+}
+
+type CreateSubnetInput struct {
+	// The Availability Zone for the subnet.
+	//
+	// Default: Amazon EC2 selects one for you (recommended).
+	AvailabilityZone *string `type:"string"`
+
+	// The network range for the subnet, in CIDR notation. For example, 10.0.0.0/24.
+	CIDRBlock *string `locationName:"CidrBlock" type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"VpcId" type:"string" required:"true"`
+
+	metadataCreateSubnetInput `json:"-" xml:"-"`
+}
+
+type metadataCreateSubnetInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateSubnetInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateSubnetInput) GoString() string {
+	return s.String()
+}
+
+type CreateSubnetOutput struct {
+	// Information about the subnet.
+	Subnet *Subnet `locationName:"subnet" type:"structure"`
+
+	metadataCreateSubnetOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateSubnetOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateSubnetOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateSubnetOutput) GoString() string {
+	return s.String()
+}
+
+type CreateTagsInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The IDs of one or more resources to tag. For example, ami-1a2b3c4d.
+	Resources []*string `locationName:"ResourceId" type:"list" required:"true"`
+
+	// One or more tags. The value parameter is required, but if you don't want
+	// the tag to have a value, specify the parameter with no value, and we set
+	// the value to an empty string.
+	Tags []*Tag `locationName:"Tag" locationNameList:"item" type:"list" required:"true"`
+
+	metadataCreateTagsInput `json:"-" xml:"-"`
+}
+
+type metadataCreateTagsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateTagsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateTagsInput) GoString() string {
+	return s.String()
+}
+
+type CreateTagsOutput struct {
+	metadataCreateTagsOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateTagsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateTagsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateTagsOutput) GoString() string {
+	return s.String()
+}
+
+type CreateVPCEndpointInput struct {
+	// Unique, case-sensitive identifier you provide to ensure the idempotency of
+	// the request. For more information, see How to Ensure Idempotency (http://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html).
+	ClientToken *string `type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `type:"boolean"`
+
+	// A policy to attach to the endpoint that controls access to the service. The
+	// policy must be in valid JSON format. If this parameter is not specified,
+	// we attach a default policy that allows full access to the service.
+	PolicyDocument *string `type:"string"`
+
+	// One or more route table IDs.
+	RouteTableIDs []*string `locationName:"RouteTableId" locationNameList:"item" type:"list"`
+
+	// The AWS service name, in the form com.amazonaws.region.service. To get a
+	// list of available services, use the DescribeVpcEndpointServices request.
+	ServiceName *string `type:"string" required:"true"`
+
+	// The ID of the VPC in which the endpoint will be used.
+	VPCID *string `locationName:"VpcId" type:"string" required:"true"`
+
+	metadataCreateVPCEndpointInput `json:"-" xml:"-"`
+}
+
+type metadataCreateVPCEndpointInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateVPCEndpointInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateVPCEndpointInput) GoString() string {
+	return s.String()
+}
+
+type CreateVPCEndpointOutput struct {
+	// Unique, case-sensitive identifier you provide to ensure the idempotency of
+	// the request.
+	ClientToken *string `locationName:"clientToken" type:"string"`
+
+	// Information about the endpoint.
+	VPCEndpoint *VPCEndpoint `locationName:"vpcEndpoint" type:"structure"`
+
+	metadataCreateVPCEndpointOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateVPCEndpointOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateVPCEndpointOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateVPCEndpointOutput) GoString() string {
+	return s.String()
+}
+
+type CreateVPCInput struct {
+	// The network range for the VPC, in CIDR notation. For example, 10.0.0.0/16.
+	CIDRBlock *string `locationName:"CidrBlock" type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The supported tenancy options for instances launched into the VPC. A value
+	// of default means that instances can be launched with any tenancy; a value
+	// of dedicated means all instances launched into the VPC are launched as dedicated
+	// tenancy instances regardless of the tenancy assigned to the instance at launch.
+	// Dedicated tenancy instances run on single-tenant hardware.
+	//
+	// Default: default
+	InstanceTenancy *string `locationName:"instanceTenancy" type:"string" enum:"Tenancy"`
+
+	metadataCreateVPCInput `json:"-" xml:"-"`
+}
+
+type metadataCreateVPCInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateVPCInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateVPCInput) GoString() string {
+	return s.String()
+}
+
+type CreateVPCOutput struct {
+	// Information about the VPC.
+	VPC *VPC `locationName:"vpc" type:"structure"`
+
+	metadataCreateVPCOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateVPCOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateVPCOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateVPCOutput) GoString() string {
+	return s.String()
+}
+
+type CreateVPCPeeringConnectionInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The AWS account ID of the owner of the peer VPC.
+	//
+	// Default: Your AWS account ID
+	PeerOwnerID *string `locationName:"peerOwnerId" type:"string"`
+
+	// The ID of the VPC with which you are creating the VPC peering connection.
+	PeerVPCID *string `locationName:"peerVpcId" type:"string"`
+
+	// The ID of the requester VPC.
+	VPCID *string `locationName:"vpcId" type:"string"`
+
+	metadataCreateVPCPeeringConnectionInput `json:"-" xml:"-"`
+}
+
+type metadataCreateVPCPeeringConnectionInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateVPCPeeringConnectionInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateVPCPeeringConnectionInput) GoString() string {
+	return s.String()
+}
+
+type CreateVPCPeeringConnectionOutput struct {
+	// Information about the VPC peering connection.
+	VPCPeeringConnection *VPCPeeringConnection `locationName:"vpcPeeringConnection" type:"structure"`
+
+	metadataCreateVPCPeeringConnectionOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateVPCPeeringConnectionOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateVPCPeeringConnectionOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateVPCPeeringConnectionOutput) GoString() string {
+	return s.String()
+}
+
+type CreateVPNConnectionInput struct {
+	// The ID of the customer gateway.
+	CustomerGatewayID *string `locationName:"CustomerGatewayId" type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// Indicates whether the VPN connection requires static routes. If you are creating
+	// a VPN connection for a device that does not support BGP, you must specify
+	// true.
+	//
+	// Default: false
+	Options *VPNConnectionOptionsSpecification `locationName:"options" type:"structure"`
+
+	// The type of VPN connection (ipsec.1).
+	Type *string `type:"string" required:"true"`
+
+	// The ID of the virtual private gateway.
+	VPNGatewayID *string `locationName:"VpnGatewayId" type:"string" required:"true"`
+
+	metadataCreateVPNConnectionInput `json:"-" xml:"-"`
+}
+
+type metadataCreateVPNConnectionInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateVPNConnectionInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateVPNConnectionInput) GoString() string {
+	return s.String()
+}
+
+type CreateVPNConnectionOutput struct {
+	// Information about the VPN connection.
+	VPNConnection *VPNConnection `locationName:"vpnConnection" type:"structure"`
+
+	metadataCreateVPNConnectionOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateVPNConnectionOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateVPNConnectionOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateVPNConnectionOutput) GoString() string {
+	return s.String()
+}
+
+type CreateVPNConnectionRouteInput struct {
+	// The CIDR block associated with the local subnet of the customer network.
+	DestinationCIDRBlock *string `locationName:"DestinationCidrBlock" type:"string" required:"true"`
+
+	// The ID of the VPN connection.
+	VPNConnectionID *string `locationName:"VpnConnectionId" type:"string" required:"true"`
+
+	metadataCreateVPNConnectionRouteInput `json:"-" xml:"-"`
+}
+
+type metadataCreateVPNConnectionRouteInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateVPNConnectionRouteInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateVPNConnectionRouteInput) GoString() string {
+	return s.String()
+}
+
+type CreateVPNConnectionRouteOutput struct {
+	metadataCreateVPNConnectionRouteOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateVPNConnectionRouteOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateVPNConnectionRouteOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateVPNConnectionRouteOutput) GoString() string {
+	return s.String()
+}
+
+type CreateVPNGatewayInput struct {
+	// The Availability Zone for the virtual private gateway.
+	AvailabilityZone *string `type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The type of VPN connection this virtual private gateway supports.
+	Type *string `type:"string" required:"true" enum:"GatewayType"`
+
+	metadataCreateVPNGatewayInput `json:"-" xml:"-"`
+}
+
+type metadataCreateVPNGatewayInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateVPNGatewayInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateVPNGatewayInput) GoString() string {
+	return s.String()
+}
+
+type CreateVPNGatewayOutput struct {
+	// Information about the virtual private gateway.
+	VPNGateway *VPNGateway `locationName:"vpnGateway" type:"structure"`
+
+	metadataCreateVPNGatewayOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateVPNGatewayOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateVPNGatewayOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateVPNGatewayOutput) GoString() string {
+	return s.String()
+}
+
+type CreateVolumeInput struct {
+	// The Availability Zone in which to create the volume. Use DescribeAvailabilityZones
+	// to list the Availability Zones that are currently available to you.
+	AvailabilityZone *string `type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// Specifies whether the volume should be encrypted. Encrypted Amazon EBS volumes
+	// may only be attached to instances that support Amazon EBS encryption. Volumes
+	// that are created from encrypted snapshots are automatically encrypted. There
+	// is no way to create an encrypted volume from an unencrypted snapshot or vice
+	// versa. If your AMI uses encrypted volumes, you can only launch it on supported
+	// instance types. For more information, see Amazon EBS Encryption (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html)
+	// in the Amazon Elastic Compute Cloud User Guide.
+	Encrypted *bool `locationName:"encrypted" type:"boolean"`
+
+	// Only valid for Provisioned IOPS (SSD) volumes. The number of I/O operations
+	// per second (IOPS) to provision for the volume, with a maximum ratio of 30
+	// IOPS/GiB.
+	//
+	// Constraint: Range is 100 to 20000 for Provisioned IOPS (SSD) volumes
+	IOPS *int64 `locationName:"Iops" type:"integer"`
+
+	// The full ARN of the AWS Key Management Service (AWS KMS) customer master
+	// key (CMK) to use when creating the encrypted volume. This parameter is only
+	// required if you want to use a non-default CMK; if this parameter is not specified,
+	// the default CMK for EBS is used. The ARN contains the arn:aws:kms namespace,
+	// followed by the region of the CMK, the AWS account ID of the CMK owner, the
+	// key namespace, and then the CMK ID. For example, arn:aws:kms:us-east-1:012345678910:key/abcd1234-a123-456a-a12b-a123b4cd56ef.
+	// If a KmsKeyId is specified, the Encrypted flag must also be set.
+	KMSKeyID *string `locationName:"KmsKeyId" type:"string"`
+
+	// The size of the volume, in GiBs.
+	//
+	// Constraints: 1-1024 for standard volumes, 1-16384 for gp2 volumes, and 4-16384
+	// for io1 volumes. If you specify a snapshot, the volume size must be equal
+	// to or larger than the snapshot size.
+	//
+	// Default: If you're creating the volume from a snapshot and don't specify
+	// a volume size, the default is the snapshot size.
+	Size *int64 `type:"integer"`
+
+	// The snapshot from which to create the volume.
+	SnapshotID *string `locationName:"SnapshotId" type:"string"`
+
+	// The volume type. This can be gp2 for General Purpose (SSD) volumes, io1 for
+	// Provisioned IOPS (SSD) volumes, or standard for Magnetic volumes.
+	//
+	// Default: standard
+	VolumeType *string `type:"string" enum:"VolumeType"`
+
+	metadataCreateVolumeInput `json:"-" xml:"-"`
+}
+
+type metadataCreateVolumeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateVolumeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateVolumeInput) GoString() string {
+	return s.String()
+}
+
+// Describes the user or group to be added or removed from the permissions for
+// a volume.
+type CreateVolumePermission struct {
+	// The specific group that is to be added or removed from a volume's list of
+	// create volume permissions.
+	Group *string `locationName:"group" type:"string" enum:"PermissionGroup"`
+
+	// The specific AWS account ID that is to be added or removed from a volume's
+	// list of create volume permissions.
+	UserID *string `locationName:"userId" type:"string"`
+
+	metadataCreateVolumePermission `json:"-" xml:"-"`
+}
+
+type metadataCreateVolumePermission struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateVolumePermission) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateVolumePermission) GoString() string {
+	return s.String()
+}
+
+// Describes modifications to the permissions for a volume.
+type CreateVolumePermissionModifications struct {
+	// Adds a specific AWS account ID or group to a volume's list of create volume
+	// permissions.
+	Add []*CreateVolumePermission `locationNameList:"item" type:"list"`
+
+	// Removes a specific AWS account ID or group from a volume's list of create
+	// volume permissions.
+	Remove []*CreateVolumePermission `locationNameList:"item" type:"list"`
+
+	metadataCreateVolumePermissionModifications `json:"-" xml:"-"`
+}
+
+type metadataCreateVolumePermissionModifications struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateVolumePermissionModifications) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateVolumePermissionModifications) GoString() string {
+	return s.String()
+}
+
+// Describes a customer gateway.
+type CustomerGateway struct {
+	// The customer gateway's Border Gateway Protocol (BGP) Autonomous System Number
+	// (ASN).
+	BGPASN *string `locationName:"bgpAsn" type:"string"`
+
+	// The ID of the customer gateway.
+	CustomerGatewayID *string `locationName:"customerGatewayId" type:"string"`
+
+	// The Internet-routable IP address of the customer gateway's outside interface.
+	IPAddress *string `locationName:"ipAddress" type:"string"`
+
+	// The current state of the customer gateway (pending | available | deleting
+	// | deleted).
+	State *string `locationName:"state" type:"string"`
+
+	// Any tags assigned to the customer gateway.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	// The type of VPN connection the customer gateway supports (ipsec.1).
+	Type *string `locationName:"type" type:"string"`
+
+	metadataCustomerGateway `json:"-" xml:"-"`
+}
+
+type metadataCustomerGateway struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s CustomerGateway) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CustomerGateway) GoString() string {
+	return s.String()
+}
+
+// Describes a DHCP configuration option.
+type DHCPConfiguration struct {
+	// The name of a DHCP option.
+	Key *string `locationName:"key" type:"string"`
+
+	// One or more values for the DHCP option.
+	Values []*AttributeValue `locationName:"valueSet" locationNameList:"item" type:"list"`
+
+	metadataDHCPConfiguration `json:"-" xml:"-"`
+}
+
+type metadataDHCPConfiguration struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DHCPConfiguration) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DHCPConfiguration) GoString() string {
+	return s.String()
+}
+
+// Describes a set of DHCP options.
+type DHCPOptions struct {
+	// One or more DHCP options in the set.
+	DHCPConfigurations []*DHCPConfiguration `locationName:"dhcpConfigurationSet" locationNameList:"item" type:"list"`
+
+	// The ID of the set of DHCP options.
+	DHCPOptionsID *string `locationName:"dhcpOptionsId" type:"string"`
+
+	// Any tags assigned to the DHCP options set.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	metadataDHCPOptions `json:"-" xml:"-"`
+}
+
+type metadataDHCPOptions struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DHCPOptions) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DHCPOptions) GoString() string {
+	return s.String()
+}
+
+type DeleteCustomerGatewayInput struct {
+	// The ID of the customer gateway.
+	CustomerGatewayID *string `locationName:"CustomerGatewayId" type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	metadataDeleteCustomerGatewayInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteCustomerGatewayInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteCustomerGatewayInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteCustomerGatewayInput) GoString() string {
+	return s.String()
+}
+
+type DeleteCustomerGatewayOutput struct {
+	metadataDeleteCustomerGatewayOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteCustomerGatewayOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteCustomerGatewayOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteCustomerGatewayOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteDHCPOptionsInput struct {
+	// The ID of the DHCP options set.
+	DHCPOptionsID *string `locationName:"DhcpOptionsId" type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	metadataDeleteDHCPOptionsInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteDHCPOptionsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteDHCPOptionsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteDHCPOptionsInput) GoString() string {
+	return s.String()
+}
+
+type DeleteDHCPOptionsOutput struct {
+	metadataDeleteDHCPOptionsOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteDHCPOptionsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteDHCPOptionsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteDHCPOptionsOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteFlowLogsInput struct {
+	// One or more flow log IDs.
+	FlowLogIDs []*string `locationName:"FlowLogId" locationNameList:"item" type:"list" required:"true"`
+
+	metadataDeleteFlowLogsInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteFlowLogsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteFlowLogsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteFlowLogsInput) GoString() string {
+	return s.String()
+}
+
+type DeleteFlowLogsOutput struct {
+	// Information about the flow logs that could not be deleted successfully.
+	Unsuccessful []*UnsuccessfulItem `locationName:"unsuccessful" locationNameList:"item" type:"list"`
+
+	metadataDeleteFlowLogsOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteFlowLogsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteFlowLogsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteFlowLogsOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteInternetGatewayInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the Internet gateway.
+	InternetGatewayID *string `locationName:"internetGatewayId" type:"string" required:"true"`
+
+	metadataDeleteInternetGatewayInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteInternetGatewayInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteInternetGatewayInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteInternetGatewayInput) GoString() string {
+	return s.String()
+}
+
+type DeleteInternetGatewayOutput struct {
+	metadataDeleteInternetGatewayOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteInternetGatewayOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteInternetGatewayOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteInternetGatewayOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteKeyPairInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The name of the key pair.
+	KeyName *string `type:"string" required:"true"`
+
+	metadataDeleteKeyPairInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteKeyPairInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteKeyPairInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteKeyPairInput) GoString() string {
+	return s.String()
+}
+
+type DeleteKeyPairOutput struct {
+	metadataDeleteKeyPairOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteKeyPairOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteKeyPairOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteKeyPairOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteNetworkACLEntryInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// Indicates whether the rule is an egress rule.
+	Egress *bool `locationName:"egress" type:"boolean" required:"true"`
+
+	// The ID of the network ACL.
+	NetworkACLID *string `locationName:"networkAclId" type:"string" required:"true"`
+
+	// The rule number of the entry to delete.
+	RuleNumber *int64 `locationName:"ruleNumber" type:"integer" required:"true"`
+
+	metadataDeleteNetworkACLEntryInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteNetworkACLEntryInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteNetworkACLEntryInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteNetworkACLEntryInput) GoString() string {
+	return s.String()
+}
+
+type DeleteNetworkACLEntryOutput struct {
+	metadataDeleteNetworkACLEntryOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteNetworkACLEntryOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteNetworkACLEntryOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteNetworkACLEntryOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteNetworkACLInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the network ACL.
+	NetworkACLID *string `locationName:"networkAclId" type:"string" required:"true"`
+
+	metadataDeleteNetworkACLInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteNetworkACLInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteNetworkACLInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteNetworkACLInput) GoString() string {
+	return s.String()
+}
+
+type DeleteNetworkACLOutput struct {
+	metadataDeleteNetworkACLOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteNetworkACLOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteNetworkACLOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteNetworkACLOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteNetworkInterfaceInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the network interface.
+	NetworkInterfaceID *string `locationName:"networkInterfaceId" type:"string" required:"true"`
+
+	metadataDeleteNetworkInterfaceInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteNetworkInterfaceInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteNetworkInterfaceInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteNetworkInterfaceInput) GoString() string {
+	return s.String()
+}
+
+type DeleteNetworkInterfaceOutput struct {
+	metadataDeleteNetworkInterfaceOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteNetworkInterfaceOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteNetworkInterfaceOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteNetworkInterfaceOutput) GoString() string {
+	return s.String()
+}
+
+type DeletePlacementGroupInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The name of the placement group.
+	GroupName *string `locationName:"groupName" type:"string" required:"true"`
+
+	metadataDeletePlacementGroupInput `json:"-" xml:"-"`
+}
+
+type metadataDeletePlacementGroupInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeletePlacementGroupInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeletePlacementGroupInput) GoString() string {
+	return s.String()
+}
+
+type DeletePlacementGroupOutput struct {
+	metadataDeletePlacementGroupOutput `json:"-" xml:"-"`
+}
+
+type metadataDeletePlacementGroupOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeletePlacementGroupOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeletePlacementGroupOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteRouteInput struct {
+	// The CIDR range for the route. The value you specify must match the CIDR for
+	// the route exactly.
+	DestinationCIDRBlock *string `locationName:"destinationCidrBlock" type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the route table.
+	RouteTableID *string `locationName:"routeTableId" type:"string" required:"true"`
+
+	metadataDeleteRouteInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteRouteInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteRouteInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteRouteInput) GoString() string {
+	return s.String()
+}
+
+type DeleteRouteOutput struct {
+	metadataDeleteRouteOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteRouteOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteRouteOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteRouteOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteRouteTableInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the route table.
+	RouteTableID *string `locationName:"routeTableId" type:"string" required:"true"`
+
+	metadataDeleteRouteTableInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteRouteTableInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteRouteTableInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteRouteTableInput) GoString() string {
+	return s.String()
+}
+
+type DeleteRouteTableOutput struct {
+	metadataDeleteRouteTableOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteRouteTableOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteRouteTableOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteRouteTableOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteSecurityGroupInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the security group. Required for a nondefault VPC.
+	GroupID *string `locationName:"GroupId" type:"string"`
+
+	// [EC2-Classic, default VPC] The name of the security group. You can specify
+	// either the security group name or the security group ID.
+	GroupName *string `type:"string"`
+
+	metadataDeleteSecurityGroupInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteSecurityGroupInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteSecurityGroupInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteSecurityGroupInput) GoString() string {
+	return s.String()
+}
+
+type DeleteSecurityGroupOutput struct {
+	metadataDeleteSecurityGroupOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteSecurityGroupOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteSecurityGroupOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteSecurityGroupOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteSnapshotInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the EBS snapshot.
+	SnapshotID *string `locationName:"SnapshotId" type:"string" required:"true"`
+
+	metadataDeleteSnapshotInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteSnapshotInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteSnapshotInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteSnapshotInput) GoString() string {
+	return s.String()
+}
+
+type DeleteSnapshotOutput struct {
+	metadataDeleteSnapshotOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteSnapshotOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteSnapshotOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteSnapshotOutput) GoString() string {
+	return s.String()
+}
+
+// Contains the parameters for DeleteSpotDatafeedSubscription.
+type DeleteSpotDatafeedSubscriptionInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	metadataDeleteSpotDatafeedSubscriptionInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteSpotDatafeedSubscriptionInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteSpotDatafeedSubscriptionInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteSpotDatafeedSubscriptionInput) GoString() string {
+	return s.String()
+}
+
+type DeleteSpotDatafeedSubscriptionOutput struct {
+	metadataDeleteSpotDatafeedSubscriptionOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteSpotDatafeedSubscriptionOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteSpotDatafeedSubscriptionOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteSpotDatafeedSubscriptionOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteSubnetInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the subnet.
+	SubnetID *string `locationName:"SubnetId" type:"string" required:"true"`
+
+	metadataDeleteSubnetInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteSubnetInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteSubnetInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteSubnetInput) GoString() string {
+	return s.String()
+}
+
+type DeleteSubnetOutput struct {
+	metadataDeleteSubnetOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteSubnetOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteSubnetOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteSubnetOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteTagsInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the resource. For example, ami-1a2b3c4d. You can specify more than
+	// one resource ID.
+	Resources []*string `locationName:"resourceId" type:"list" required:"true"`
+
+	// One or more tags to delete. If you omit the value parameter, we delete the
+	// tag regardless of its value. If you specify this parameter with an empty
+	// string as the value, we delete the key only if its value is an empty string.
+	Tags []*Tag `locationName:"tag" locationNameList:"item" type:"list"`
+
+	metadataDeleteTagsInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteTagsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteTagsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteTagsInput) GoString() string {
+	return s.String()
+}
+
+type DeleteTagsOutput struct {
+	metadataDeleteTagsOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteTagsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteTagsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteTagsOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteVPCEndpointsInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `type:"boolean"`
+
+	// One or more endpoint IDs.
+	VPCEndpointIDs []*string `locationName:"VpcEndpointId" locationNameList:"item" type:"list" required:"true"`
+
+	metadataDeleteVPCEndpointsInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteVPCEndpointsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteVPCEndpointsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteVPCEndpointsInput) GoString() string {
+	return s.String()
+}
+
+type DeleteVPCEndpointsOutput struct {
+	// Information about the endpoints that were not successfully deleted.
+	Unsuccessful []*UnsuccessfulItem `locationName:"unsuccessful" locationNameList:"item" type:"list"`
+
+	metadataDeleteVPCEndpointsOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteVPCEndpointsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteVPCEndpointsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteVPCEndpointsOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteVPCInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"VpcId" type:"string" required:"true"`
+
+	metadataDeleteVPCInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteVPCInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteVPCInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteVPCInput) GoString() string {
+	return s.String()
+}
+
+type DeleteVPCOutput struct {
+	metadataDeleteVPCOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteVPCOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteVPCOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteVPCOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteVPCPeeringConnectionInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the VPC peering connection.
+	VPCPeeringConnectionID *string `locationName:"vpcPeeringConnectionId" type:"string" required:"true"`
+
+	metadataDeleteVPCPeeringConnectionInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteVPCPeeringConnectionInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteVPCPeeringConnectionInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteVPCPeeringConnectionInput) GoString() string {
+	return s.String()
+}
+
+type DeleteVPCPeeringConnectionOutput struct {
+	// Returns true if the request succeeds; otherwise, it returns an error.
+	Return *bool `locationName:"return" type:"boolean"`
+
+	metadataDeleteVPCPeeringConnectionOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteVPCPeeringConnectionOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteVPCPeeringConnectionOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteVPCPeeringConnectionOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteVPNConnectionInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the VPN connection.
+	VPNConnectionID *string `locationName:"VpnConnectionId" type:"string" required:"true"`
+
+	metadataDeleteVPNConnectionInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteVPNConnectionInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteVPNConnectionInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteVPNConnectionInput) GoString() string {
+	return s.String()
+}
+
+type DeleteVPNConnectionOutput struct {
+	metadataDeleteVPNConnectionOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteVPNConnectionOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteVPNConnectionOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteVPNConnectionOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteVPNConnectionRouteInput struct {
+	// The CIDR block associated with the local subnet of the customer network.
+	DestinationCIDRBlock *string `locationName:"DestinationCidrBlock" type:"string" required:"true"`
+
+	// The ID of the VPN connection.
+	VPNConnectionID *string `locationName:"VpnConnectionId" type:"string" required:"true"`
+
+	metadataDeleteVPNConnectionRouteInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteVPNConnectionRouteInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteVPNConnectionRouteInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteVPNConnectionRouteInput) GoString() string {
+	return s.String()
+}
+
+type DeleteVPNConnectionRouteOutput struct {
+	metadataDeleteVPNConnectionRouteOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteVPNConnectionRouteOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteVPNConnectionRouteOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteVPNConnectionRouteOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteVPNGatewayInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the virtual private gateway.
+	VPNGatewayID *string `locationName:"VpnGatewayId" type:"string" required:"true"`
+
+	metadataDeleteVPNGatewayInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteVPNGatewayInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteVPNGatewayInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteVPNGatewayInput) GoString() string {
+	return s.String()
+}
+
+type DeleteVPNGatewayOutput struct {
+	metadataDeleteVPNGatewayOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteVPNGatewayOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteVPNGatewayOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteVPNGatewayOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteVolumeInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the volume.
+	VolumeID *string `locationName:"VolumeId" type:"string" required:"true"`
+
+	metadataDeleteVolumeInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteVolumeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteVolumeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteVolumeInput) GoString() string {
+	return s.String()
+}
+
+type DeleteVolumeOutput struct {
+	metadataDeleteVolumeOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteVolumeOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteVolumeOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteVolumeOutput) GoString() string {
+	return s.String()
+}
+
+type DeregisterImageInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the AMI.
+	ImageID *string `locationName:"ImageId" type:"string" required:"true"`
+
+	metadataDeregisterImageInput `json:"-" xml:"-"`
+}
+
+type metadataDeregisterImageInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeregisterImageInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeregisterImageInput) GoString() string {
+	return s.String()
+}
+
+type DeregisterImageOutput struct {
+	metadataDeregisterImageOutput `json:"-" xml:"-"`
+}
+
+type metadataDeregisterImageOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeregisterImageOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeregisterImageOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeAccountAttributesInput struct {
+	// One or more account attribute names.
+	AttributeNames []*string `locationName:"attributeName" locationNameList:"attributeName" type:"list"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	metadataDescribeAccountAttributesInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeAccountAttributesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeAccountAttributesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeAccountAttributesInput) GoString() string {
+	return s.String()
+}
+
+type DescribeAccountAttributesOutput struct {
+	// Information about one or more account attributes.
+	AccountAttributes []*AccountAttribute `locationName:"accountAttributeSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeAccountAttributesOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeAccountAttributesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeAccountAttributesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeAccountAttributesOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeAddressesInput struct {
+	// [EC2-VPC] One or more allocation IDs.
+	//
+	// Default: Describes all your Elastic IP addresses.
+	AllocationIDs []*string `locationName:"AllocationId" locationNameList:"AllocationId" type:"list"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters. Filter names and values are case-sensitive.
+	//
+	//   allocation-id - [EC2-VPC] The allocation ID for the address.
+	//
+	//   association-id - [EC2-VPC] The association ID for the address.
+	//
+	//   domain - Indicates whether the address is for use in EC2-Classic (standard)
+	// or in a VPC (vpc).
+	//
+	//   instance-id - The ID of the instance the address is associated with, if
+	// any.
+	//
+	//   network-interface-id - [EC2-VPC] The ID of the network interface that
+	// the address is associated with, if any.
+	//
+	//   network-interface-owner-id - The AWS account ID of the owner.
+	//
+	//   private-ip-address - [EC2-VPC] The private IP address associated with
+	// the Elastic IP address.
+	//
+	//   public-ip - The Elastic IP address.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// [EC2-Classic] One or more Elastic IP addresses.
+	//
+	// Default: Describes all your Elastic IP addresses.
+	PublicIPs []*string `locationName:"PublicIp" locationNameList:"PublicIp" type:"list"`
+
+	metadataDescribeAddressesInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeAddressesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeAddressesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeAddressesInput) GoString() string {
+	return s.String()
+}
+
+type DescribeAddressesOutput struct {
+	// Information about one or more Elastic IP addresses.
+	Addresses []*Address `locationName:"addressesSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeAddressesOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeAddressesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeAddressesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeAddressesOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeAvailabilityZonesInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   message - Information about the Availability Zone.
+	//
+	//   region-name - The name of the region for the Availability Zone (for example,
+	// us-east-1).
+	//
+	//   state - The state of the Availability Zone (available | impaired | unavailable).
+	//
+	//   zone-name - The name of the Availability Zone (for example, us-east-1a).
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// The names of one or more Availability Zones.
+	ZoneNames []*string `locationName:"ZoneName" locationNameList:"ZoneName" type:"list"`
+
+	metadataDescribeAvailabilityZonesInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeAvailabilityZonesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeAvailabilityZonesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeAvailabilityZonesInput) GoString() string {
+	return s.String()
+}
+
+type DescribeAvailabilityZonesOutput struct {
+	// Information about one or more Availability Zones.
+	AvailabilityZones []*AvailabilityZone `locationName:"availabilityZoneInfo" locationNameList:"item" type:"list"`
+
+	metadataDescribeAvailabilityZonesOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeAvailabilityZonesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeAvailabilityZonesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeAvailabilityZonesOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeBundleTasksInput struct {
+	// One or more bundle task IDs.
+	//
+	// Default: Describes all your bundle tasks.
+	BundleIDs []*string `locationName:"BundleId" locationNameList:"BundleId" type:"list"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   bundle-id - The ID of the bundle task.
+	//
+	//   error-code - If the task failed, the error code returned.
+	//
+	//   error-message - If the task failed, the error message returned.
+	//
+	//   instance-id - The ID of the instance.
+	//
+	//   progress - The level of task completion, as a percentage (for example,
+	// 20%).
+	//
+	//   s3-bucket - The Amazon S3 bucket to store the AMI.
+	//
+	//   s3-prefix - The beginning of the AMI name.
+	//
+	//   start-time - The time the task started (for example, 2013-09-15T17:15:20.000Z).
+	//
+	//   state - The state of the task (pending | waiting-for-shutdown | bundling
+	// | storing | cancelling | complete | failed).
+	//
+	//   update-time - The time of the most recent update for the task.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	metadataDescribeBundleTasksInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeBundleTasksInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeBundleTasksInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeBundleTasksInput) GoString() string {
+	return s.String()
+}
+
+type DescribeBundleTasksOutput struct {
+	// Information about one or more bundle tasks.
+	BundleTasks []*BundleTask `locationName:"bundleInstanceTasksSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeBundleTasksOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeBundleTasksOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeBundleTasksOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeBundleTasksOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeClassicLinkInstancesInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//  group-id - The ID of a VPC security group that's associated with the instance.
+	//
+	//  instance-id - The ID of the instance.
+	//
+	//   tag:key=value - The key/value combination of a tag assigned to the resource.
+	//
+	//   tag-key - The key of a tag assigned to the resource. This filter is independent
+	// of the tag-value filter. For example, if you use both the filter "tag-key=Purpose"
+	// and the filter "tag-value=X", you get any resources assigned both the tag
+	// key Purpose (regardless of what the tag's value is), and the tag value X
+	// (regardless of what the tag's key is). If you want to list only resources
+	// where Purpose is X, see the tag:key=value filter.
+	//
+	//   tag-value - The value of a tag assigned to the resource. This filter is
+	// independent of the tag-key filter.
+	//
+	//   vpc-id - The ID of the VPC that the instance is linked to.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// One or more instance IDs. Must be instances linked to a VPC through ClassicLink.
+	InstanceIDs []*string `locationName:"InstanceId" locationNameList:"InstanceId" type:"list"`
+
+	// The maximum number of results to return for the request in a single page.
+	// The remaining results of the initial request can be seen by sending another
+	// request with the returned NextToken value. This value can be between 5 and
+	// 1000; if MaxResults is given a value larger than 1000, only 1000 results
+	// are returned. You cannot specify this parameter and the instance IDs parameter
+	// in the same request.
+	//
+	// Constraint: If the value is greater than 1000, we return only 1000 items.
+	MaxResults *int64 `locationName:"maxResults" type:"integer"`
+
+	// The token to retrieve the next page of results.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	metadataDescribeClassicLinkInstancesInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeClassicLinkInstancesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeClassicLinkInstancesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeClassicLinkInstancesInput) GoString() string {
+	return s.String()
+}
+
+type DescribeClassicLinkInstancesOutput struct {
+	// Information about one or more linked EC2-Classic instances.
+	Instances []*ClassicLinkInstance `locationName:"instancesSet" locationNameList:"item" type:"list"`
+
+	// The token to use to retrieve the next page of results. This value is null
+	// when there are no more results to return.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	metadataDescribeClassicLinkInstancesOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeClassicLinkInstancesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeClassicLinkInstancesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeClassicLinkInstancesOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeConversionTasksInput struct {
+	// One or more conversion task IDs.
+	ConversionTaskIDs []*string `locationName:"conversionTaskId" locationNameList:"item" type:"list"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	Filters []*Filter `locationName:"filter" locationNameList:"Filter" type:"list"`
+
+	metadataDescribeConversionTasksInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeConversionTasksInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeConversionTasksInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeConversionTasksInput) GoString() string {
+	return s.String()
+}
+
+type DescribeConversionTasksOutput struct {
+	// Information about the conversion tasks.
+	ConversionTasks []*ConversionTask `locationName:"conversionTasks" locationNameList:"item" type:"list"`
+
+	metadataDescribeConversionTasksOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeConversionTasksOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeConversionTasksOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeConversionTasksOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeCustomerGatewaysInput struct {
+	// One or more customer gateway IDs.
+	//
+	// Default: Describes all your customer gateways.
+	CustomerGatewayIDs []*string `locationName:"CustomerGatewayId" locationNameList:"CustomerGatewayId" type:"list"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   bgp-asn - The customer gateway's Border Gateway Protocol (BGP) Autonomous
+	// System Number (ASN).
+	//
+	//   customer-gateway-id - The ID of the customer gateway.
+	//
+	//   ip-address - The IP address of the customer gateway's Internet-routable
+	// external interface.
+	//
+	//   state - The state of the customer gateway (pending | available | deleting
+	// | deleted).
+	//
+	//   type - The type of customer gateway. Currently, the only supported type
+	// is ipsec.1.
+	//
+	//   tag:key=value - The key/value combination of a tag assigned to the resource.
+	//
+	//   tag-key - The key of a tag assigned to the resource. This filter is independent
+	// of the tag-value filter. For example, if you use both the filter "tag-key=Purpose"
+	// and the filter "tag-value=X", you get any resources assigned both the tag
+	// key Purpose (regardless of what the tag's value is), and the tag value X
+	// (regardless of what the tag's key is). If you want to list only resources
+	// where Purpose is X, see the tag:key=value filter.
+	//
+	//   tag-value - The value of a tag assigned to the resource. This filter is
+	// independent of the tag-key filter.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	metadataDescribeCustomerGatewaysInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeCustomerGatewaysInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeCustomerGatewaysInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeCustomerGatewaysInput) GoString() string {
+	return s.String()
+}
+
+type DescribeCustomerGatewaysOutput struct {
+	// Information about one or more customer gateways.
+	CustomerGateways []*CustomerGateway `locationName:"customerGatewaySet" locationNameList:"item" type:"list"`
+
+	metadataDescribeCustomerGatewaysOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeCustomerGatewaysOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeCustomerGatewaysOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeCustomerGatewaysOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeDHCPOptionsInput struct {
+	// The IDs of one or more DHCP options sets.
+	//
+	// Default: Describes all your DHCP options sets.
+	DHCPOptionsIDs []*string `locationName:"DhcpOptionsId" locationNameList:"DhcpOptionsId" type:"list"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   dhcp-options-id - The ID of a set of DHCP options.
+	//
+	//   key - The key for one of the options (for example, domain-name).
+	//
+	//   value - The value for one of the options.
+	//
+	//   tag:key=value - The key/value combination of a tag assigned to the resource.
+	//
+	//   tag-key - The key of a tag assigned to the resource. This filter is independent
+	// of the tag-value filter. For example, if you use both the filter "tag-key=Purpose"
+	// and the filter "tag-value=X", you get any resources assigned both the tag
+	// key Purpose (regardless of what the tag's value is), and the tag value X
+	// (regardless of what the tag's key is). If you want to list only resources
+	// where Purpose is X, see the tag:key=value filter.
+	//
+	//   tag-value - The value of a tag assigned to the resource. This filter is
+	// independent of the tag-key filter.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	metadataDescribeDHCPOptionsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeDHCPOptionsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeDHCPOptionsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeDHCPOptionsInput) GoString() string {
+	return s.String()
+}
+
+type DescribeDHCPOptionsOutput struct {
+	// Information about one or more DHCP options sets.
+	DHCPOptions []*DHCPOptions `locationName:"dhcpOptionsSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeDHCPOptionsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeDHCPOptionsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeDHCPOptionsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeDHCPOptionsOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeExportTasksInput struct {
+	// One or more export task IDs.
+	ExportTaskIDs []*string `locationName:"exportTaskId" locationNameList:"ExportTaskId" type:"list"`
+
+	metadataDescribeExportTasksInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeExportTasksInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeExportTasksInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeExportTasksInput) GoString() string {
+	return s.String()
+}
+
+type DescribeExportTasksOutput struct {
+	// Information about the export tasks.
+	ExportTasks []*ExportTask `locationName:"exportTaskSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeExportTasksOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeExportTasksOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeExportTasksOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeExportTasksOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeFlowLogsInput struct {
+	// One or more filters.
+	//
+	//  deliver-log-status - The status of the logs delivery (SUCCESS | FAILED).
+	//
+	// flow-log-id - The ID of the flow log.
+	//
+	// log-group-name - The name of the log group.
+	//
+	// resource-id - The ID of the VPC, subnet, or network interface.
+	//
+	// traffic-type - The type of traffic (ACCEPT | REJECT | ALL)
+	Filter []*Filter `locationNameList:"Filter" type:"list"`
+
+	// One or more flow log IDs.
+	FlowLogIDs []*string `locationName:"FlowLogId" locationNameList:"item" type:"list"`
+
+	// The maximum number of results to return for the request in a single page.
+	// The remaining results can be seen by sending another request with the returned
+	// NextToken value. This value can be between 5 and 1000; if MaxResults is given
+	// a value larger than 1000, only 1000 results are returned. You cannot specify
+	// this parameter and the flow log IDs parameter in the same request.
+	MaxResults *int64 `type:"integer"`
+
+	// The token to retrieve the next page of results.
+	NextToken *string `type:"string"`
+
+	metadataDescribeFlowLogsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeFlowLogsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeFlowLogsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeFlowLogsInput) GoString() string {
+	return s.String()
+}
+
+type DescribeFlowLogsOutput struct {
+	// Information about the flow logs.
+	FlowLogs []*FlowLog `locationName:"flowLogSet" locationNameList:"item" type:"list"`
+
+	// The token to use to retrieve the next page of results. This value is null
+	// when there are no more results to return.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	metadataDescribeFlowLogsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeFlowLogsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeFlowLogsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeFlowLogsOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeImageAttributeInput struct {
+	// The AMI attribute.
+	//
+	// Note: Depending on your account privileges, the blockDeviceMapping attribute
+	// may return a Client.AuthFailure error. If this happens, use DescribeImages
+	// to get information about the block device mapping for the AMI.
+	Attribute *string `type:"string" required:"true" enum:"ImageAttributeName"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the AMI.
+	ImageID *string `locationName:"ImageId" type:"string" required:"true"`
+
+	metadataDescribeImageAttributeInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeImageAttributeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeImageAttributeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeImageAttributeInput) GoString() string {
+	return s.String()
+}
+
+// Describes an image attribute.
+type DescribeImageAttributeOutput struct {
+	// One or more block device mapping entries.
+	BlockDeviceMappings []*BlockDeviceMapping `locationName:"blockDeviceMapping" locationNameList:"item" type:"list"`
+
+	// A description for the AMI.
+	Description *AttributeValue `locationName:"description" type:"structure"`
+
+	// The ID of the AMI.
+	ImageID *string `locationName:"imageId" type:"string"`
+
+	// The kernel ID.
+	KernelID *AttributeValue `locationName:"kernel" type:"structure"`
+
+	// One or more launch permissions.
+	LaunchPermissions []*LaunchPermission `locationName:"launchPermission" locationNameList:"item" type:"list"`
+
+	// One or more product codes.
+	ProductCodes []*ProductCode `locationName:"productCodes" locationNameList:"item" type:"list"`
+
+	// The RAM disk ID.
+	RAMDiskID *AttributeValue `locationName:"ramdisk" type:"structure"`
+
+	// The value to use for a resource attribute.
+	SRIOVNetSupport *AttributeValue `locationName:"sriovNetSupport" type:"structure"`
+
+	metadataDescribeImageAttributeOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeImageAttributeOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeImageAttributeOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeImageAttributeOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeImagesInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// Scopes the images by users with explicit launch permissions. Specify an AWS
+	// account ID, self (the sender of the request), or all (public AMIs).
+	ExecutableUsers []*string `locationName:"ExecutableBy" locationNameList:"ExecutableBy" type:"list"`
+
+	// One or more filters.
+	//
+	//   architecture - The image architecture (i386 | x86_64).
+	//
+	//   block-device-mapping.delete-on-termination - A Boolean value that indicates
+	// whether the Amazon EBS volume is deleted on instance termination.
+	//
+	//   block-device-mapping.device-name - The device name for the EBS volume
+	// (for example, /dev/sdh).
+	//
+	//   block-device-mapping.snapshot-id - The ID of the snapshot used for the
+	// EBS volume.
+	//
+	//   block-device-mapping.volume-size - The volume size of the EBS volume,
+	// in GiB.
+	//
+	//   block-device-mapping.volume-type - The volume type of the EBS volume (gp2
+	// | standard | io1).
+	//
+	//   description - The description of the image (provided during image creation).
+	//
+	//   hypervisor - The hypervisor type (ovm | xen).
+	//
+	//   image-id - The ID of the image.
+	//
+	//   image-type - The image type (machine | kernel | ramdisk).
+	//
+	//   is-public - A Boolean that indicates whether the image is public.
+	//
+	//   kernel-id - The kernel ID.
+	//
+	//   manifest-location - The location of the image manifest.
+	//
+	//   name - The name of the AMI (provided during image creation).
+	//
+	//   owner-alias - The AWS account alias (for example, amazon).
+	//
+	//   owner-id - The AWS account ID of the image owner.
+	//
+	//   platform - The platform. To only list Windows-based AMIs, use windows.
+	//
+	//   product-code - The product code.
+	//
+	//   product-code.type - The type of the product code (devpay | marketplace).
+	//
+	//   ramdisk-id - The RAM disk ID.
+	//
+	//   root-device-name - The name of the root device volume (for example, /dev/sda1).
+	//
+	//   root-device-type - The type of the root device volume (ebs | instance-store).
+	//
+	//   state - The state of the image (available | pending | failed).
+	//
+	//   state-reason-code - The reason code for the state change.
+	//
+	//   state-reason-message - The message for the state change.
+	//
+	//   tag:key=value - The key/value combination of a tag assigned to the resource.
+	//
+	//   tag-key - The key of a tag assigned to the resource. This filter is independent
+	// of the tag-value filter. For example, if you use both the filter "tag-key=Purpose"
+	// and the filter "tag-value=X", you get any resources assigned both the tag
+	// key Purpose (regardless of what the tag's value is), and the tag value X
+	// (regardless of what the tag's key is). If you want to list only resources
+	// where Purpose is X, see the tag:key=value filter.
+	//
+	//   tag-value - The value of a tag assigned to the resource. This filter is
+	// independent of the tag-key filter.
+	//
+	//   virtualization-type - The virtualization type (paravirtual | hvm).
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// One or more image IDs.
+	//
+	// Default: Describes all images available to you.
+	ImageIDs []*string `locationName:"ImageId" locationNameList:"ImageId" type:"list"`
+
+	// Filters the images by the owner. Specify an AWS account ID, amazon (owner
+	// is Amazon), aws-marketplace (owner is AWS Marketplace), self (owner is the
+	// sender of the request). Omitting this option returns all images for which
+	// you have launch permissions, regardless of ownership.
+	Owners []*string `locationName:"Owner" locationNameList:"Owner" type:"list"`
+
+	metadataDescribeImagesInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeImagesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeImagesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeImagesInput) GoString() string {
+	return s.String()
+}
+
+type DescribeImagesOutput struct {
+	// Information about one or more images.
+	Images []*Image `locationName:"imagesSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeImagesOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeImagesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeImagesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeImagesOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeImportImageTasksInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `type:"boolean"`
+
+	// One or more filters.
+	Filters []*Filter `locationNameList:"Filter" type:"list"`
+
+	// A list of import image task IDs.
+	ImportTaskIDs []*string `locationName:"ImportTaskId" locationNameList:"ImportTaskId" type:"list"`
+
+	// The maximum number of results to return in a single request.
+	MaxResults *int64 `type:"integer"`
+
+	// A token that indicates the next page of results.
+	NextToken *string `type:"string"`
+
+	metadataDescribeImportImageTasksInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeImportImageTasksInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeImportImageTasksInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeImportImageTasksInput) GoString() string {
+	return s.String()
+}
+
+type DescribeImportImageTasksOutput struct {
+	// A list of zero or more import image tasks that are currently active or were
+	// completed or canceled in the previous 7 days.
+	ImportImageTasks []*ImportImageTask `locationName:"importImageTaskSet" locationNameList:"item" type:"list"`
+
+	// The token to use to get the next page of results. This value is null when
+	// there are no more results to return.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	metadataDescribeImportImageTasksOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeImportImageTasksOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeImportImageTasksOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeImportImageTasksOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeImportSnapshotTasksInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `type:"boolean"`
+
+	// One or more filters.
+	Filters []*Filter `locationNameList:"Filter" type:"list"`
+
+	// A list of import snapshot task IDs.
+	ImportTaskIDs []*string `locationName:"ImportTaskId" locationNameList:"ImportTaskId" type:"list"`
+
+	// The maximum number of results to return in a single request.
+	MaxResults *int64 `type:"integer"`
+
+	// A token that indicates the next page of results.
+	NextToken *string `type:"string"`
+
+	metadataDescribeImportSnapshotTasksInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeImportSnapshotTasksInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeImportSnapshotTasksInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeImportSnapshotTasksInput) GoString() string {
+	return s.String()
+}
+
+type DescribeImportSnapshotTasksOutput struct {
+	// A list of zero or more import snapshot tasks that are currently active or
+	// were completed or canceled in the previous 7 days.
+	ImportSnapshotTasks []*ImportSnapshotTask `locationName:"importSnapshotTaskSet" locationNameList:"item" type:"list"`
+
+	// The token to use to get the next page of results. This value is null when
+	// there are no more results to return.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	metadataDescribeImportSnapshotTasksOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeImportSnapshotTasksOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeImportSnapshotTasksOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeImportSnapshotTasksOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeInstanceAttributeInput struct {
+	// The instance attribute.
+	Attribute *string `locationName:"attribute" type:"string" required:"true" enum:"InstanceAttributeName"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the instance.
+	InstanceID *string `locationName:"instanceId" type:"string" required:"true"`
+
+	metadataDescribeInstanceAttributeInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeInstanceAttributeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeInstanceAttributeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeInstanceAttributeInput) GoString() string {
+	return s.String()
+}
+
+// Describes an instance attribute.
+type DescribeInstanceAttributeOutput struct {
+	// The block device mapping of the instance.
+	BlockDeviceMappings []*InstanceBlockDeviceMapping `locationName:"blockDeviceMapping" locationNameList:"item" type:"list"`
+
+	// If the value is true, you can't terminate the instance through the Amazon
+	// EC2 console, CLI, or API; otherwise, you can.
+	DisableAPITermination *AttributeBooleanValue `locationName:"disableApiTermination" type:"structure"`
+
+	// Indicates whether the instance is optimized for EBS I/O.
+	EBSOptimized *AttributeBooleanValue `locationName:"ebsOptimized" type:"structure"`
+
+	// The security groups associated with the instance.
+	Groups []*GroupIdentifier `locationName:"groupSet" locationNameList:"item" type:"list"`
+
+	// The ID of the instance.
+	InstanceID *string `locationName:"instanceId" type:"string"`
+
+	// Indicates whether an instance stops or terminates when you initiate shutdown
+	// from the instance (using the operating system command for system shutdown).
+	InstanceInitiatedShutdownBehavior *AttributeValue `locationName:"instanceInitiatedShutdownBehavior" type:"structure"`
+
+	// The instance type.
+	InstanceType *AttributeValue `locationName:"instanceType" type:"structure"`
+
+	// The kernel ID.
+	KernelID *AttributeValue `locationName:"kernel" type:"structure"`
+
+	// A list of product codes.
+	ProductCodes []*ProductCode `locationName:"productCodes" locationNameList:"item" type:"list"`
+
+	// The RAM disk ID.
+	RAMDiskID *AttributeValue `locationName:"ramdisk" type:"structure"`
+
+	// The name of the root device (for example, /dev/sda1 or /dev/xvda).
+	RootDeviceName *AttributeValue `locationName:"rootDeviceName" type:"structure"`
+
+	// The value to use for a resource attribute.
+	SRIOVNetSupport *AttributeValue `locationName:"sriovNetSupport" type:"structure"`
+
+	// Indicates whether source/destination checking is enabled. A value of true
+	// means checking is enabled, and false means checking is disabled. This value
+	// must be false for a NAT instance to perform NAT.
+	SourceDestCheck *AttributeBooleanValue `locationName:"sourceDestCheck" type:"structure"`
+
+	// The Base64-encoded MIME user data.
+	UserData *AttributeValue `locationName:"userData" type:"structure"`
+
+	metadataDescribeInstanceAttributeOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeInstanceAttributeOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeInstanceAttributeOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeInstanceAttributeOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeInstanceStatusInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   availability-zone - The Availability Zone of the instance.
+	//
+	//   event.code - The code for the scheduled event (instance-reboot | system-reboot
+	// | system-maintenance | instance-retirement | instance-stop).
+	//
+	//   event.description - A description of the event.
+	//
+	//   event.not-after - The latest end time for the scheduled event (for example,
+	// 2014-09-15T17:15:20.000Z).
+	//
+	//   event.not-before - The earliest start time for the scheduled event (for
+	// example, 2014-09-15T17:15:20.000Z).
+	//
+	//   instance-state-code - The code for the instance state, as a 16-bit unsigned
+	// integer. The high byte is an opaque internal value and should be ignored.
+	// The low byte is set based on the state represented. The valid values are
+	// 0 (pending), 16 (running), 32 (shutting-down), 48 (terminated), 64 (stopping),
+	// and 80 (stopped).
+	//
+	//   instance-state-name - The state of the instance (pending | running | shutting-down
+	// | terminated | stopping | stopped).
+	//
+	//   instance-status.reachability - Filters on instance status where the name
+	// is reachability (passed | failed | initializing | insufficient-data).
+	//
+	//   instance-status.status - The status of the instance (ok | impaired | initializing
+	// | insufficient-data | not-applicable).
+	//
+	//   system-status.reachability - Filters on system status where the name is
+	// reachability (passed | failed | initializing | insufficient-data).
+	//
+	//   system-status.status - The system status of the instance (ok | impaired
+	// | initializing | insufficient-data | not-applicable).
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// When true, includes the health status for all instances. When false, includes
+	// the health status for running instances only.
+	//
+	// Default: false
+	IncludeAllInstances *bool `locationName:"includeAllInstances" type:"boolean"`
+
+	// One or more instance IDs.
+	//
+	// Default: Describes all your instances.
+	//
+	// Constraints: Maximum 100 explicitly specified instance IDs.
+	InstanceIDs []*string `locationName:"InstanceId" locationNameList:"InstanceId" type:"list"`
+
+	// The maximum number of results to return for the request in a single page.
+	// The remaining results of the initial request can be seen by sending another
+	// request with the returned NextToken value. This value can be between 5 and
+	// 1000; if MaxResults is given a value larger than 1000, only 1000 results
+	// are returned. You cannot specify this parameter and the instance IDs parameter
+	// in the same request.
+	MaxResults *int64 `type:"integer"`
+
+	// The token to retrieve the next page of results.
+	NextToken *string `type:"string"`
+
+	metadataDescribeInstanceStatusInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeInstanceStatusInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeInstanceStatusInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeInstanceStatusInput) GoString() string {
+	return s.String()
+}
+
+type DescribeInstanceStatusOutput struct {
+	// One or more instance status descriptions.
+	InstanceStatuses []*InstanceStatus `locationName:"instanceStatusSet" locationNameList:"item" type:"list"`
+
+	// The token to use to retrieve the next page of results. This value is null
+	// when there are no more results to return.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	metadataDescribeInstanceStatusOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeInstanceStatusOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeInstanceStatusOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeInstanceStatusOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeInstancesInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   architecture - The instance architecture (i386 | x86_64).
+	//
+	//   availability-zone - The Availability Zone of the instance.
+	//
+	//   block-device-mapping.attach-time - The attach time for an EBS volume mapped
+	// to the instance, for example, 2010-09-15T17:15:20.000Z.
+	//
+	//   block-device-mapping.delete-on-termination - A Boolean that indicates
+	// whether the EBS volume is deleted on instance termination.
+	//
+	//   block-device-mapping.device-name - The device name for the EBS volume
+	// (for example, /dev/sdh or xvdh).
+	//
+	//   block-device-mapping.status - The status for the EBS volume (attaching
+	// | attached | detaching | detached).
+	//
+	//   block-device-mapping.volume-id - The volume ID of the EBS volume.
+	//
+	//   client-token - The idempotency token you provided when you launched the
+	// instance.
+	//
+	//   dns-name - The public DNS name of the instance.
+	//
+	//   group-id - The ID of the security group for the instance. EC2-Classic
+	// only.
+	//
+	//   group-name - The name of the security group for the instance. EC2-Classic
+	// only.
+	//
+	//   hypervisor - The hypervisor type of the instance (ovm | xen).
+	//
+	//   iam-instance-profile.arn - The instance profile associated with the instance.
+	// Specified as an ARN.
+	//
+	//   image-id - The ID of the image used to launch the instance.
+	//
+	//   instance-id - The ID of the instance.
+	//
+	//   instance-lifecycle - Indicates whether this is a Spot Instance (spot).
+	//
+	//   instance-state-code - The state of the instance, as a 16-bit unsigned
+	// integer. The high byte is an opaque internal value and should be ignored.
+	// The low byte is set based on the state represented. The valid values are:
+	// 0 (pending), 16 (running), 32 (shutting-down), 48 (terminated), 64 (stopping),
+	// and 80 (stopped).
+	//
+	//   instance-state-name - The state of the instance (pending | running | shutting-down
+	// | terminated | stopping | stopped).
+	//
+	//   instance-type - The type of instance (for example, t2.micro).
+	//
+	//   instance.group-id - The ID of the security group for the instance.
+	//
+	//   instance.group-name - The name of the security group for the instance.
+	//
+	//   ip-address - The public IP address of the instance.
+	//
+	//   kernel-id - The kernel ID.
+	//
+	//   key-name - The name of the key pair used when the instance was launched.
+	//
+	//   launch-index - When launching multiple instances, this is the index for
+	// the instance in the launch group (for example, 0, 1, 2, and so on).
+	//
+	//   launch-time - The time when the instance was launched.
+	//
+	//   monitoring-state - Indicates whether monitoring is enabled for the instance
+	// (disabled | enabled).
+	//
+	//   owner-id - The AWS account ID of the instance owner.
+	//
+	//   placement-group-name - The name of the placement group for the instance.
+	//
+	//   platform - The platform. Use windows if you have Windows instances; otherwise,
+	// leave blank.
+	//
+	//   private-dns-name - The private DNS name of the instance.
+	//
+	//   private-ip-address - The private IP address of the instance.
+	//
+	//   product-code - The product code associated with the AMI used to launch
+	// the instance.
+	//
+	//   product-code.type - The type of product code (devpay | marketplace).
+	//
+	//   ramdisk-id - The RAM disk ID.
+	//
+	//   reason - The reason for the current state of the instance (for example,
+	// shows "User Initiated [date]" when you stop or terminate the instance). Similar
+	// to the state-reason-code filter.
+	//
+	//   requester-id - The ID of the entity that launched the instance on your
+	// behalf (for example, AWS Management Console, Auto Scaling, and so on).
+	//
+	//   reservation-id - The ID of the instance's reservation. A reservation ID
+	// is created any time you launch an instance. A reservation ID has a one-to-one
+	// relationship with an instance launch request, but can be associated with
+	// more than one instance if you launch multiple instances using the same launch
+	// request. For example, if you launch one instance, you'll get one reservation
+	// ID. If you launch ten instances using the same launch request, you'll also
+	// get one reservation ID.
+	//
+	//   root-device-name - The name of the root device for the instance (for example,
+	// /dev/sda1 or /dev/xvda).
+	//
+	//   root-device-type - The type of root device that the instance uses (ebs
+	// | instance-store).
+	//
+	//   source-dest-check - Indicates whether the instance performs source/destination
+	// checking. A value of true means that checking is enabled, and false means
+	// checking is disabled. The value must be false for the instance to perform
+	// network address translation (NAT) in your VPC.
+	//
+	//   spot-instance-request-id - The ID of the Spot Instance request.
+	//
+	//   state-reason-code - The reason code for the state change.
+	//
+	//   state-reason-message - A message that describes the state change.
+	//
+	//   subnet-id - The ID of the subnet for the instance.
+	//
+	//   tag:key=value - The key/value combination of a tag assigned to the resource,
+	// where tag:key is the tag's key.
+	//
+	//   tag-key - The key of a tag assigned to the resource. This filter is independent
+	// of the tag-value filter. For example, if you use both the filter "tag-key=Purpose"
+	// and the filter "tag-value=X", you get any resources assigned both the tag
+	// key Purpose (regardless of what the tag's value is), and the tag value X
+	// (regardless of what the tag's key is). If you want to list only resources
+	// where Purpose is X, see the tag:key=value filter.
+	//
+	//   tag-value - The value of a tag assigned to the resource. This filter is
+	// independent of the tag-key filter.
+	//
+	//   tenancy - The tenancy of an instance (dedicated | default).
+	//
+	//   virtualization-type - The virtualization type of the instance (paravirtual
+	// | hvm).
+	//
+	//   vpc-id - The ID of the VPC that the instance is running in.
+	//
+	//   network-interface.description - The description of the network interface.
+	//
+	//   network-interface.subnet-id - The ID of the subnet for the network interface.
+	//
+	//   network-interface.vpc-id - The ID of the VPC for the network interface.
+	//
+	//   network-interface.network-interface.id - The ID of the network interface.
+	//
+	//   network-interface.owner-id - The ID of the owner of the network interface.
+	//
+	//   network-interface.availability-zone - The Availability Zone for the network
+	// interface.
+	//
+	//   network-interface.requester-id - The requester ID for the network interface.
+	//
+	//   network-interface.requester-managed - Indicates whether the network interface
+	// is being managed by AWS.
+	//
+	//   network-interface.status - The status of the network interface (available)
+	// | in-use).
+	//
+	//   network-interface.mac-address - The MAC address of the network interface.
+	//
+	//   network-interface-private-dns-name - The private DNS name of the network
+	// interface.
+	//
+	//   network-interface.source-dest-check - Whether the network interface performs
+	// source/destination checking. A value of true means checking is enabled, and
+	// false means checking is disabled. The value must be false for the network
+	// interface to perform network address translation (NAT) in your VPC.
+	//
+	//   network-interface.group-id - The ID of a security group associated with
+	// the network interface.
+	//
+	//   network-interface.group-name - The name of a security group associated
+	// with the network interface.
+	//
+	//   network-interface.attachment.attachment-id - The ID of the interface attachment.
+	//
+	//   network-interface.attachment.instance-id - The ID of the instance to which
+	// the network interface is attached.
+	//
+	//   network-interface.attachment.instance-owner-id - The owner ID of the instance
+	// to which the network interface is attached.
+	//
+	//   network-interface.addresses.private-ip-address - The private IP address
+	// associated with the network interface.
+	//
+	//   network-interface.attachment.device-index - The device index to which
+	// the network interface is attached.
+	//
+	//   network-interface.attachment.status - The status of the attachment (attaching
+	// | attached | detaching | detached).
+	//
+	//   network-interface.attachment.attach-time - The time that the network interface
+	// was attached to an instance.
+	//
+	//   network-interface.attachment.delete-on-termination - Specifies whether
+	// the attachment is deleted when an instance is terminated.
+	//
+	//   network-interface.addresses.primary - Specifies whether the IP address
+	// of the network interface is the primary private IP address.
+	//
+	//   network-interface.addresses.association.public-ip - The ID of the association
+	// of an Elastic IP address with a network interface.
+	//
+	//   network-interface.addresses.association.ip-owner-id - The owner ID of
+	// the private IP address associated with the network interface.
+	//
+	//   association.public-ip - The address of the Elastic IP address bound to
+	// the network interface.
+	//
+	//   association.ip-owner-id - The owner of the Elastic IP address associated
+	// with the network interface.
+	//
+	//   association.allocation-id - The allocation ID returned when you allocated
+	// the Elastic IP address for your network interface.
+	//
+	//   association.association-id - The association ID returned when the network
+	// interface was associated with an IP address.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// One or more instance IDs.
+	//
+	// Default: Describes all your instances.
+	InstanceIDs []*string `locationName:"InstanceId" locationNameList:"InstanceId" type:"list"`
+
+	// The maximum number of results to return for the request in a single page.
+	// The remaining results of the initial request can be seen by sending another
+	// request with the returned NextToken value. This value can be between 5 and
+	// 1000; if MaxResults is given a value larger than 1000, only 1000 results
+	// are returned. You cannot specify this parameter and the instance IDs parameter
+	// in the same request.
+	MaxResults *int64 `locationName:"maxResults" type:"integer"`
+
+	// The token to request the next page of results.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	metadataDescribeInstancesInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeInstancesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeInstancesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeInstancesInput) GoString() string {
+	return s.String()
+}
+
+type DescribeInstancesOutput struct {
+	// The token to use to retrieve the next page of results. This value is null
+	// when there are no more results to return.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// One or more reservations.
+	Reservations []*Reservation `locationName:"reservationSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeInstancesOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeInstancesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeInstancesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeInstancesOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeInternetGatewaysInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   attachment.state - The current state of the attachment between the gateway
+	// and the VPC (available). Present only if a VPC is attached.
+	//
+	//   attachment.vpc-id - The ID of an attached VPC.
+	//
+	//   internet-gateway-id - The ID of the Internet gateway.
+	//
+	//   tag:key=value - The key/value combination of a tag assigned to the resource.
+	//
+	//   tag-key - The key of a tag assigned to the resource. This filter is independent
+	// of the tag-value filter. For example, if you use both the filter "tag-key=Purpose"
+	// and the filter "tag-value=X", you get any resources assigned both the tag
+	// key Purpose (regardless of what the tag's value is), and the tag value X
+	// (regardless of what the tag's key is). If you want to list only resources
+	// where Purpose is X, see the tag:key=value filter.
+	//
+	//   tag-value - The value of a tag assigned to the resource. This filter is
+	// independent of the tag-key filter.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// One or more Internet gateway IDs.
+	//
+	// Default: Describes all your Internet gateways.
+	InternetGatewayIDs []*string `locationName:"internetGatewayId" locationNameList:"item" type:"list"`
+
+	metadataDescribeInternetGatewaysInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeInternetGatewaysInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeInternetGatewaysInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeInternetGatewaysInput) GoString() string {
+	return s.String()
+}
+
+type DescribeInternetGatewaysOutput struct {
+	// Information about one or more Internet gateways.
+	InternetGateways []*InternetGateway `locationName:"internetGatewaySet" locationNameList:"item" type:"list"`
+
+	metadataDescribeInternetGatewaysOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeInternetGatewaysOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeInternetGatewaysOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeInternetGatewaysOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeKeyPairsInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   fingerprint - The fingerprint of the key pair.
+	//
+	//   key-name - The name of the key pair.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// One or more key pair names.
+	//
+	// Default: Describes all your key pairs.
+	KeyNames []*string `locationName:"KeyName" locationNameList:"KeyName" type:"list"`
+
+	metadataDescribeKeyPairsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeKeyPairsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeKeyPairsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeKeyPairsInput) GoString() string {
+	return s.String()
+}
+
+type DescribeKeyPairsOutput struct {
+	// Information about one or more key pairs.
+	KeyPairs []*KeyPairInfo `locationName:"keySet" locationNameList:"item" type:"list"`
+
+	metadataDescribeKeyPairsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeKeyPairsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeKeyPairsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeKeyPairsOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeMovingAddressesInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   moving-status - The status of the Elastic IP address (MovingToVpc | RestoringToClassic).
+	Filters []*Filter `locationName:"filter" locationNameList:"Filter" type:"list"`
+
+	// The maximum number of results to return for the request in a single page.
+	// The remaining results of the initial request can be seen by sending another
+	// request with the returned NextToken value. This value can be between 5 and
+	// 1000; if MaxResults is given a value outside of this range, an error is returned.
+	//
+	// Default: If no value is provided, the default is 1000.
+	MaxResults *int64 `locationName:"maxResults" type:"integer"`
+
+	// The token to use to retrieve the next page of results.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// One or more Elastic IP addresses.
+	PublicIPs []*string `locationName:"publicIp" locationNameList:"item" type:"list"`
+
+	metadataDescribeMovingAddressesInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeMovingAddressesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeMovingAddressesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeMovingAddressesInput) GoString() string {
+	return s.String()
+}
+
+type DescribeMovingAddressesOutput struct {
+	// The status for each Elastic IP address.
+	MovingAddressStatuses []*MovingAddressStatus `locationName:"movingAddressStatusSet" locationNameList:"item" type:"list"`
+
+	// The token to use to retrieve the next page of results. This value is null
+	// when there are no more results to return.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	metadataDescribeMovingAddressesOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeMovingAddressesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeMovingAddressesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeMovingAddressesOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeNetworkACLsInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   association.association-id - The ID of an association ID for the ACL.
+	//
+	//   association.network-acl-id - The ID of the network ACL involved in the
+	// association.
+	//
+	//   association.subnet-id - The ID of the subnet involved in the association.
+	//
+	//   default - Indicates whether the ACL is the default network ACL for the
+	// VPC.
+	//
+	//   entry.cidr - The CIDR range specified in the entry.
+	//
+	//   entry.egress - Indicates whether the entry applies to egress traffic.
+	//
+	//   entry.icmp.code - The ICMP code specified in the entry, if any.
+	//
+	//   entry.icmp.type - The ICMP type specified in the entry, if any.
+	//
+	//   entry.port-range.from - The start of the port range specified in the entry.
+	//
+	//   entry.port-range.to - The end of the port range specified in the entry.
+	//
+	//   entry.protocol - The protocol specified in the entry (tcp | udp | icmp
+	// or a protocol number).
+	//
+	//   entry.rule-action - Allows or denies the matching traffic (allow | deny).
+	//
+	//   entry.rule-number - The number of an entry (in other words, rule) in the
+	// ACL's set of entries.
+	//
+	//   network-acl-id - The ID of the network ACL.
+	//
+	//   tag:key=value - The key/value combination of a tag assigned to the resource.
+	//
+	//   tag-key - The key of a tag assigned to the resource. This filter is independent
+	// of the tag-value filter. For example, if you use both the filter "tag-key=Purpose"
+	// and the filter "tag-value=X", you get any resources assigned both the tag
+	// key Purpose (regardless of what the tag's value is), and the tag value X
+	// (regardless of what the tag's key is). If you want to list only resources
+	// where Purpose is X, see the tag:key=value filter.
+	//
+	//   tag-value - The value of a tag assigned to the resource. This filter is
+	// independent of the tag-key filter.
+	//
+	//   vpc-id - The ID of the VPC for the network ACL.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// One or more network ACL IDs.
+	//
+	// Default: Describes all your network ACLs.
+	NetworkACLIDs []*string `locationName:"NetworkAclId" locationNameList:"item" type:"list"`
+
+	metadataDescribeNetworkACLsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeNetworkACLsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeNetworkACLsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeNetworkACLsInput) GoString() string {
+	return s.String()
+}
+
+type DescribeNetworkACLsOutput struct {
+	// Information about one or more network ACLs.
+	NetworkACLs []*NetworkACL `locationName:"networkAclSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeNetworkACLsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeNetworkACLsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeNetworkACLsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeNetworkACLsOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeNetworkInterfaceAttributeInput struct {
+	// The attribute of the network interface.
+	Attribute *string `locationName:"attribute" type:"string" enum:"NetworkInterfaceAttribute"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the network interface.
+	NetworkInterfaceID *string `locationName:"networkInterfaceId" type:"string" required:"true"`
+
+	metadataDescribeNetworkInterfaceAttributeInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeNetworkInterfaceAttributeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeNetworkInterfaceAttributeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeNetworkInterfaceAttributeInput) GoString() string {
+	return s.String()
+}
+
+type DescribeNetworkInterfaceAttributeOutput struct {
+	// The attachment (if any) of the network interface.
+	Attachment *NetworkInterfaceAttachment `locationName:"attachment" type:"structure"`
+
+	// The description of the network interface.
+	Description *AttributeValue `locationName:"description" type:"structure"`
+
+	// The security groups associated with the network interface.
+	Groups []*GroupIdentifier `locationName:"groupSet" locationNameList:"item" type:"list"`
+
+	// The ID of the network interface.
+	NetworkInterfaceID *string `locationName:"networkInterfaceId" type:"string"`
+
+	// Indicates whether source/destination checking is enabled.
+	SourceDestCheck *AttributeBooleanValue `locationName:"sourceDestCheck" type:"structure"`
+
+	metadataDescribeNetworkInterfaceAttributeOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeNetworkInterfaceAttributeOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeNetworkInterfaceAttributeOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeNetworkInterfaceAttributeOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeNetworkInterfacesInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   addresses.private-ip-address - The private IP addresses associated with
+	// the network interface.
+	//
+	//   addresses.primary - Whether the private IP address is the primary IP address
+	// associated with the network interface.
+	//
+	//   addresses.association.public-ip - The association ID returned when the
+	// network interface was associated with the Elastic IP address.
+	//
+	//   addresses.association.owner-id - The owner ID of the addresses associated
+	// with the network interface.
+	//
+	//   association.association-id - The association ID returned when the network
+	// interface was associated with an IP address.
+	//
+	//   association.allocation-id - The allocation ID returned when you allocated
+	// the Elastic IP address for your network interface.
+	//
+	//   association.ip-owner-id - The owner of the Elastic IP address associated
+	// with the network interface.
+	//
+	//   association.public-ip - The address of the Elastic IP address bound to
+	// the network interface.
+	//
+	//   association.public-dns-name - The public DNS name for the network interface.
+	//
+	//   attachment.attachment-id - The ID of the interface attachment.
+	//
+	//   attachment.instance-id - The ID of the instance to which the network interface
+	// is attached.
+	//
+	//   attachment.instance-owner-id - The owner ID of the instance to which the
+	// network interface is attached.
+	//
+	//   attachment.device-index - The device index to which the network interface
+	// is attached.
+	//
+	//   attachment.status - The status of the attachment (attaching | attached
+	// | detaching | detached).
+	//
+	//   attachment.attach.time - The time that the network interface was attached
+	// to an instance.
+	//
+	//   attachment.delete-on-termination - Indicates whether the attachment is
+	// deleted when an instance is terminated.
+	//
+	//   availability-zone - The Availability Zone of the network interface.
+	//
+	//   description - The description of the network interface.
+	//
+	//   group-id - The ID of a security group associated with the network interface.
+	//
+	//   group-name - The name of a security group associated with the network
+	// interface.
+	//
+	//   mac-address - The MAC address of the network interface.
+	//
+	//   network-interface-id - The ID of the network interface.
+	//
+	//   owner-id - The AWS account ID of the network interface owner.
+	//
+	//   private-ip-address - The private IP address or addresses of the network
+	// interface.
+	//
+	//   private-dns-name - The private DNS name of the network interface.
+	//
+	//   requester-id - The ID of the entity that launched the instance on your
+	// behalf (for example, AWS Management Console, Auto Scaling, and so on).
+	//
+	//   requester-managed - Indicates whether the network interface is being managed
+	// by an AWS service (for example, AWS Management Console, Auto Scaling, and
+	// so on).
+	//
+	//   source-desk-check - Indicates whether the network interface performs source/destination
+	// checking. A value of true means checking is enabled, and false means checking
+	// is disabled. The value must be false for the network interface to perform
+	// Network Address Translation (NAT) in your VPC.
+	//
+	//   status - The status of the network interface. If the network interface
+	// is not attached to an instance, the status is available; if a network interface
+	// is attached to an instance the status is in-use.
+	//
+	//   subnet-id - The ID of the subnet for the network interface.
+	//
+	//   tag:key=value - The key/value combination of a tag assigned to the resource.
+	//
+	//   tag-key - The key of a tag assigned to the resource. This filter is independent
+	// of the tag-value filter. For example, if you use both the filter "tag-key=Purpose"
+	// and the filter "tag-value=X", you get any resources assigned both the tag
+	// key Purpose (regardless of what the tag's value is), and the tag value X
+	// (regardless of what the tag's key is). If you want to list only resources
+	// where Purpose is X, see the tag:key=value filter.
+	//
+	//   tag-value - The value of a tag assigned to the resource. This filter is
+	// independent of the tag-key filter.
+	//
+	//   vpc-id - The ID of the VPC for the network interface.
+	Filters []*Filter `locationName:"filter" locationNameList:"Filter" type:"list"`
+
+	// One or more network interface IDs.
+	//
+	// Default: Describes all your network interfaces.
+	NetworkInterfaceIDs []*string `locationName:"NetworkInterfaceId" locationNameList:"item" type:"list"`
+
+	metadataDescribeNetworkInterfacesInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeNetworkInterfacesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeNetworkInterfacesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeNetworkInterfacesInput) GoString() string {
+	return s.String()
+}
+
+type DescribeNetworkInterfacesOutput struct {
+	// Information about one or more network interfaces.
+	NetworkInterfaces []*NetworkInterface `locationName:"networkInterfaceSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeNetworkInterfacesOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeNetworkInterfacesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeNetworkInterfacesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeNetworkInterfacesOutput) GoString() string {
+	return s.String()
+}
+
+type DescribePlacementGroupsInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   group-name - The name of the placement group.
+	//
+	//   state - The state of the placement group (pending | available | deleting
+	// | deleted).
+	//
+	//   strategy - The strategy of the placement group (cluster).
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// One or more placement group names.
+	//
+	// Default: Describes all your placement groups, or only those otherwise specified.
+	GroupNames []*string `locationName:"groupName" type:"list"`
+
+	metadataDescribePlacementGroupsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribePlacementGroupsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribePlacementGroupsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribePlacementGroupsInput) GoString() string {
+	return s.String()
+}
+
+type DescribePlacementGroupsOutput struct {
+	// One or more placement groups.
+	PlacementGroups []*PlacementGroup `locationName:"placementGroupSet" locationNameList:"item" type:"list"`
+
+	metadataDescribePlacementGroupsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribePlacementGroupsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribePlacementGroupsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribePlacementGroupsOutput) GoString() string {
+	return s.String()
+}
+
+type DescribePrefixListsInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `type:"boolean"`
+
+	// One or more filters.
+	//
+	//   prefix-list-id: The ID of a prefix list.
+	//
+	//   prefix-list-name: The name of a prefix list.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// The maximum number of items to return for this request. The request returns
+	// a token that you can specify in a subsequent call to get the next set of
+	// results.
+	//
+	// Constraint: If the value specified is greater than 1000, we return only
+	// 1000 items.
+	MaxResults *int64 `type:"integer"`
+
+	// The token for the next set of items to return. (You received this token from
+	// a prior call.)
+	NextToken *string `type:"string"`
+
+	// One or more prefix list IDs.
+	PrefixListIDs []*string `locationName:"PrefixListId" locationNameList:"item" type:"list"`
+
+	metadataDescribePrefixListsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribePrefixListsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribePrefixListsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribePrefixListsInput) GoString() string {
+	return s.String()
+}
+
+type DescribePrefixListsOutput struct {
+	// The token to use when requesting the next set of items. If there are no additional
+	// items to return, the string is empty.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// All available prefix lists.
+	PrefixLists []*PrefixList `locationName:"prefixListSet" locationNameList:"item" type:"list"`
+
+	metadataDescribePrefixListsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribePrefixListsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribePrefixListsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribePrefixListsOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeRegionsInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   endpoint - The endpoint of the region (for example, ec2.us-east-1.amazonaws.com).
+	//
+	//   region-name - The name of the region (for example, us-east-1).
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// The names of one or more regions.
+	RegionNames []*string `locationName:"RegionName" locationNameList:"RegionName" type:"list"`
+
+	metadataDescribeRegionsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeRegionsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeRegionsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeRegionsInput) GoString() string {
+	return s.String()
+}
+
+type DescribeRegionsOutput struct {
+	// Information about one or more regions.
+	Regions []*Region `locationName:"regionInfo" locationNameList:"item" type:"list"`
+
+	metadataDescribeRegionsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeRegionsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeRegionsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeRegionsOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeReservedInstancesInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   availability-zone - The Availability Zone where the Reserved Instance
+	// can be used.
+	//
+	//   duration - The duration of the Reserved Instance (one year or three years),
+	// in seconds (31536000 | 94608000).
+	//
+	//   end - The time when the Reserved Instance expires (for example, 2015-08-07T11:54:42.000Z).
+	//
+	//   fixed-price - The purchase price of the Reserved Instance (for example,
+	// 9800.0).
+	//
+	//   instance-type - The instance type on which the Reserved Instance can be
+	// used.
+	//
+	//   product-description - The Reserved Instance product platform description.
+	// Instances that include (Amazon VPC) in the product platform description will
+	// only be displayed to EC2-Classic account holders and are for use with Amazon
+	// VPC. (Linux/UNIX | Linux/UNIX (Amazon VPC) | SUSE Linux | SUSE Linux (Amazon
+	// VPC) | Red Hat Enterprise Linux | Red Hat Enterprise Linux (Amazon VPC) |
+	// Windows | Windows (Amazon VPC) | Windows with SQL Server Standard | Windows
+	// with SQL Server Standard (Amazon VPC) | Windows with SQL Server Web | Windows
+	// with SQL Server Web (Amazon VPC) | Windows with SQL Server Enterprise | Windows
+	// with SQL Server Enterprise (Amazon VPC)).
+	//
+	//   reserved-instances-id - The ID of the Reserved Instance.
+	//
+	//   start - The time at which the Reserved Instance purchase request was placed
+	// (for example, 2014-08-07T11:54:42.000Z).
+	//
+	//   state - The state of the Reserved Instance (payment-pending | active |
+	// payment-failed | retired).
+	//
+	//   tag:key=value - The key/value combination of a tag assigned to the resource.
+	//
+	//   tag-key - The key of a tag assigned to the resource. This filter is independent
+	// of the tag-value filter. For example, if you use both the filter "tag-key=Purpose"
+	// and the filter "tag-value=X", you get any resources assigned both the tag
+	// key Purpose (regardless of what the tag's value is), and the tag value X
+	// (regardless of what the tag's key is). If you want to list only resources
+	// where Purpose is X, see the tag:key=value filter.
+	//
+	//   tag-value - The value of a tag assigned to the resource. This filter is
+	// independent of the tag-key filter.
+	//
+	//   usage-price - The usage price of the Reserved Instance, per hour (for
+	// example, 0.84).
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// The Reserved Instance offering type. If you are using tools that predate
+	// the 2011-11-01 API version, you only have access to the Medium Utilization
+	// Reserved Instance offering type.
+	OfferingType *string `locationName:"offeringType" type:"string" enum:"OfferingTypeValues"`
+
+	// One or more Reserved Instance IDs.
+	//
+	// Default: Describes all your Reserved Instances, or only those otherwise
+	// specified.
+	ReservedInstancesIDs []*string `locationName:"ReservedInstancesId" locationNameList:"ReservedInstancesId" type:"list"`
+
+	metadataDescribeReservedInstancesInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeReservedInstancesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeReservedInstancesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeReservedInstancesInput) GoString() string {
+	return s.String()
+}
+
+type DescribeReservedInstancesListingsInput struct {
+	// One or more filters.
+	//
+	//   reserved-instances-id - The ID of the Reserved Instances.
+	//
+	//   reserved-instances-listing-id - The ID of the Reserved Instances listing.
+	//
+	//   status - The status of the Reserved Instance listing (pending | active
+	// | cancelled | closed).
+	//
+	//   status-message - The reason for the status.
+	Filters []*Filter `locationName:"filters" locationNameList:"Filter" type:"list"`
+
+	// One or more Reserved Instance IDs.
+	ReservedInstancesID *string `locationName:"reservedInstancesId" type:"string"`
+
+	// One or more Reserved Instance Listing IDs.
+	ReservedInstancesListingID *string `locationName:"reservedInstancesListingId" type:"string"`
+
+	metadataDescribeReservedInstancesListingsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeReservedInstancesListingsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeReservedInstancesListingsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeReservedInstancesListingsInput) GoString() string {
+	return s.String()
+}
+
+type DescribeReservedInstancesListingsOutput struct {
+	// Information about the Reserved Instance listing.
+	ReservedInstancesListings []*ReservedInstancesListing `locationName:"reservedInstancesListingsSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeReservedInstancesListingsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeReservedInstancesListingsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeReservedInstancesListingsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeReservedInstancesListingsOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeReservedInstancesModificationsInput struct {
+	// One or more filters.
+	//
+	//   client-token - The idempotency token for the modification request.
+	//
+	//   create-date - The time when the modification request was created.
+	//
+	//   effective-date - The time when the modification becomes effective.
+	//
+	//   modification-result.reserved-instances-id - The ID for the Reserved Instances
+	// created as part of the modification request. This ID is only available when
+	// the status of the modification is fulfilled.
+	//
+	//   modification-result.target-configuration.availability-zone - The Availability
+	// Zone for the new Reserved Instances.
+	//
+	//   modification-result.target-configuration.instance-count  - The number
+	// of new Reserved Instances.
+	//
+	//   modification-result.target-configuration.instance-type - The instance
+	// type of the new Reserved Instances.
+	//
+	//   modification-result.target-configuration.platform - The network platform
+	// of the new Reserved Instances (EC2-Classic | EC2-VPC).
+	//
+	//   reserved-instances-id - The ID of the Reserved Instances modified.
+	//
+	//   reserved-instances-modification-id - The ID of the modification request.
+	//
+	//   status - The status of the Reserved Instances modification request (processing
+	// | fulfilled | failed).
+	//
+	//   status-message - The reason for the status.
+	//
+	//   update-date - The time when the modification request was last updated.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// The token to retrieve the next page of results.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// IDs for the submitted modification request.
+	ReservedInstancesModificationIDs []*string `locationName:"ReservedInstancesModificationId" locationNameList:"ReservedInstancesModificationId" type:"list"`
+
+	metadataDescribeReservedInstancesModificationsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeReservedInstancesModificationsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeReservedInstancesModificationsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeReservedInstancesModificationsInput) GoString() string {
+	return s.String()
+}
+
+type DescribeReservedInstancesModificationsOutput struct {
+	// The token to use to retrieve the next page of results. This value is null
+	// when there are no more results to return.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// The Reserved Instance modification information.
+	ReservedInstancesModifications []*ReservedInstancesModification `locationName:"reservedInstancesModificationsSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeReservedInstancesModificationsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeReservedInstancesModificationsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeReservedInstancesModificationsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeReservedInstancesModificationsOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeReservedInstancesOfferingsInput struct {
+	// The Availability Zone in which the Reserved Instance can be used.
+	AvailabilityZone *string `type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   availability-zone - The Availability Zone where the Reserved Instance
+	// can be used.
+	//
+	//   duration - The duration of the Reserved Instance (for example, one year
+	// or three years), in seconds (31536000 | 94608000).
+	//
+	//   fixed-price - The purchase price of the Reserved Instance (for example,
+	// 9800.0).
+	//
+	//   instance-type - The instance type on which the Reserved Instance can be
+	// used.
+	//
+	//   marketplace - Set to true to show only Reserved Instance Marketplace offerings.
+	// When this filter is not used, which is the default behavior, all offerings
+	// from AWS and Reserved Instance Marketplace are listed.
+	//
+	//   product-description - The Reserved Instance product platform description.
+	// Instances that include (Amazon VPC) in the product platform description will
+	// only be displayed to EC2-Classic account holders and are for use with Amazon
+	// VPC. (Linux/UNIX | Linux/UNIX (Amazon VPC) | SUSE Linux | SUSE Linux (Amazon
+	// VPC) | Red Hat Enterprise Linux | Red Hat Enterprise Linux (Amazon VPC) |
+	// Windows | Windows (Amazon VPC) | Windows with SQL Server Standard | Windows
+	// with SQL Server Standard (Amazon VPC) | Windows with SQL Server Web |  Windows
+	// with SQL Server Web (Amazon VPC) | Windows with SQL Server Enterprise | Windows
+	// with SQL Server Enterprise (Amazon VPC))
+	//
+	//   reserved-instances-offering-id - The Reserved Instances offering ID.
+	//
+	//   usage-price - The usage price of the Reserved Instance, per hour (for
+	// example, 0.84).
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// Include Marketplace offerings in the response.
+	IncludeMarketplace *bool `type:"boolean"`
+
+	// The tenancy of the Reserved Instance offering. A Reserved Instance with dedicated
+	// tenancy runs on single-tenant hardware and can only be launched within a
+	// VPC.
+	//
+	// Default: default
+	InstanceTenancy *string `locationName:"instanceTenancy" type:"string" enum:"Tenancy"`
+
+	// The instance type on which the Reserved Instance can be used. For more information,
+	// see Instance Types (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html)
+	// in the Amazon Elastic Compute Cloud User Guide.
+	InstanceType *string `type:"string" enum:"InstanceType"`
+
+	// The maximum duration (in seconds) to filter when searching for offerings.
+	//
+	// Default: 94608000 (3 years)
+	MaxDuration *int64 `type:"long"`
+
+	// The maximum number of instances to filter when searching for offerings.
+	//
+	// Default: 20
+	MaxInstanceCount *int64 `type:"integer"`
+
+	// The maximum number of results to return for the request in a single page.
+	// The remaining results of the initial request can be seen by sending another
+	// request with the returned NextToken value. The maximum is 100.
+	//
+	// Default: 100
+	MaxResults *int64 `locationName:"maxResults" type:"integer"`
+
+	// The minimum duration (in seconds) to filter when searching for offerings.
+	//
+	// Default: 2592000 (1 month)
+	MinDuration *int64 `type:"long"`
+
+	// The token to retrieve the next page of results.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// The Reserved Instance offering type. If you are using tools that predate
+	// the 2011-11-01 API version, you only have access to the Medium Utilization
+	// Reserved Instance offering type.
+	OfferingType *string `locationName:"offeringType" type:"string" enum:"OfferingTypeValues"`
+
+	// The Reserved Instance product platform description. Instances that include
+	// (Amazon VPC) in the description are for use with Amazon VPC.
+	ProductDescription *string `type:"string" enum:"RIProductDescription"`
+
+	// One or more Reserved Instances offering IDs.
+	ReservedInstancesOfferingIDs []*string `locationName:"ReservedInstancesOfferingId" type:"list"`
+
+	metadataDescribeReservedInstancesOfferingsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeReservedInstancesOfferingsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeReservedInstancesOfferingsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeReservedInstancesOfferingsInput) GoString() string {
+	return s.String()
+}
+
+type DescribeReservedInstancesOfferingsOutput struct {
+	// The token to use to retrieve the next page of results. This value is null
+	// when there are no more results to return.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// A list of Reserved Instances offerings.
+	ReservedInstancesOfferings []*ReservedInstancesOffering `locationName:"reservedInstancesOfferingsSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeReservedInstancesOfferingsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeReservedInstancesOfferingsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeReservedInstancesOfferingsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeReservedInstancesOfferingsOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeReservedInstancesOutput struct {
+	// A list of Reserved Instances.
+	ReservedInstances []*ReservedInstances `locationName:"reservedInstancesSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeReservedInstancesOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeReservedInstancesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeReservedInstancesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeReservedInstancesOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeRouteTablesInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   association.route-table-association-id - The ID of an association ID for
+	// the route table.
+	//
+	//   association.route-table-id - The ID of the route table involved in the
+	// association.
+	//
+	//   association.subnet-id - The ID of the subnet involved in the association.
+	//
+	//   association.main - Indicates whether the route table is the main route
+	// table for the VPC.
+	//
+	//   route-table-id - The ID of the route table.
+	//
+	//   route.destination-cidr-block - The CIDR range specified in a route in
+	// the table.
+	//
+	//   route.destination-prefix-list-id - The ID (prefix) of the AWS service
+	// specified in a route in the table.
+	//
+	//   route.gateway-id - The ID of a gateway specified in a route in the table.
+	//
+	//   route.instance-id - The ID of an instance specified in a route in the
+	// table.
+	//
+	//   route.origin - Describes how the route was created. CreateRouteTable indicates
+	// that the route was automatically created when the route table was created;
+	// CreateRoute indicates that the route was manually added to the route table;
+	// EnableVgwRoutePropagation indicates that the route was propagated by route
+	// propagation.
+	//
+	//   route.state - The state of a route in the route table (active | blackhole).
+	// The blackhole state indicates that the route's target isn't available (for
+	// example, the specified gateway isn't attached to the VPC, the specified NAT
+	// instance has been terminated, and so on).
+	//
+	//   route.vpc-peering-connection-id - The ID of a VPC peering connection specified
+	// in a route in the table.
+	//
+	//   tag:key=value - The key/value combination of a tag assigned to the resource.
+	//
+	//   tag-key - The key of a tag assigned to the resource. This filter is independent
+	// of the tag-value filter. For example, if you use both the filter "tag-key=Purpose"
+	// and the filter "tag-value=X", you get any resources assigned both the tag
+	// key Purpose (regardless of what the tag's value is), and the tag value X
+	// (regardless of what the tag's key is). If you want to list only resources
+	// where Purpose is X, see the tag:key=value filter.
+	//
+	//   tag-value - The value of a tag assigned to the resource. This filter is
+	// independent of the tag-key filter.
+	//
+	//   vpc-id - The ID of the VPC for the route table.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// One or more route table IDs.
+	//
+	// Default: Describes all your route tables.
+	RouteTableIDs []*string `locationName:"RouteTableId" locationNameList:"item" type:"list"`
+
+	metadataDescribeRouteTablesInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeRouteTablesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeRouteTablesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeRouteTablesInput) GoString() string {
+	return s.String()
+}
+
+type DescribeRouteTablesOutput struct {
+	// Information about one or more route tables.
+	RouteTables []*RouteTable `locationName:"routeTableSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeRouteTablesOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeRouteTablesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeRouteTablesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeRouteTablesOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeSecurityGroupsInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   description - The description of the security group.
+	//
+	//   egress.ip-permission.prefix-list-id - The ID (prefix) of the AWS service
+	// to which the security group allows access.
+	//
+	//   group-id - The ID of the security group.
+	//
+	//   group-name - The name of the security group.
+	//
+	//   ip-permission.cidr - A CIDR range that has been granted permission.
+	//
+	//   ip-permission.from-port - The start of port range for the TCP and UDP
+	// protocols, or an ICMP type number.
+	//
+	//   ip-permission.group-id - The ID of a security group that has been granted
+	// permission.
+	//
+	//   ip-permission.group-name - The name of a security group that has been
+	// granted permission.
+	//
+	//   ip-permission.protocol - The IP protocol for the permission (tcp | udp
+	// | icmp or a protocol number).
+	//
+	//   ip-permission.to-port - The end of port range for the TCP and UDP protocols,
+	// or an ICMP code.
+	//
+	//   ip-permission.user-id - The ID of an AWS account that has been granted
+	// permission.
+	//
+	//   owner-id - The AWS account ID of the owner of the security group.
+	//
+	//   tag-key - The key of a tag assigned to the security group.
+	//
+	//   tag-value - The value of a tag assigned to the security group.
+	//
+	//   vpc-id - The ID of the VPC specified when the security group was created.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// One or more security group IDs. Required for security groups in a nondefault
+	// VPC.
+	//
+	// Default: Describes all your security groups.
+	GroupIDs []*string `locationName:"GroupId" locationNameList:"groupId" type:"list"`
+
+	// [EC2-Classic and default VPC only] One or more security group names. You
+	// can specify either the security group name or the security group ID. For
+	// security groups in a nondefault VPC, use the group-name filter to describe
+	// security groups by name.
+	//
+	// Default: Describes all your security groups.
+	GroupNames []*string `locationName:"GroupName" locationNameList:"GroupName" type:"list"`
+
+	metadataDescribeSecurityGroupsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeSecurityGroupsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeSecurityGroupsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeSecurityGroupsInput) GoString() string {
+	return s.String()
+}
+
+type DescribeSecurityGroupsOutput struct {
+	// Information about one or more security groups.
+	SecurityGroups []*SecurityGroup `locationName:"securityGroupInfo" locationNameList:"item" type:"list"`
+
+	metadataDescribeSecurityGroupsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeSecurityGroupsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeSecurityGroupsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeSecurityGroupsOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeSnapshotAttributeInput struct {
+	// The snapshot attribute you would like to view.
+	Attribute *string `type:"string" required:"true" enum:"SnapshotAttributeName"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the EBS snapshot.
+	SnapshotID *string `locationName:"SnapshotId" type:"string" required:"true"`
+
+	metadataDescribeSnapshotAttributeInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeSnapshotAttributeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeSnapshotAttributeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeSnapshotAttributeInput) GoString() string {
+	return s.String()
+}
+
+type DescribeSnapshotAttributeOutput struct {
+	// A list of permissions for creating volumes from the snapshot.
+	CreateVolumePermissions []*CreateVolumePermission `locationName:"createVolumePermission" locationNameList:"item" type:"list"`
+
+	// A list of product codes.
+	ProductCodes []*ProductCode `locationName:"productCodes" locationNameList:"item" type:"list"`
+
+	// The ID of the EBS snapshot.
+	SnapshotID *string `locationName:"snapshotId" type:"string"`
+
+	metadataDescribeSnapshotAttributeOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeSnapshotAttributeOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeSnapshotAttributeOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeSnapshotAttributeOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeSnapshotsInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   description - A description of the snapshot.
+	//
+	//   owner-alias - The AWS account alias (for example, amazon) that owns the
+	// snapshot.
+	//
+	//   owner-id - The ID of the AWS account that owns the snapshot.
+	//
+	//   progress - The progress of the snapshot, as a percentage (for example,
+	// 80%).
+	//
+	//   snapshot-id - The snapshot ID.
+	//
+	//   start-time - The time stamp when the snapshot was initiated.
+	//
+	//   status - The status of the snapshot (pending | completed | error).
+	//
+	//   tag:key=value - The key/value combination of a tag assigned to the resource.
+	//
+	//   tag-key - The key of a tag assigned to the resource. This filter is independent
+	// of the tag-value filter. For example, if you use both the filter "tag-key=Purpose"
+	// and the filter "tag-value=X", you get any resources assigned both the tag
+	// key Purpose (regardless of what the tag's value is), and the tag value X
+	// (regardless of what the tag's key is). If you want to list only resources
+	// where Purpose is X, see the tag:key=value filter.
+	//
+	//   tag-value - The value of a tag assigned to the resource. This filter is
+	// independent of the tag-key filter.
+	//
+	//   volume-id - The ID of the volume the snapshot is for.
+	//
+	//   volume-size - The size of the volume, in GiB.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// The maximum number of snapshot results returned by DescribeSnapshots in paginated
+	// output. When this parameter is used, DescribeSnapshots only returns MaxResults
+	// results in a single page along with a NextToken response element. The remaining
+	// results of the initial request can be seen by sending another DescribeSnapshots
+	// request with the returned NextToken value. This value can be between 5 and
+	// 1000; if MaxResults is given a value larger than 1000, only 1000 results
+	// are returned. If this parameter is not used, then DescribeSnapshots returns
+	// all results. You cannot specify this parameter and the snapshot IDs parameter
+	// in the same request.
+	MaxResults *int64 `type:"integer"`
+
+	// The NextToken value returned from a previous paginated DescribeSnapshots
+	// request where MaxResults was used and the results exceeded the value of that
+	// parameter. Pagination continues from the end of the previous results that
+	// returned the NextToken value. This value is null when there are no more results
+	// to return.
+	NextToken *string `type:"string"`
+
+	// Returns the snapshots owned by the specified owner. Multiple owners can be
+	// specified.
+	OwnerIDs []*string `locationName:"Owner" locationNameList:"Owner" type:"list"`
+
+	// One or more AWS accounts IDs that can create volumes from the snapshot.
+	RestorableByUserIDs []*string `locationName:"RestorableBy" type:"list"`
+
+	// One or more snapshot IDs.
+	//
+	// Default: Describes snapshots for which you have launch permissions.
+	SnapshotIDs []*string `locationName:"SnapshotId" locationNameList:"SnapshotId" type:"list"`
+
+	metadataDescribeSnapshotsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeSnapshotsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeSnapshotsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeSnapshotsInput) GoString() string {
+	return s.String()
+}
+
+type DescribeSnapshotsOutput struct {
+	// The NextToken value to include in a future DescribeSnapshots request. When
+	// the results of a DescribeSnapshots request exceed MaxResults, this value
+	// can be used to retrieve the next page of results. This value is null when
+	// there are no more results to return.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// Information about the snapshots.
+	Snapshots []*Snapshot `locationName:"snapshotSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeSnapshotsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeSnapshotsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeSnapshotsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeSnapshotsOutput) GoString() string {
+	return s.String()
+}
+
+// Contains the parameters for DescribeSpotDatafeedSubscription.
+type DescribeSpotDatafeedSubscriptionInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	metadataDescribeSpotDatafeedSubscriptionInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeSpotDatafeedSubscriptionInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeSpotDatafeedSubscriptionInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeSpotDatafeedSubscriptionInput) GoString() string {
+	return s.String()
+}
+
+// Contains the output of DescribeSpotDatafeedSubscription.
+type DescribeSpotDatafeedSubscriptionOutput struct {
+	// The Spot Instance data feed subscription.
+	SpotDatafeedSubscription *SpotDatafeedSubscription `locationName:"spotDatafeedSubscription" type:"structure"`
+
+	metadataDescribeSpotDatafeedSubscriptionOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeSpotDatafeedSubscriptionOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeSpotDatafeedSubscriptionOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeSpotDatafeedSubscriptionOutput) GoString() string {
+	return s.String()
+}
+
+// Contains the parameters for DescribeSpotFleetInstances.
+type DescribeSpotFleetInstancesInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The maximum number of results to return in a single call. Specify a value
+	// between 1 and 1000. The default value is 1000. To retrieve the remaining
+	// results, make another call with the returned NextToken value.
+	MaxResults *int64 `locationName:"maxResults" type:"integer"`
+
+	// The token for the next set of results.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// The ID of the Spot fleet request.
+	SpotFleetRequestID *string `locationName:"spotFleetRequestId" type:"string" required:"true"`
+
+	metadataDescribeSpotFleetInstancesInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeSpotFleetInstancesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeSpotFleetInstancesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeSpotFleetInstancesInput) GoString() string {
+	return s.String()
+}
+
+// Contains the output of DescribeSpotFleetInstances.
+type DescribeSpotFleetInstancesOutput struct {
+	// The running instances. Note that this list is refreshed periodically and
+	// might be out of date.
+	ActiveInstances []*ActiveInstance `locationName:"activeInstanceSet" locationNameList:"item" type:"list" required:"true"`
+
+	// The token required to retrieve the next set of results. This value is null
+	// when there are no more results to return.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// The ID of the Spot fleet request.
+	SpotFleetRequestID *string `locationName:"spotFleetRequestId" type:"string" required:"true"`
+
+	metadataDescribeSpotFleetInstancesOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeSpotFleetInstancesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeSpotFleetInstancesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeSpotFleetInstancesOutput) GoString() string {
+	return s.String()
+}
+
+// Contains the parameters for DescribeSpotFleetRequestHistory.
+type DescribeSpotFleetRequestHistoryInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The type of events to describe. By default, all events are described.
+	EventType *string `locationName:"eventType" type:"string" enum:"EventType"`
+
+	// The maximum number of results to return in a single call. Specify a value
+	// between 1 and 1000. The default value is 1000. To retrieve the remaining
+	// results, make another call with the returned NextToken value.
+	MaxResults *int64 `locationName:"maxResults" type:"integer"`
+
+	// The token for the next set of results.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// The ID of the Spot fleet request.
+	SpotFleetRequestID *string `locationName:"spotFleetRequestId" type:"string" required:"true"`
+
+	// The starting date and time for the events, in UTC format (for example, YYYY-MM-DDTHH:MM:SSZ).
+	StartTime *time.Time `locationName:"startTime" type:"timestamp" timestampFormat:"iso8601" required:"true"`
+
+	metadataDescribeSpotFleetRequestHistoryInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeSpotFleetRequestHistoryInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeSpotFleetRequestHistoryInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeSpotFleetRequestHistoryInput) GoString() string {
+	return s.String()
+}
+
+// Contains the output of DescribeSpotFleetRequestHistory.
+type DescribeSpotFleetRequestHistoryOutput struct {
+	// Information about the events in the history of the Spot fleet request.
+	HistoryRecords []*HistoryRecord `locationName:"historyRecordSet" locationNameList:"item" type:"list" required:"true"`
+
+	// The last date and time for the events, in UTC format (for example, YYYY-MM-DDTHH:MM:SSZ).
+	// All records up to this time were retrieved.
+	//
+	// If nextToken indicates that there are more results, this value is not present.
+	LastEvaluatedTime *time.Time `locationName:"lastEvaluatedTime" type:"timestamp" timestampFormat:"iso8601" required:"true"`
+
+	// The token required to retrieve the next set of results. This value is null
+	// when there are no more results to return.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// The ID of the Spot fleet request.
+	SpotFleetRequestID *string `locationName:"spotFleetRequestId" type:"string" required:"true"`
+
+	// The starting date and time for the events, in UTC format (for example, YYYY-MM-DDTHH:MM:SSZ).
+	StartTime *time.Time `locationName:"startTime" type:"timestamp" timestampFormat:"iso8601" required:"true"`
+
+	metadataDescribeSpotFleetRequestHistoryOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeSpotFleetRequestHistoryOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeSpotFleetRequestHistoryOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeSpotFleetRequestHistoryOutput) GoString() string {
+	return s.String()
+}
+
+// Contains the parameters for DescribeSpotFleetRequests.
+type DescribeSpotFleetRequestsInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The maximum number of results to return in a single call. Specify a value
+	// between 1 and 1000. The default value is 1000. To retrieve the remaining
+	// results, make another call with the returned NextToken value.
+	MaxResults *int64 `locationName:"maxResults" type:"integer"`
+
+	// The token for the next set of results.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// The IDs of the Spot fleet requests.
+	SpotFleetRequestIDs []*string `locationName:"spotFleetRequestId" locationNameList:"item" type:"list"`
+
+	metadataDescribeSpotFleetRequestsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeSpotFleetRequestsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeSpotFleetRequestsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeSpotFleetRequestsInput) GoString() string {
+	return s.String()
+}
+
+// Contains the output of DescribeSpotFleetRequests.
+type DescribeSpotFleetRequestsOutput struct {
+	// The token required to retrieve the next set of results. This value is null
+	// when there are no more results to return.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// Information about the configuration of your Spot fleet.
+	SpotFleetRequestConfigs []*SpotFleetRequestConfig `locationName:"spotFleetRequestConfigSet" locationNameList:"item" type:"list" required:"true"`
+
+	metadataDescribeSpotFleetRequestsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeSpotFleetRequestsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeSpotFleetRequestsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeSpotFleetRequestsOutput) GoString() string {
+	return s.String()
+}
+
+// Contains the parameters for DescribeSpotInstanceRequests.
+type DescribeSpotInstanceRequestsInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   availability-zone-group - The Availability Zone group.
+	//
+	//   create-time - The time stamp when the Spot Instance request was created.
+	//
+	//   fault-code - The fault code related to the request.
+	//
+	//   fault-message - The fault message related to the request.
+	//
+	//   instance-id - The ID of the instance that fulfilled the request.
+	//
+	//   launch-group - The Spot Instance launch group.
+	//
+	//   launch.block-device-mapping.delete-on-termination - Indicates whether
+	// the Amazon EBS volume is deleted on instance termination.
+	//
+	//   launch.block-device-mapping.device-name - The device name for the Amazon
+	// EBS volume (for example, /dev/sdh).
+	//
+	//   launch.block-device-mapping.snapshot-id - The ID of the snapshot used
+	// for the Amazon EBS volume.
+	//
+	//   launch.block-device-mapping.volume-size - The size of the Amazon EBS volume,
+	// in GiB.
+	//
+	//   launch.block-device-mapping.volume-type - The type of the Amazon EBS volume
+	// (gp2 | standard | io1).
+	//
+	//   launch.group-id - The security group for the instance.
+	//
+	//   launch.image-id - The ID of the AMI.
+	//
+	//   launch.instance-type - The type of instance (for example, m1.small).
+	//
+	//   launch.kernel-id - The kernel ID.
+	//
+	//   launch.key-name - The name of the key pair the instance launched with.
+	//
+	//   launch.monitoring-enabled - Whether monitoring is enabled for the Spot
+	// Instance.
+	//
+	//   launch.ramdisk-id - The RAM disk ID.
+	//
+	//   network-interface.network-interface-id - The ID of the network interface.
+	//
+	//   network-interface.device-index - The index of the device for the network
+	// interface attachment on the instance.
+	//
+	//   network-interface.subnet-id - The ID of the subnet for the instance.
+	//
+	//   network-interface.description - A description of the network interface.
+	//
+	//   network-interface.private-ip-address - The primary private IP address
+	// of the network interface.
+	//
+	//   network-interface.delete-on-termination - Indicates whether the network
+	// interface is deleted when the instance is terminated.
+	//
+	//   network-interface.group-id - The ID of the security group associated with
+	// the network interface.
+	//
+	//   network-interface.group-name - The name of the security group associated
+	// with the network interface.
+	//
+	//   network-interface.addresses.primary - Indicates whether the IP address
+	// is the primary private IP address.
+	//
+	//   product-description - The product description associated with the instance
+	// (Linux/UNIX | Windows).
+	//
+	//   spot-instance-request-id - The Spot Instance request ID.
+	//
+	//   spot-price - The maximum hourly price for any Spot Instance launched to
+	// fulfill the request.
+	//
+	//   state - The state of the Spot Instance request (open | active | closed
+	// | cancelled | failed). Spot bid status information can help you track your
+	// Amazon EC2 Spot Instance requests. For more information, see Spot Bid Status
+	// (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-bid-status.html)
+	// in the Amazon Elastic Compute Cloud User Guide.
+	//
+	//   status-code - The short code describing the most recent evaluation of
+	// your Spot Instance request.
+	//
+	//   status-message - The message explaining the status of the Spot Instance
+	// request.
+	//
+	//   tag:key=value - The key/value combination of a tag assigned to the resource.
+	//
+	//   tag-key - The key of a tag assigned to the resource. This filter is independent
+	// of the tag-value filter. For example, if you use both the filter "tag-key=Purpose"
+	// and the filter "tag-value=X", you get any resources assigned both the tag
+	// key Purpose (regardless of what the tag's value is), and the tag value X
+	// (regardless of what the tag's key is). If you want to list only resources
+	// where Purpose is X, see the tag:key=value filter.
+	//
+	//   tag-value - The value of a tag assigned to the resource. This filter is
+	// independent of the tag-key filter.
+	//
+	//   type - The type of Spot Instance request (one-time | persistent).
+	//
+	//   launched-availability-zone - The Availability Zone in which the bid is
+	// launched.
+	//
+	//   valid-from - The start date of the request.
+	//
+	//   valid-until - The end date of the request.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// One or more Spot Instance request IDs.
+	SpotInstanceRequestIDs []*string `locationName:"SpotInstanceRequestId" locationNameList:"SpotInstanceRequestId" type:"list"`
+
+	metadataDescribeSpotInstanceRequestsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeSpotInstanceRequestsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeSpotInstanceRequestsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeSpotInstanceRequestsInput) GoString() string {
+	return s.String()
+}
+
+// Contains the output of DescribeSpotInstanceRequests.
+type DescribeSpotInstanceRequestsOutput struct {
+	// One or more Spot Instance requests.
+	SpotInstanceRequests []*SpotInstanceRequest `locationName:"spotInstanceRequestSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeSpotInstanceRequestsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeSpotInstanceRequestsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeSpotInstanceRequestsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeSpotInstanceRequestsOutput) GoString() string {
+	return s.String()
+}
+
+// Contains the parameters for DescribeSpotPriceHistory.
+type DescribeSpotPriceHistoryInput struct {
+	// Filters the results by the specified Availability Zone.
+	AvailabilityZone *string `locationName:"availabilityZone" type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The date and time, up to the current date, from which to stop retrieving
+	// the price history data, in UTC format (for example, YYYY-MM-DDTHH:MM:SSZ).
+	EndTime *time.Time `locationName:"endTime" type:"timestamp" timestampFormat:"iso8601"`
+
+	// One or more filters.
+	//
+	//   availability-zone - The Availability Zone for which prices should be returned.
+	//
+	//   instance-type - The type of instance (for example, m1.small).
+	//
+	//   product-description - The product description for the Spot Price (Linux/UNIX
+	// | SUSE Linux | Windows | Linux/UNIX (Amazon VPC) | SUSE Linux (Amazon VPC)
+	// | Windows (Amazon VPC)).
+	//
+	//   spot-price - The Spot Price. The value must match exactly (or use wildcards;
+	// greater than or less than comparison is not supported).
+	//
+	//   timestamp - The timestamp of the Spot Price history, in UTC format (for
+	// example, YYYY-MM-DDTHH:MM:SSZ). You can use wildcards (* and ?). Greater
+	// than or less than comparison is not supported.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// Filters the results by the specified instance types.
+	InstanceTypes []*string `locationName:"InstanceType" type:"list"`
+
+	// The maximum number of results to return in a single call. Specify a value
+	// between 1 and 1000. The default value is 1000. To retrieve the remaining
+	// results, make another call with the returned NextToken value.
+	MaxResults *int64 `locationName:"maxResults" type:"integer"`
+
+	// The token for the next set of results.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// Filters the results by the specified basic product descriptions.
+	ProductDescriptions []*string `locationName:"ProductDescription" type:"list"`
+
+	// The date and time, up to the past 90 days, from which to start retrieving
+	// the price history data, in UTC format (for example, YYYY-MM-DDTHH:MM:SSZ).
+	StartTime *time.Time `locationName:"startTime" type:"timestamp" timestampFormat:"iso8601"`
+
+	metadataDescribeSpotPriceHistoryInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeSpotPriceHistoryInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeSpotPriceHistoryInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeSpotPriceHistoryInput) GoString() string {
+	return s.String()
+}
+
+// Contains the output of DescribeSpotPriceHistory.
+type DescribeSpotPriceHistoryOutput struct {
+	// The token required to retrieve the next set of results. This value is null
+	// when there are no more results to return.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// The historical Spot Prices.
+	SpotPriceHistory []*SpotPrice `locationName:"spotPriceHistorySet" locationNameList:"item" type:"list"`
+
+	metadataDescribeSpotPriceHistoryOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeSpotPriceHistoryOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeSpotPriceHistoryOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeSpotPriceHistoryOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeSubnetsInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   availabilityZone - The Availability Zone for the subnet. You can also
+	// use availability-zone as the filter name.
+	//
+	//   available-ip-address-count - The number of IP addresses in the subnet
+	// that are available.
+	//
+	//   cidrBlock - The CIDR block of the subnet. The CIDR block you specify must
+	// exactly match the subnet's CIDR block for information to be returned for
+	// the subnet. You can also use cidr or cidr-block as the filter names.
+	//
+	//   defaultForAz - Indicates whether this is the default subnet for the Availability
+	// Zone. You can also use default-for-az as the filter name.
+	//
+	//   state - The state of the subnet (pending | available).
+	//
+	//   subnet-id - The ID of the subnet.
+	//
+	//   tag:key=value - The key/value combination of a tag assigned to the resource.
+	//
+	//   tag-key - The key of a tag assigned to the resource. This filter is independent
+	// of the tag-value filter. For example, if you use both the filter "tag-key=Purpose"
+	// and the filter "tag-value=X", you get any resources assigned both the tag
+	// key Purpose (regardless of what the tag's value is), and the tag value X
+	// (regardless of what the tag's key is). If you want to list only resources
+	// where Purpose is X, see the tag:key=value filter.
+	//
+	//   tag-value - The value of a tag assigned to the resource. This filter is
+	// independent of the tag-key filter.
+	//
+	//   vpc-id - The ID of the VPC for the subnet.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// One or more subnet IDs.
+	//
+	// Default: Describes all your subnets.
+	SubnetIDs []*string `locationName:"SubnetId" locationNameList:"SubnetId" type:"list"`
+
+	metadataDescribeSubnetsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeSubnetsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeSubnetsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeSubnetsInput) GoString() string {
+	return s.String()
+}
+
+type DescribeSubnetsOutput struct {
+	// Information about one or more subnets.
+	Subnets []*Subnet `locationName:"subnetSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeSubnetsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeSubnetsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeSubnetsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeSubnetsOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeTagsInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   key - The tag key.
+	//
+	//   resource-id - The resource ID.
+	//
+	//   resource-type - The resource type (customer-gateway | dhcp-options | image
+	// | instance | internet-gateway | network-acl | network-interface | reserved-instances
+	// | route-table | security-group | snapshot | spot-instances-request | subnet
+	// | volume | vpc | vpn-connection | vpn-gateway).
+	//
+	//   value - The tag value.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// The maximum number of results to return for the request in a single page.
+	// The remaining results of the initial request can be seen by sending another
+	// request with the returned NextToken value. This value can be between 5 and
+	// 1000; if MaxResults is given a value larger than 1000, only 1000 results
+	// are returned.
+	MaxResults *int64 `locationName:"maxResults" type:"integer"`
+
+	// The token to retrieve the next page of results.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	metadataDescribeTagsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeTagsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeTagsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeTagsInput) GoString() string {
+	return s.String()
+}
+
+type DescribeTagsOutput struct {
+	// The token to use to retrieve the next page of results. This value is null
+	// when there are no more results to return..
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// A list of tags.
+	Tags []*TagDescription `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeTagsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeTagsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeTagsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeTagsOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeVPCAttributeInput struct {
+	// The VPC attribute.
+	Attribute *string `type:"string" enum:"VpcAttributeName"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"VpcId" type:"string" required:"true"`
+
+	metadataDescribeVPCAttributeInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVPCAttributeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVPCAttributeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVPCAttributeInput) GoString() string {
+	return s.String()
+}
+
+type DescribeVPCAttributeOutput struct {
+	// Indicates whether the instances launched in the VPC get DNS hostnames. If
+	// this attribute is true, instances in the VPC get DNS hostnames; otherwise,
+	// they do not.
+	EnableDNSHostnames *AttributeBooleanValue `locationName:"enableDnsHostnames" type:"structure"`
+
+	// Indicates whether DNS resolution is enabled for the VPC. If this attribute
+	// is true, the Amazon DNS server resolves DNS hostnames for your instances
+	// to their corresponding IP addresses; otherwise, it does not.
+	EnableDNSSupport *AttributeBooleanValue `locationName:"enableDnsSupport" type:"structure"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"vpcId" type:"string"`
+
+	metadataDescribeVPCAttributeOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVPCAttributeOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVPCAttributeOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVPCAttributeOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeVPCClassicLinkInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   is-classic-link-enabled - Whether the VPC is enabled for ClassicLink (true
+	// | false).
+	//
+	//   tag:key=value - The key/value combination of a tag assigned to the resource.
+	//
+	//   tag-key - The key of a tag assigned to the resource. This filter is independent
+	// of the tag-value filter. For example, if you use both the filter "tag-key=Purpose"
+	// and the filter "tag-value=X", you get any resources assigned both the tag
+	// key Purpose (regardless of what the tag's value is), and the tag value X
+	// (regardless of what the tag's key is). If you want to list only resources
+	// where Purpose is X, see the tag:key=value filter.
+	//
+	//   tag-value - The value of a tag assigned to the resource. This filter is
+	// independent of the tag-key filter.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// One or more VPCs for which you want to describe the ClassicLink status.
+	VPCIDs []*string `locationName:"VpcId" locationNameList:"VpcId" type:"list"`
+
+	metadataDescribeVPCClassicLinkInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVPCClassicLinkInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVPCClassicLinkInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVPCClassicLinkInput) GoString() string {
+	return s.String()
+}
+
+type DescribeVPCClassicLinkOutput struct {
+	// The ClassicLink status of one or more VPCs.
+	VPCs []*VPCClassicLink `locationName:"vpcSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeVPCClassicLinkOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVPCClassicLinkOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVPCClassicLinkOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVPCClassicLinkOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeVPCEndpointServicesInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `type:"boolean"`
+
+	// The maximum number of items to return for this request. The request returns
+	// a token that you can specify in a subsequent call to get the next set of
+	// results.
+	//
+	// Constraint: If the value is greater than 1000, we return only 1000 items.
+	MaxResults *int64 `type:"integer"`
+
+	// The token for the next set of items to return. (You received this token from
+	// a prior call.)
+	NextToken *string `type:"string"`
+
+	metadataDescribeVPCEndpointServicesInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVPCEndpointServicesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVPCEndpointServicesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVPCEndpointServicesInput) GoString() string {
+	return s.String()
+}
+
+type DescribeVPCEndpointServicesOutput struct {
+	// The token to use when requesting the next set of items. If there are no additional
+	// items to return, the string is empty.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// A list of supported AWS services.
+	ServiceNames []*string `locationName:"serviceNameSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeVPCEndpointServicesOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVPCEndpointServicesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVPCEndpointServicesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVPCEndpointServicesOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeVPCEndpointsInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `type:"boolean"`
+
+	// One or more filters.
+	//
+	//   service-name: The name of the AWS service.
+	//
+	//   vpc-id: The ID of the VPC in which the endpoint resides.
+	//
+	//   vpc-endpoint-id: The ID of the endpoint.
+	//
+	//   vpc-endpoint-state: The state of the endpoint. (pending | available |
+	// deleting | deleted)
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// The maximum number of items to return for this request. The request returns
+	// a token that you can specify in a subsequent call to get the next set of
+	// results.
+	//
+	// Constraint: If the value is greater than 1000, we return only 1000 items.
+	MaxResults *int64 `type:"integer"`
+
+	// The token for the next set of items to return. (You received this token from
+	// a prior call.)
+	NextToken *string `type:"string"`
+
+	// One or more endpoint IDs.
+	VPCEndpointIDs []*string `locationName:"VpcEndpointId" locationNameList:"item" type:"list"`
+
+	metadataDescribeVPCEndpointsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVPCEndpointsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVPCEndpointsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVPCEndpointsInput) GoString() string {
+	return s.String()
+}
+
+type DescribeVPCEndpointsOutput struct {
+	// The token to use when requesting the next set of items. If there are no additional
+	// items to return, the string is empty.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// Information about the endpoints.
+	VPCEndpoints []*VPCEndpoint `locationName:"vpcEndpointSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeVPCEndpointsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVPCEndpointsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVPCEndpointsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVPCEndpointsOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeVPCPeeringConnectionsInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   accepter-vpc-info.cidr-block - The CIDR block of the peer VPC.
+	//
+	//   accepter-vpc-info.owner-id - The AWS account ID of the owner of the peer
+	// VPC.
+	//
+	//   accepter-vpc-info.vpc-id - The ID of the peer VPC.
+	//
+	//   expiration-time - The expiration date and time for the VPC peering connection.
+	//
+	//   requester-vpc-info.cidr-block - The CIDR block of the requester's VPC.
+	//
+	//   requester-vpc-info.owner-id - The AWS account ID of the owner of the requester
+	// VPC.
+	//
+	//   requester-vpc-info.vpc-id - The ID of the requester VPC.
+	//
+	//   status-code - The status of the VPC peering connection (pending-acceptance
+	// | failed | expired | provisioning | active | deleted | rejected).
+	//
+	//   status-message - A message that provides more information about the status
+	// of the VPC peering connection, if applicable.
+	//
+	//   tag:key=value - The key/value combination of a tag assigned to the resource.
+	//
+	//   tag-key - The key of a tag assigned to the resource. This filter is independent
+	// of the tag-value filter. For example, if you use both the filter "tag-key=Purpose"
+	// and the filter "tag-value=X", you get any resources assigned both the tag
+	// key Purpose (regardless of what the tag's value is), and the tag value X
+	// (regardless of what the tag's key is). If you want to list only resources
+	// where Purpose is X, see the tag:key=value filter.
+	//
+	//   tag-value - The value of a tag assigned to the resource. This filter is
+	// independent of the tag-key filter.
+	//
+	//   vpc-peering-connection-id - The ID of the VPC peering connection.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// One or more VPC peering connection IDs.
+	//
+	// Default: Describes all your VPC peering connections.
+	VPCPeeringConnectionIDs []*string `locationName:"VpcPeeringConnectionId" locationNameList:"item" type:"list"`
+
+	metadataDescribeVPCPeeringConnectionsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVPCPeeringConnectionsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVPCPeeringConnectionsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVPCPeeringConnectionsInput) GoString() string {
+	return s.String()
+}
+
+type DescribeVPCPeeringConnectionsOutput struct {
+	// Information about the VPC peering connections.
+	VPCPeeringConnections []*VPCPeeringConnection `locationName:"vpcPeeringConnectionSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeVPCPeeringConnectionsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVPCPeeringConnectionsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVPCPeeringConnectionsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVPCPeeringConnectionsOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeVPCsInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   cidr - The CIDR block of the VPC. The CIDR block you specify must exactly
+	// match the VPC's CIDR block for information to be returned for the VPC. Must
+	// contain the slash followed by one or two digits (for example, /28).
+	//
+	//   dhcp-options-id - The ID of a set of DHCP options.
+	//
+	//   isDefault - Indicates whether the VPC is the default VPC.
+	//
+	//   state - The state of the VPC (pending | available).
+	//
+	//   tag:key=value - The key/value combination of a tag assigned to the resource.
+	//
+	//   tag-key - The key of a tag assigned to the resource. This filter is independent
+	// of the tag-value filter. For example, if you use both the filter "tag-key=Purpose"
+	// and the filter "tag-value=X", you get any resources assigned both the tag
+	// key Purpose (regardless of what the tag's value is), and the tag value X
+	// (regardless of what the tag's key is). If you want to list only resources
+	// where Purpose is X, see the tag:key=value filter.
+	//
+	//   tag-value - The value of a tag assigned to the resource. This filter is
+	// independent of the tag-key filter.
+	//
+	//   vpc-id - The ID of the VPC.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// One or more VPC IDs.
+	//
+	// Default: Describes all your VPCs.
+	VPCIDs []*string `locationName:"VpcId" locationNameList:"VpcId" type:"list"`
+
+	metadataDescribeVPCsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVPCsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVPCsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVPCsInput) GoString() string {
+	return s.String()
+}
+
+type DescribeVPCsOutput struct {
+	// Information about one or more VPCs.
+	VPCs []*VPC `locationName:"vpcSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeVPCsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVPCsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVPCsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVPCsOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeVPNConnectionsInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   customer-gateway-configuration - The configuration information for the
+	// customer gateway.
+	//
+	//   customer-gateway-id - The ID of a customer gateway associated with the
+	// VPN connection.
+	//
+	//   state - The state of the VPN connection (pending | available | deleting
+	// | deleted).
+	//
+	//   option.static-routes-only - Indicates whether the connection has static
+	// routes only. Used for devices that do not support Border Gateway Protocol
+	// (BGP).
+	//
+	//   route.destination-cidr-block - The destination CIDR block. This corresponds
+	// to the subnet used in a customer data center.
+	//
+	//   bgp-asn - The BGP Autonomous System Number (ASN) associated with a BGP
+	// device.
+	//
+	//   tag:key=value - The key/value combination of a tag assigned to the resource.
+	//
+	//   tag-key - The key of a tag assigned to the resource. This filter is independent
+	// of the tag-value filter. For example, if you use both the filter "tag-key=Purpose"
+	// and the filter "tag-value=X", you get any resources assigned both the tag
+	// key Purpose (regardless of what the tag's value is), and the tag value X
+	// (regardless of what the tag's key is). If you want to list only resources
+	// where Purpose is X, see the tag:key=value filter.
+	//
+	//   tag-value - The value of a tag assigned to the resource. This filter is
+	// independent of the tag-key filter.
+	//
+	//   type - The type of VPN connection. Currently the only supported type is
+	// ipsec.1.
+	//
+	//   vpn-connection-id - The ID of the VPN connection.
+	//
+	//   vpn-gateway-id - The ID of a virtual private gateway associated with the
+	// VPN connection.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// One or more VPN connection IDs.
+	//
+	// Default: Describes your VPN connections.
+	VPNConnectionIDs []*string `locationName:"VpnConnectionId" locationNameList:"VpnConnectionId" type:"list"`
+
+	metadataDescribeVPNConnectionsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVPNConnectionsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVPNConnectionsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVPNConnectionsInput) GoString() string {
+	return s.String()
+}
+
+type DescribeVPNConnectionsOutput struct {
+	// Information about one or more VPN connections.
+	VPNConnections []*VPNConnection `locationName:"vpnConnectionSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeVPNConnectionsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVPNConnectionsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVPNConnectionsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVPNConnectionsOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeVPNGatewaysInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   attachment.state - The current state of the attachment between the gateway
+	// and the VPC (attaching | attached | detaching | detached).
+	//
+	//   attachment.vpc-id - The ID of an attached VPC.
+	//
+	//   availability-zone - The Availability Zone for the virtual private gateway.
+	//
+	//   state - The state of the virtual private gateway (pending | available
+	// | deleting | deleted).
+	//
+	//   tag:key=value - The key/value combination of a tag assigned to the resource.
+	//
+	//   tag-key - The key of a tag assigned to the resource. This filter is independent
+	// of the tag-value filter. For example, if you use both the filter "tag-key=Purpose"
+	// and the filter "tag-value=X", you get any resources assigned both the tag
+	// key Purpose (regardless of what the tag's value is), and the tag value X
+	// (regardless of what the tag's key is). If you want to list only resources
+	// where Purpose is X, see the tag:key=value filter.
+	//
+	//   tag-value - The value of a tag assigned to the resource. This filter is
+	// independent of the tag-key filter.
+	//
+	//   type - The type of virtual private gateway. Currently the only supported
+	// type is ipsec.1.
+	//
+	//   vpn-gateway-id - The ID of the virtual private gateway.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// One or more virtual private gateway IDs.
+	//
+	// Default: Describes all your virtual private gateways.
+	VPNGatewayIDs []*string `locationName:"VpnGatewayId" locationNameList:"VpnGatewayId" type:"list"`
+
+	metadataDescribeVPNGatewaysInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVPNGatewaysInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVPNGatewaysInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVPNGatewaysInput) GoString() string {
+	return s.String()
+}
+
+type DescribeVPNGatewaysOutput struct {
+	// Information about one or more virtual private gateways.
+	VPNGateways []*VPNGateway `locationName:"vpnGatewaySet" locationNameList:"item" type:"list"`
+
+	metadataDescribeVPNGatewaysOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVPNGatewaysOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVPNGatewaysOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVPNGatewaysOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeVolumeAttributeInput struct {
+	// The instance attribute.
+	Attribute *string `type:"string" enum:"VolumeAttributeName"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the volume.
+	VolumeID *string `locationName:"VolumeId" type:"string" required:"true"`
+
+	metadataDescribeVolumeAttributeInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVolumeAttributeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVolumeAttributeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVolumeAttributeInput) GoString() string {
+	return s.String()
+}
+
+type DescribeVolumeAttributeOutput struct {
+	// The state of autoEnableIO attribute.
+	AutoEnableIO *AttributeBooleanValue `locationName:"autoEnableIO" type:"structure"`
+
+	// A list of product codes.
+	ProductCodes []*ProductCode `locationName:"productCodes" locationNameList:"item" type:"list"`
+
+	// The ID of the volume.
+	VolumeID *string `locationName:"volumeId" type:"string"`
+
+	metadataDescribeVolumeAttributeOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVolumeAttributeOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVolumeAttributeOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVolumeAttributeOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeVolumeStatusInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   action.code - The action code for the event (for example, enable-volume-io).
+	//
+	//   action.description - A description of the action.
+	//
+	//   action.event-id - The event ID associated with the action.
+	//
+	//   availability-zone - The Availability Zone of the instance.
+	//
+	//   event.description - A description of the event.
+	//
+	//   event.event-id - The event ID.
+	//
+	//   event.event-type - The event type (for io-enabled: passed | failed; for
+	// io-performance: io-performance:degraded | io-performance:severely-degraded
+	// | io-performance:stalled).
+	//
+	//   event.not-after - The latest end time for the event.
+	//
+	//   event.not-before - The earliest start time for the event.
+	//
+	//   volume-status.details-name - The cause for volume-status.status (io-enabled
+	// | io-performance).
+	//
+	//   volume-status.details-status - The status of volume-status.details-name
+	// (for io-enabled: passed | failed; for io-performance: normal | degraded |
+	// severely-degraded | stalled).
+	//
+	//   volume-status.status - The status of the volume (ok | impaired | warning
+	// | insufficient-data).
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// The maximum number of volume results returned by DescribeVolumeStatus in
+	// paginated output. When this parameter is used, the request only returns MaxResults
+	// results in a single page along with a NextToken response element. The remaining
+	// results of the initial request can be seen by sending another request with
+	// the returned NextToken value. This value can be between 5 and 1000; if MaxResults
+	// is given a value larger than 1000, only 1000 results are returned. If this
+	// parameter is not used, then DescribeVolumeStatus returns all results. You
+	// cannot specify this parameter and the volume IDs parameter in the same request.
+	MaxResults *int64 `type:"integer"`
+
+	// The NextToken value to include in a future DescribeVolumeStatus request.
+	// When the results of the request exceed MaxResults, this value can be used
+	// to retrieve the next page of results. This value is null when there are no
+	// more results to return.
+	NextToken *string `type:"string"`
+
+	// One or more volume IDs.
+	//
+	// Default: Describes all your volumes.
+	VolumeIDs []*string `locationName:"VolumeId" locationNameList:"VolumeId" type:"list"`
+
+	metadataDescribeVolumeStatusInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVolumeStatusInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVolumeStatusInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVolumeStatusInput) GoString() string {
+	return s.String()
+}
+
+type DescribeVolumeStatusOutput struct {
+	// The token to use to retrieve the next page of results. This value is null
+	// when there are no more results to return.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// A list of volumes.
+	VolumeStatuses []*VolumeStatusItem `locationName:"volumeStatusSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeVolumeStatusOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVolumeStatusOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVolumeStatusOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVolumeStatusOutput) GoString() string {
+	return s.String()
+}
+
+type DescribeVolumesInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more filters.
+	//
+	//   attachment.attach-time - The time stamp when the attachment initiated.
+	//
+	//   attachment.delete-on-termination - Whether the volume is deleted on instance
+	// termination.
+	//
+	//   attachment.device - The device name that is exposed to the instance (for
+	// example, /dev/sda1).
+	//
+	//   attachment.instance-id - The ID of the instance the volume is attached
+	// to.
+	//
+	//   attachment.status - The attachment state (attaching | attached | detaching
+	// | detached).
+	//
+	//   availability-zone - The Availability Zone in which the volume was created.
+	//
+	//   create-time - The time stamp when the volume was created.
+	//
+	//   encrypted - The encryption status of the volume.
+	//
+	//   size - The size of the volume, in GiB.
+	//
+	//   snapshot-id - The snapshot from which the volume was created.
+	//
+	//   status - The status of the volume (creating | available | in-use | deleting
+	// | deleted | error).
+	//
+	//   tag:key=value - The key/value combination of a tag assigned to the resource.
+	//
+	//   tag-key - The key of a tag assigned to the resource. This filter is independent
+	// of the tag-value filter. For example, if you use both the filter "tag-key=Purpose"
+	// and the filter "tag-value=X", you get any resources assigned both the tag
+	// key Purpose (regardless of what the tag's value is), and the tag value X
+	// (regardless of what the tag's key is). If you want to list only resources
+	// where Purpose is X, see the tag:key=value filter.
+	//
+	//   tag-value - The value of a tag assigned to the resource. This filter is
+	// independent of the tag-key filter.
+	//
+	//   volume-id - The volume ID.
+	//
+	//   volume-type - The Amazon EBS volume type. This can be gp2 for General
+	// Purpose (SSD) volumes, io1 for Provisioned IOPS (SSD) volumes, or standard
+	// for Magnetic volumes.
+	Filters []*Filter `locationName:"Filter" locationNameList:"Filter" type:"list"`
+
+	// The maximum number of volume results returned by DescribeVolumes in paginated
+	// output. When this parameter is used, DescribeVolumes only returns MaxResults
+	// results in a single page along with a NextToken response element. The remaining
+	// results of the initial request can be seen by sending another DescribeVolumes
+	// request with the returned NextToken value. This value can be between 5 and
+	// 1000; if MaxResults is given a value larger than 1000, only 1000 results
+	// are returned. If this parameter is not used, then DescribeVolumes returns
+	// all results. You cannot specify this parameter and the volume IDs parameter
+	// in the same request.
+	MaxResults *int64 `locationName:"maxResults" type:"integer"`
+
+	// The NextToken value returned from a previous paginated DescribeVolumes request
+	// where MaxResults was used and the results exceeded the value of that parameter.
+	// Pagination continues from the end of the previous results that returned the
+	// NextToken value. This value is null when there are no more results to return.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// One or more volume IDs.
+	VolumeIDs []*string `locationName:"VolumeId" locationNameList:"VolumeId" type:"list"`
+
+	metadataDescribeVolumesInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVolumesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVolumesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVolumesInput) GoString() string {
+	return s.String()
+}
+
+type DescribeVolumesOutput struct {
+	// The NextToken value to include in a future DescribeVolumes request. When
+	// the results of a DescribeVolumes request exceed MaxResults, this value can
+	// be used to retrieve the next page of results. This value is null when there
+	// are no more results to return.
+	NextToken *string `locationName:"nextToken" type:"string"`
+
+	// Information about the volumes.
+	Volumes []*Volume `locationName:"volumeSet" locationNameList:"item" type:"list"`
+
+	metadataDescribeVolumesOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeVolumesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DescribeVolumesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DescribeVolumesOutput) GoString() string {
+	return s.String()
+}
+
+type DetachClassicLinkVPCInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the instance to unlink from the VPC.
+	InstanceID *string `locationName:"instanceId" type:"string" required:"true"`
+
+	// The ID of the VPC to which the instance is linked.
+	VPCID *string `locationName:"vpcId" type:"string" required:"true"`
+
+	metadataDetachClassicLinkVPCInput `json:"-" xml:"-"`
+}
+
+type metadataDetachClassicLinkVPCInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DetachClassicLinkVPCInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DetachClassicLinkVPCInput) GoString() string {
+	return s.String()
+}
+
+type DetachClassicLinkVPCOutput struct {
+	// Returns true if the request succeeds; otherwise, it returns an error.
+	Return *bool `locationName:"return" type:"boolean"`
+
+	metadataDetachClassicLinkVPCOutput `json:"-" xml:"-"`
+}
+
+type metadataDetachClassicLinkVPCOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DetachClassicLinkVPCOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DetachClassicLinkVPCOutput) GoString() string {
+	return s.String()
+}
+
+type DetachInternetGatewayInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the Internet gateway.
+	InternetGatewayID *string `locationName:"internetGatewayId" type:"string" required:"true"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"vpcId" type:"string" required:"true"`
+
+	metadataDetachInternetGatewayInput `json:"-" xml:"-"`
+}
+
+type metadataDetachInternetGatewayInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DetachInternetGatewayInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DetachInternetGatewayInput) GoString() string {
+	return s.String()
+}
+
+type DetachInternetGatewayOutput struct {
+	metadataDetachInternetGatewayOutput `json:"-" xml:"-"`
+}
+
+type metadataDetachInternetGatewayOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DetachInternetGatewayOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DetachInternetGatewayOutput) GoString() string {
+	return s.String()
+}
+
+type DetachNetworkInterfaceInput struct {
+	// The ID of the attachment.
+	AttachmentID *string `locationName:"attachmentId" type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// Specifies whether to force a detachment.
+	Force *bool `locationName:"force" type:"boolean"`
+
+	metadataDetachNetworkInterfaceInput `json:"-" xml:"-"`
+}
+
+type metadataDetachNetworkInterfaceInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DetachNetworkInterfaceInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DetachNetworkInterfaceInput) GoString() string {
+	return s.String()
+}
+
+type DetachNetworkInterfaceOutput struct {
+	metadataDetachNetworkInterfaceOutput `json:"-" xml:"-"`
+}
+
+type metadataDetachNetworkInterfaceOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DetachNetworkInterfaceOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DetachNetworkInterfaceOutput) GoString() string {
+	return s.String()
+}
+
+type DetachVPNGatewayInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"VpcId" type:"string" required:"true"`
+
+	// The ID of the virtual private gateway.
+	VPNGatewayID *string `locationName:"VpnGatewayId" type:"string" required:"true"`
+
+	metadataDetachVPNGatewayInput `json:"-" xml:"-"`
+}
+
+type metadataDetachVPNGatewayInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DetachVPNGatewayInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DetachVPNGatewayInput) GoString() string {
+	return s.String()
+}
+
+type DetachVPNGatewayOutput struct {
+	metadataDetachVPNGatewayOutput `json:"-" xml:"-"`
+}
+
+type metadataDetachVPNGatewayOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DetachVPNGatewayOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DetachVPNGatewayOutput) GoString() string {
+	return s.String()
+}
+
+type DetachVolumeInput struct {
+	// The device name.
+	Device *string `type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// Forces detachment if the previous detachment attempt did not occur cleanly
+	// (for example, logging into an instance, unmounting the volume, and detaching
+	// normally). This option can lead to data loss or a corrupted file system.
+	// Use this option only as a last resort to detach a volume from a failed instance.
+	// The instance won't have an opportunity to flush file system caches or file
+	// system metadata. If you use this option, you must perform file system check
+	// and repair procedures.
+	Force *bool `type:"boolean"`
+
+	// The ID of the instance.
+	InstanceID *string `locationName:"InstanceId" type:"string"`
+
+	// The ID of the volume.
+	VolumeID *string `locationName:"VolumeId" type:"string" required:"true"`
+
+	metadataDetachVolumeInput `json:"-" xml:"-"`
+}
+
+type metadataDetachVolumeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DetachVolumeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DetachVolumeInput) GoString() string {
+	return s.String()
+}
+
+type DisableVGWRoutePropagationInput struct {
+	// The ID of the virtual private gateway.
+	GatewayID *string `locationName:"GatewayId" type:"string" required:"true"`
+
+	// The ID of the route table.
+	RouteTableID *string `locationName:"RouteTableId" type:"string" required:"true"`
+
+	metadataDisableVGWRoutePropagationInput `json:"-" xml:"-"`
+}
+
+type metadataDisableVGWRoutePropagationInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DisableVGWRoutePropagationInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DisableVGWRoutePropagationInput) GoString() string {
+	return s.String()
+}
+
+type DisableVGWRoutePropagationOutput struct {
+	metadataDisableVGWRoutePropagationOutput `json:"-" xml:"-"`
+}
+
+type metadataDisableVGWRoutePropagationOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DisableVGWRoutePropagationOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DisableVGWRoutePropagationOutput) GoString() string {
+	return s.String()
+}
+
+type DisableVPCClassicLinkInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"vpcId" type:"string" required:"true"`
+
+	metadataDisableVPCClassicLinkInput `json:"-" xml:"-"`
+}
+
+type metadataDisableVPCClassicLinkInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DisableVPCClassicLinkInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DisableVPCClassicLinkInput) GoString() string {
+	return s.String()
+}
+
+type DisableVPCClassicLinkOutput struct {
+	// Returns true if the request succeeds; otherwise, it returns an error.
+	Return *bool `locationName:"return" type:"boolean"`
+
+	metadataDisableVPCClassicLinkOutput `json:"-" xml:"-"`
+}
+
+type metadataDisableVPCClassicLinkOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DisableVPCClassicLinkOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DisableVPCClassicLinkOutput) GoString() string {
+	return s.String()
+}
+
+type DisassociateAddressInput struct {
+	// [EC2-VPC] The association ID. Required for EC2-VPC.
+	AssociationID *string `locationName:"AssociationId" type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// [EC2-Classic] The Elastic IP address. Required for EC2-Classic.
+	PublicIP *string `locationName:"PublicIp" type:"string"`
+
+	metadataDisassociateAddressInput `json:"-" xml:"-"`
+}
+
+type metadataDisassociateAddressInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DisassociateAddressInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DisassociateAddressInput) GoString() string {
+	return s.String()
+}
+
+type DisassociateAddressOutput struct {
+	metadataDisassociateAddressOutput `json:"-" xml:"-"`
+}
+
+type metadataDisassociateAddressOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DisassociateAddressOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DisassociateAddressOutput) GoString() string {
+	return s.String()
+}
+
+type DisassociateRouteTableInput struct {
+	// The association ID representing the current association between the route
+	// table and subnet.
+	AssociationID *string `locationName:"associationId" type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	metadataDisassociateRouteTableInput `json:"-" xml:"-"`
+}
+
+type metadataDisassociateRouteTableInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DisassociateRouteTableInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DisassociateRouteTableInput) GoString() string {
+	return s.String()
+}
+
+type DisassociateRouteTableOutput struct {
+	metadataDisassociateRouteTableOutput `json:"-" xml:"-"`
+}
+
+type metadataDisassociateRouteTableOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DisassociateRouteTableOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DisassociateRouteTableOutput) GoString() string {
+	return s.String()
+}
+
+// Describes a disk image.
+type DiskImage struct {
+	// A description of the disk image.
+	Description *string `type:"string"`
+
+	// Information about the disk image.
+	Image *DiskImageDetail `type:"structure"`
+
+	// Information about the volume.
+	Volume *VolumeDetail `type:"structure"`
+
+	metadataDiskImage `json:"-" xml:"-"`
+}
+
+type metadataDiskImage struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DiskImage) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DiskImage) GoString() string {
+	return s.String()
+}
+
+// Describes a disk image.
+type DiskImageDescription struct {
+	// The checksum computed for the disk image.
+	Checksum *string `locationName:"checksum" type:"string"`
+
+	// The disk image format.
+	Format *string `locationName:"format" type:"string" required:"true" enum:"DiskImageFormat"`
+
+	// A presigned URL for the import manifest stored in Amazon S3. For information
+	// about creating a presigned URL for an Amazon S3 object, read the "Query String
+	// Request Authentication Alternative" section of the Authenticating REST Requests
+	// (http://docs.aws.amazon.com/AmazonS3/latest/dev/RESTAuthentication.html)
+	// topic in the Amazon Simple Storage Service Developer Guide.
+	ImportManifestURL *string `locationName:"importManifestUrl" type:"string" required:"true"`
+
+	// The size of the disk image, in GiB.
+	Size *int64 `locationName:"size" type:"long" required:"true"`
+
+	metadataDiskImageDescription `json:"-" xml:"-"`
+}
+
+type metadataDiskImageDescription struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DiskImageDescription) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DiskImageDescription) GoString() string {
+	return s.String()
+}
+
+// Describes a disk image.
+type DiskImageDetail struct {
+	// The size of the disk image, in GiB.
+	Bytes *int64 `locationName:"bytes" type:"long" required:"true"`
+
+	// The disk image format.
+	Format *string `locationName:"format" type:"string" required:"true" enum:"DiskImageFormat"`
+
+	// A presigned URL for the import manifest stored in Amazon S3 and presented
+	// here as an Amazon S3 presigned URL. For information about creating a presigned
+	// URL for an Amazon S3 object, read the "Query String Request Authentication
+	// Alternative" section of the Authenticating REST Requests (http://docs.aws.amazon.com/AmazonS3/latest/dev/RESTAuthentication.html)
+	// topic in the Amazon Simple Storage Service Developer Guide.
+	ImportManifestURL *string `locationName:"importManifestUrl" type:"string" required:"true"`
+
+	metadataDiskImageDetail `json:"-" xml:"-"`
+}
+
+type metadataDiskImageDetail struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DiskImageDetail) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DiskImageDetail) GoString() string {
+	return s.String()
+}
+
+// Describes a disk image volume.
+type DiskImageVolumeDescription struct {
+	// The volume identifier.
+	ID *string `locationName:"id" type:"string" required:"true"`
+
+	// The size of the volume, in GiB.
+	Size *int64 `locationName:"size" type:"long"`
+
+	metadataDiskImageVolumeDescription `json:"-" xml:"-"`
+}
+
+type metadataDiskImageVolumeDescription struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s DiskImageVolumeDescription) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DiskImageVolumeDescription) GoString() string {
+	return s.String()
+}
+
+// Describes a block device for an EBS volume.
+type EBSBlockDevice struct {
+	// Indicates whether the EBS volume is deleted on instance termination.
+	DeleteOnTermination *bool `locationName:"deleteOnTermination" type:"boolean"`
+
+	// Indicates whether the EBS volume is encrypted. Encrypted Amazon EBS volumes
+	// may only be attached to instances that support Amazon EBS encryption.
+	Encrypted *bool `locationName:"encrypted" type:"boolean"`
+
+	// The number of I/O operations per second (IOPS) that the volume supports.
+	// For Provisioned IOPS (SSD) volumes, this represents the number of IOPS that
+	// are provisioned for the volume. For General Purpose (SSD) volumes, this represents
+	// the baseline performance of the volume and the rate at which the volume accumulates
+	// I/O credits for bursting. For more information on General Purpose (SSD) baseline
+	// performance, I/O credits, and bursting, see Amazon EBS Volume Types (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html)
+	// in the Amazon Elastic Compute Cloud User Guide.
+	//
+	// Constraint: Range is 100 to 20000 for Provisioned IOPS (SSD) volumes and
+	// 3 to 10000 for General Purpose (SSD) volumes.
+	//
+	// Condition: This parameter is required for requests to create io1 volumes;
+	// it is not used in requests to create standard or gp2 volumes.
+	IOPS *int64 `locationName:"iops" type:"integer"`
+
+	// The ID of the snapshot.
+	SnapshotID *string `locationName:"snapshotId" type:"string"`
+
+	// The size of the volume, in GiB.
+	//
+	// Constraints: 1-1024 for standard volumes, 1-16384 for gp2 volumes, and 4-16384
+	// for io1 volumes. If you specify a snapshot, the volume size must be equal
+	// to or larger than the snapshot size.
+	//
+	// Default: If you're creating the volume from a snapshot and don't specify
+	// a volume size, the default is the snapshot size.
+	VolumeSize *int64 `locationName:"volumeSize" type:"integer"`
+
+	// The volume type. gp2 for General Purpose (SSD) volumes, io1 for Provisioned
+	// IOPS (SSD) volumes, and standard for Magnetic volumes.
+	//
+	// Default: standard
+	VolumeType *string `locationName:"volumeType" type:"string" enum:"VolumeType"`
+
+	metadataEBSBlockDevice `json:"-" xml:"-"`
+}
+
+type metadataEBSBlockDevice struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s EBSBlockDevice) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s EBSBlockDevice) GoString() string {
+	return s.String()
+}
+
+// Describes a parameter used to set up an EBS volume in a block device mapping.
+type EBSInstanceBlockDevice struct {
+	// The time stamp when the attachment initiated.
+	AttachTime *time.Time `locationName:"attachTime" type:"timestamp" timestampFormat:"iso8601"`
+
+	// Indicates whether the volume is deleted on instance termination.
+	DeleteOnTermination *bool `locationName:"deleteOnTermination" type:"boolean"`
+
+	// The attachment state.
+	Status *string `locationName:"status" type:"string" enum:"AttachmentStatus"`
+
+	// The ID of the EBS volume.
+	VolumeID *string `locationName:"volumeId" type:"string"`
+
+	metadataEBSInstanceBlockDevice `json:"-" xml:"-"`
+}
+
+type metadataEBSInstanceBlockDevice struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s EBSInstanceBlockDevice) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s EBSInstanceBlockDevice) GoString() string {
+	return s.String()
+}
+
+type EBSInstanceBlockDeviceSpecification struct {
+	// Indicates whether the volume is deleted on instance termination.
+	DeleteOnTermination *bool `locationName:"deleteOnTermination" type:"boolean"`
+
+	// The ID of the EBS volume.
+	VolumeID *string `locationName:"volumeId" type:"string"`
+
+	metadataEBSInstanceBlockDeviceSpecification `json:"-" xml:"-"`
+}
+
+type metadataEBSInstanceBlockDeviceSpecification struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s EBSInstanceBlockDeviceSpecification) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s EBSInstanceBlockDeviceSpecification) GoString() string {
+	return s.String()
+}
+
+type EnableVGWRoutePropagationInput struct {
+	// The ID of the virtual private gateway.
+	GatewayID *string `locationName:"GatewayId" type:"string" required:"true"`
+
+	// The ID of the route table.
+	RouteTableID *string `locationName:"RouteTableId" type:"string" required:"true"`
+
+	metadataEnableVGWRoutePropagationInput `json:"-" xml:"-"`
+}
+
+type metadataEnableVGWRoutePropagationInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s EnableVGWRoutePropagationInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s EnableVGWRoutePropagationInput) GoString() string {
+	return s.String()
+}
+
+type EnableVGWRoutePropagationOutput struct {
+	metadataEnableVGWRoutePropagationOutput `json:"-" xml:"-"`
+}
+
+type metadataEnableVGWRoutePropagationOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s EnableVGWRoutePropagationOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s EnableVGWRoutePropagationOutput) GoString() string {
+	return s.String()
+}
+
+type EnableVPCClassicLinkInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"vpcId" type:"string" required:"true"`
+
+	metadataEnableVPCClassicLinkInput `json:"-" xml:"-"`
+}
+
+type metadataEnableVPCClassicLinkInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s EnableVPCClassicLinkInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s EnableVPCClassicLinkInput) GoString() string {
+	return s.String()
+}
+
+type EnableVPCClassicLinkOutput struct {
+	// Returns true if the request succeeds; otherwise, it returns an error.
+	Return *bool `locationName:"return" type:"boolean"`
+
+	metadataEnableVPCClassicLinkOutput `json:"-" xml:"-"`
+}
+
+type metadataEnableVPCClassicLinkOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s EnableVPCClassicLinkOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s EnableVPCClassicLinkOutput) GoString() string {
+	return s.String()
+}
+
+type EnableVolumeIOInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the volume.
+	VolumeID *string `locationName:"volumeId" type:"string" required:"true"`
+
+	metadataEnableVolumeIOInput `json:"-" xml:"-"`
+}
+
+type metadataEnableVolumeIOInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s EnableVolumeIOInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s EnableVolumeIOInput) GoString() string {
+	return s.String()
+}
+
+type EnableVolumeIOOutput struct {
+	metadataEnableVolumeIOOutput `json:"-" xml:"-"`
+}
+
+type metadataEnableVolumeIOOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s EnableVolumeIOOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s EnableVolumeIOOutput) GoString() string {
+	return s.String()
+}
+
+// Describes a Spot fleet event.
+type EventInformation struct {
+	// The description of the event.
+	EventDescription *string `locationName:"eventDescription" type:"string"`
+
+	// The event.
+	//
+	// The following are the error events.
+	//
+	//   iamFleetRoleInvalid - Spot fleet did not have the required permissions
+	// either to launch or terminate an instance.
+	//
+	//   spotFleetRequestConfigurationInvalid - The configuration is not valid.
+	// For more information, see the description.
+	//
+	//   spotInstanceCountLimitExceeded - You've reached the limit on the number
+	// of Spot Instances that you can launch.
+	//
+	//   The following are the fleetRequestChange events.
+	//
+	//   active - The Spot fleet has been validated and Amazon EC2 is attempting
+	// to maintain the target number of running Spot Instances.
+	//
+	//   cancelled - The Spot fleet is canceled and has no running Spot Instances.
+	// The Spot fleet will be deleted two days after its instances were terminated.
+	//
+	//   cancelled_running - The Spot fleet is canceled and will not launch additional
+	// Spot Instances, but its existing Spot Instances will continue to run until
+	// they are interrupted or terminated.
+	//
+	//   cancelled_terminating - The Spot fleet is canceled and its Spot Instances
+	// are terminating.
+	//
+	//   expired - The Spot fleet request has expired. A subsequent event indicates
+	// that the instances were terminated, if the request was created with terminateInstancesWithExpiration
+	// set.
+	//
+	//   price_update - The bid price for a launch configuration was adjusted because
+	// it was too high. This change is permanent.
+	//
+	//   submitted - The Spot fleet request is being evaluated and Amazon EC2 is
+	// preparing to launch the target number of Spot Instances.
+	//
+	//   The following are the instanceChange events.
+	//
+	//   launched - A bid was fulfilled and a new instance was launched.
+	//
+	//   terminated - An instance was terminated by the user.
+	EventSubType *string `locationName:"eventSubType" type:"string"`
+
+	// The ID of the instance. This information is available only for instanceChange
+	// events.
+	InstanceID *string `locationName:"instanceId" type:"string"`
+
+	metadataEventInformation `json:"-" xml:"-"`
+}
+
+type metadataEventInformation struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s EventInformation) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s EventInformation) GoString() string {
+	return s.String()
+}
+
+// Describes an instance export task.
+type ExportTask struct {
+	// A description of the resource being exported.
+	Description *string `locationName:"description" type:"string"`
+
+	// The ID of the export task.
+	ExportTaskID *string `locationName:"exportTaskId" type:"string"`
+
+	// Information about the export task.
+	ExportToS3Task *ExportToS3Task `locationName:"exportToS3" type:"structure"`
+
+	// Information about the instance to export.
+	InstanceExportDetails *InstanceExportDetails `locationName:"instanceExport" type:"structure"`
+
+	// The state of the export task.
+	State *string `locationName:"state" type:"string" enum:"ExportTaskState"`
+
+	// The status message related to the export task.
+	StatusMessage *string `locationName:"statusMessage" type:"string"`
+
+	metadataExportTask `json:"-" xml:"-"`
+}
+
+type metadataExportTask struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ExportTask) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ExportTask) GoString() string {
+	return s.String()
+}
+
+// Describes the format and location for an instance export task.
+type ExportToS3Task struct {
+	// The container format used to combine disk images with metadata (such as OVF).
+	// If absent, only the disk image is exported.
+	ContainerFormat *string `locationName:"containerFormat" type:"string" enum:"ContainerFormat"`
+
+	// The format for the exported image.
+	DiskImageFormat *string `locationName:"diskImageFormat" type:"string" enum:"DiskImageFormat"`
+
+	// The S3 bucket for the destination image. The destination bucket must exist
+	// and grant WRITE and READ_ACP permissions to the AWS account vm-import-export@amazon.com.
+	S3Bucket *string `locationName:"s3Bucket" type:"string"`
+
+	// The encryption key for your S3 bucket.
+	S3Key *string `locationName:"s3Key" type:"string"`
+
+	metadataExportToS3Task `json:"-" xml:"-"`
+}
+
+type metadataExportToS3Task struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ExportToS3Task) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ExportToS3Task) GoString() string {
+	return s.String()
+}
+
+// Describes an instance export task.
+type ExportToS3TaskSpecification struct {
+	// The container format used to combine disk images with metadata (such as OVF).
+	// If absent, only the disk image is exported.
+	ContainerFormat *string `locationName:"containerFormat" type:"string" enum:"ContainerFormat"`
+
+	// The format for the exported image.
+	DiskImageFormat *string `locationName:"diskImageFormat" type:"string" enum:"DiskImageFormat"`
+
+	// The S3 bucket for the destination image. The destination bucket must exist
+	// and grant WRITE and READ_ACP permissions to the AWS account vm-import-export@amazon.com.
+	S3Bucket *string `locationName:"s3Bucket" type:"string"`
+
+	// The image is written to a single object in the S3 bucket at the S3 key s3prefix
+	// + exportTaskId + '.' + diskImageFormat.
+	S3Prefix *string `locationName:"s3Prefix" type:"string"`
+
+	metadataExportToS3TaskSpecification `json:"-" xml:"-"`
+}
+
+type metadataExportToS3TaskSpecification struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ExportToS3TaskSpecification) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ExportToS3TaskSpecification) GoString() string {
+	return s.String()
+}
+
+// A filter name and value pair that is used to return a more specific list
+// of results. Filters can be used to match a set of resources by various criteria,
+// such as tags, attributes, or IDs.
+type Filter struct {
+	// The name of the filter. Filter names are case-sensitive.
+	Name *string `type:"string"`
+
+	// One or more filter values. Filter values are case-sensitive.
+	Values []*string `locationName:"Value" locationNameList:"item" type:"list"`
+
+	metadataFilter `json:"-" xml:"-"`
+}
+
+type metadataFilter struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s Filter) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Filter) GoString() string {
+	return s.String()
+}
+
+// Describes a flow log.
+type FlowLog struct {
+	// The date and time the flow log was created.
+	CreationTime *time.Time `locationName:"creationTime" type:"timestamp" timestampFormat:"iso8601"`
+
+	// Information about the error that occurred. Rate limited indicates that CloudWatch
+	// logs throttling has been applied for one or more network interfaces. Access
+	// error indicates that the IAM role associated with the flow log does not have
+	// sufficient permissions to publish to CloudWatch Logs. Unknown error indicates
+	// an internal error.
+	DeliverLogsErrorMessage *string `locationName:"deliverLogsErrorMessage" type:"string"`
+
+	// The ARN of the IAM role that posts logs to CloudWatch Logs.
+	DeliverLogsPermissionARN *string `locationName:"deliverLogsPermissionArn" type:"string"`
+
+	// The status of the logs delivery (SUCCESS | FAILED).
+	DeliverLogsStatus *string `locationName:"deliverLogsStatus" type:"string"`
+
+	// The flow log ID.
+	FlowLogID *string `locationName:"flowLogId" type:"string"`
+
+	// The status of the flow log (ACTIVE).
+	FlowLogStatus *string `locationName:"flowLogStatus" type:"string"`
+
+	// The name of the flow log group.
+	LogGroupName *string `locationName:"logGroupName" type:"string"`
+
+	// The ID of the resource on which the flow log was created.
+	ResourceID *string `locationName:"resourceId" type:"string"`
+
+	// The type of traffic captured for the flow log.
+	TrafficType *string `locationName:"trafficType" type:"string" enum:"TrafficType"`
+
+	metadataFlowLog `json:"-" xml:"-"`
+}
+
+type metadataFlowLog struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s FlowLog) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s FlowLog) GoString() string {
+	return s.String()
+}
+
+type GetConsoleOutputInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the instance.
+	InstanceID *string `locationName:"InstanceId" type:"string" required:"true"`
+
+	metadataGetConsoleOutputInput `json:"-" xml:"-"`
+}
+
+type metadataGetConsoleOutputInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s GetConsoleOutputInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetConsoleOutputInput) GoString() string {
+	return s.String()
+}
+
+type GetConsoleOutputOutput struct {
+	// The ID of the instance.
+	InstanceID *string `locationName:"instanceId" type:"string"`
+
+	// The console output, Base64 encoded.
+	Output *string `locationName:"output" type:"string"`
+
+	// The time the output was last updated.
+	Timestamp *time.Time `locationName:"timestamp" type:"timestamp" timestampFormat:"iso8601"`
+
+	metadataGetConsoleOutputOutput `json:"-" xml:"-"`
+}
+
+type metadataGetConsoleOutputOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s GetConsoleOutputOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetConsoleOutputOutput) GoString() string {
+	return s.String()
+}
+
+type GetPasswordDataInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the Windows instance.
+	InstanceID *string `locationName:"InstanceId" type:"string" required:"true"`
+
+	metadataGetPasswordDataInput `json:"-" xml:"-"`
+}
+
+type metadataGetPasswordDataInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s GetPasswordDataInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetPasswordDataInput) GoString() string {
+	return s.String()
+}
+
+type GetPasswordDataOutput struct {
+	// The ID of the Windows instance.
+	InstanceID *string `locationName:"instanceId" type:"string"`
+
+	// The password of the instance.
+	PasswordData *string `locationName:"passwordData" type:"string"`
+
+	// The time the data was last updated.
+	Timestamp *time.Time `locationName:"timestamp" type:"timestamp" timestampFormat:"iso8601"`
+
+	metadataGetPasswordDataOutput `json:"-" xml:"-"`
+}
+
+type metadataGetPasswordDataOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s GetPasswordDataOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetPasswordDataOutput) GoString() string {
+	return s.String()
+}
+
+// Describes a security group.
+type GroupIdentifier struct {
+	// The ID of the security group.
+	GroupID *string `locationName:"groupId" type:"string"`
+
+	// The name of the security group.
+	GroupName *string `locationName:"groupName" type:"string"`
+
+	metadataGroupIdentifier `json:"-" xml:"-"`
+}
+
+type metadataGroupIdentifier struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s GroupIdentifier) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GroupIdentifier) GoString() string {
+	return s.String()
+}
+
+// Describes an event in the history of the Spot fleet request.
+type HistoryRecord struct {
+	// Information about the event.
+	EventInformation *EventInformation `locationName:"eventInformation" type:"structure" required:"true"`
+
+	// The event type.
+	//
+	//   error - Indicates an error with the Spot fleet request.
+	//
+	//   fleetRequestChange - Indicates a change in the status or configuration
+	// of the Spot fleet request.
+	//
+	//   instanceChange - Indicates that an instance was launched or terminated.
+	EventType *string `locationName:"eventType" type:"string" required:"true" enum:"EventType"`
+
+	// The date and time of the event, in UTC format (for example, YYYY-MM-DDTHH:MM:SSZ).
+	Timestamp *time.Time `locationName:"timestamp" type:"timestamp" timestampFormat:"iso8601" required:"true"`
+
+	metadataHistoryRecord `json:"-" xml:"-"`
+}
+
+type metadataHistoryRecord struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s HistoryRecord) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s HistoryRecord) GoString() string {
+	return s.String()
+}
+
+// Describes an IAM instance profile.
+type IAMInstanceProfile struct {
+	// The Amazon Resource Name (ARN) of the instance profile.
+	ARN *string `locationName:"arn" type:"string"`
+
+	// The ID of the instance profile.
+	ID *string `locationName:"id" type:"string"`
+
+	metadataIAMInstanceProfile `json:"-" xml:"-"`
+}
+
+type metadataIAMInstanceProfile struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s IAMInstanceProfile) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s IAMInstanceProfile) GoString() string {
+	return s.String()
+}
+
+// Describes an IAM instance profile.
+type IAMInstanceProfileSpecification struct {
+	// The Amazon Resource Name (ARN) of the instance profile.
+	ARN *string `locationName:"arn" type:"string"`
+
+	// The name of the instance profile.
+	Name *string `locationName:"name" type:"string"`
+
+	metadataIAMInstanceProfileSpecification `json:"-" xml:"-"`
+}
+
+type metadataIAMInstanceProfileSpecification struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s IAMInstanceProfileSpecification) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s IAMInstanceProfileSpecification) GoString() string {
+	return s.String()
+}
+
+// Describes the ICMP type and code.
+type ICMPTypeCode struct {
+	// The ICMP type. A value of -1 means all types.
+	Code *int64 `locationName:"code" type:"integer"`
+
+	// The ICMP code. A value of -1 means all codes for the specified ICMP type.
+	Type *int64 `locationName:"type" type:"integer"`
+
+	metadataICMPTypeCode `json:"-" xml:"-"`
+}
+
+type metadataICMPTypeCode struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ICMPTypeCode) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ICMPTypeCode) GoString() string {
+	return s.String()
+}
+
+// Describes a security group rule.
+type IPPermission struct {
+	// The start of port range for the TCP and UDP protocols, or an ICMP type number.
+	// A value of -1 indicates all ICMP types.
+	FromPort *int64 `locationName:"fromPort" type:"integer"`
+
+	// The protocol.
+	//
+	// When you call DescribeSecurityGroups, the protocol value returned is the
+	// number. Exception: For TCP, UDP, and ICMP, the value returned is the name
+	// (for example, tcp, udp, or icmp). For a list of protocol numbers, see Protocol
+	// Numbers (http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml).
+	// (VPC only) When you call AuthorizeSecurityGroupIngress, you can use -1 to
+	// specify all.
+	IPProtocol *string `locationName:"ipProtocol" type:"string"`
+
+	// One or more IP ranges.
+	IPRanges []*IPRange `locationName:"ipRanges" locationNameList:"item" type:"list"`
+
+	// (Valid for AuthorizeSecurityGroupEgress, RevokeSecurityGroupEgress and DescribeSecurityGroups
+	// only) One or more prefix list IDs for an AWS service. In an AuthorizeSecurityGroupEgress
+	// request, this is the AWS service that you want to access through a VPC endpoint
+	// from instances associated with the security group.
+	PrefixListIDs []*PrefixListID `locationName:"prefixListIds" locationNameList:"item" type:"list"`
+
+	// The end of port range for the TCP and UDP protocols, or an ICMP code. A value
+	// of -1 indicates all ICMP codes for the specified ICMP type.
+	ToPort *int64 `locationName:"toPort" type:"integer"`
+
+	// One or more security group and AWS account ID pairs.
+	UserIDGroupPairs []*UserIDGroupPair `locationName:"groups" locationNameList:"item" type:"list"`
+
+	metadataIPPermission `json:"-" xml:"-"`
+}
+
+type metadataIPPermission struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s IPPermission) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s IPPermission) GoString() string {
+	return s.String()
+}
+
+// Describes an IP range.
+type IPRange struct {
+	// The CIDR range. You can either specify a CIDR range or a source security
+	// group, not both.
+	CIDRIP *string `locationName:"cidrIp" type:"string"`
+
+	metadataIPRange `json:"-" xml:"-"`
+}
+
+type metadataIPRange struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s IPRange) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s IPRange) GoString() string {
+	return s.String()
+}
+
+// Describes an image.
+type Image struct {
+	// The architecture of the image.
+	Architecture *string `locationName:"architecture" type:"string" enum:"ArchitectureValues"`
+
+	// Any block device mapping entries.
+	BlockDeviceMappings []*BlockDeviceMapping `locationName:"blockDeviceMapping" locationNameList:"item" type:"list"`
+
+	// The date and time the image was created.
+	CreationDate *string `locationName:"creationDate" type:"string"`
+
+	// The description of the AMI that was provided during image creation.
+	Description *string `locationName:"description" type:"string"`
+
+	// The hypervisor type of the image.
+	Hypervisor *string `locationName:"hypervisor" type:"string" enum:"HypervisorType"`
+
+	// The ID of the AMI.
+	ImageID *string `locationName:"imageId" type:"string"`
+
+	// The location of the AMI.
+	ImageLocation *string `locationName:"imageLocation" type:"string"`
+
+	// The AWS account alias (for example, amazon, self) or the AWS account ID of
+	// the AMI owner.
+	ImageOwnerAlias *string `locationName:"imageOwnerAlias" type:"string"`
+
+	// The type of image.
+	ImageType *string `locationName:"imageType" type:"string" enum:"ImageTypeValues"`
+
+	// The kernel associated with the image, if any. Only applicable for machine
+	// images.
+	KernelID *string `locationName:"kernelId" type:"string"`
+
+	// The name of the AMI that was provided during image creation.
+	Name *string `locationName:"name" type:"string"`
+
+	// The AWS account ID of the image owner.
+	OwnerID *string `locationName:"imageOwnerId" type:"string"`
+
+	// The value is Windows for Windows AMIs; otherwise blank.
+	Platform *string `locationName:"platform" type:"string" enum:"PlatformValues"`
+
+	// Any product codes associated with the AMI.
+	ProductCodes []*ProductCode `locationName:"productCodes" locationNameList:"item" type:"list"`
+
+	// Indicates whether the image has public launch permissions. The value is true
+	// if this image has public launch permissions or false if it has only implicit
+	// and explicit launch permissions.
+	Public *bool `locationName:"isPublic" type:"boolean"`
+
+	// The RAM disk associated with the image, if any. Only applicable for machine
+	// images.
+	RAMDiskID *string `locationName:"ramdiskId" type:"string"`
+
+	// The device name of the root device (for example, /dev/sda1 or /dev/xvda).
+	RootDeviceName *string `locationName:"rootDeviceName" type:"string"`
+
+	// The type of root device used by the AMI. The AMI can use an EBS volume or
+	// an instance store volume.
+	RootDeviceType *string `locationName:"rootDeviceType" type:"string" enum:"DeviceType"`
+
+	// Specifies whether enhanced networking is enabled.
+	SRIOVNetSupport *string `locationName:"sriovNetSupport" type:"string"`
+
+	// The current state of the AMI. If the state is available, the image is successfully
+	// registered and can be used to launch an instance.
+	State *string `locationName:"imageState" type:"string" enum:"ImageState"`
+
+	// The reason for the state change.
+	StateReason *StateReason `locationName:"stateReason" type:"structure"`
+
+	// Any tags assigned to the image.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	// The type of virtualization of the AMI.
+	VirtualizationType *string `locationName:"virtualizationType" type:"string" enum:"VirtualizationType"`
+
+	metadataImage `json:"-" xml:"-"`
+}
+
+type metadataImage struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s Image) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Image) GoString() string {
+	return s.String()
+}
+
+// Describes the disk container object for an import image task.
+type ImageDiskContainer struct {
+	// The description of the disk image.
+	Description *string `type:"string"`
+
+	// The block device mapping for the disk.
+	DeviceName *string `type:"string"`
+
+	// The format of the disk image being imported.
+	//
+	// Valid values: RAW | VHD | VMDK | OVA
+	Format *string `type:"string"`
+
+	// The ID of the EBS snapshot to be used for importing the snapshot.
+	SnapshotID *string `locationName:"SnapshotId" type:"string"`
+
+	// The URL to the Amazon S3-based disk image being imported. The URL can either
+	// be a https URL (https://..) or an Amazon S3 URL (s3://..)
+	URL *string `locationName:"Url" type:"string"`
+
+	// The S3 bucket for the disk image.
+	UserBucket *UserBucket `type:"structure"`
+
+	metadataImageDiskContainer `json:"-" xml:"-"`
+}
+
+type metadataImageDiskContainer struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ImageDiskContainer) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ImageDiskContainer) GoString() string {
+	return s.String()
+}
+
+type ImportImageInput struct {
+	// The architecture of the virtual machine.
+	//
+	// Valid values: i386 | x86_64
+	Architecture *string `type:"string"`
+
+	// The client-specific data.
+	ClientData *ClientData `type:"structure"`
+
+	// The token to enable idempotency for VM import requests.
+	ClientToken *string `type:"string"`
+
+	// A description string for the import image task.
+	Description *string `type:"string"`
+
+	// Information about the disk containers.
+	DiskContainers []*ImageDiskContainer `locationName:"DiskContainer" locationNameList:"item" type:"list"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `type:"boolean"`
+
+	// The target hypervisor platform.
+	//
+	// Valid values: xen
+	Hypervisor *string `type:"string"`
+
+	// The license type to be used for the Amazon Machine Image (AMI) after importing.
+	//
+	// Note: You may only use BYOL if you have existing licenses with rights to
+	// use these licenses in a third party cloud like AWS. For more information,
+	// see VM Import/Export Prerequisites (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/VMImportPrerequisites.html)
+	// in the Amazon Elastic Compute Cloud User Guide.
+	//
+	// Valid values: AWS | BYOL
+	LicenseType *string `type:"string"`
+
+	// The operating system of the virtual machine.
+	//
+	// Valid values: Windows | Linux
+	Platform *string `type:"string"`
+
+	// The name of the role to use when not using the default role, 'vmimport'.
+	RoleName *string `type:"string"`
+
+	metadataImportImageInput `json:"-" xml:"-"`
+}
+
+type metadataImportImageInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ImportImageInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ImportImageInput) GoString() string {
+	return s.String()
+}
+
+type ImportImageOutput struct {
+	// The architecture of the virtual machine.
+	Architecture *string `locationName:"architecture" type:"string"`
+
+	// A description of the import task.
+	Description *string `locationName:"description" type:"string"`
+
+	// The target hypervisor of the import task.
+	Hypervisor *string `locationName:"hypervisor" type:"string"`
+
+	// The ID of the Amazon Machine Image (AMI) created by the import task.
+	ImageID *string `locationName:"imageId" type:"string"`
+
+	// The task ID of the import image task.
+	ImportTaskID *string `locationName:"importTaskId" type:"string"`
+
+	// The license type of the virtual machine.
+	LicenseType *string `locationName:"licenseType" type:"string"`
+
+	// The operating system of the virtual machine.
+	Platform *string `locationName:"platform" type:"string"`
+
+	// The progress of the task.
+	Progress *string `locationName:"progress" type:"string"`
+
+	// Information about the snapshots.
+	SnapshotDetails []*SnapshotDetail `locationName:"snapshotDetailSet" locationNameList:"item" type:"list"`
+
+	// A brief status of the task.
+	Status *string `locationName:"status" type:"string"`
+
+	// A detailed status message of the import task.
+	StatusMessage *string `locationName:"statusMessage" type:"string"`
+
+	metadataImportImageOutput `json:"-" xml:"-"`
+}
+
+type metadataImportImageOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ImportImageOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ImportImageOutput) GoString() string {
+	return s.String()
+}
+
+// Describes an import image task.
+type ImportImageTask struct {
+	// The architecture of the virtual machine.
+	//
+	// Valid values: i386 | x86_64
+	Architecture *string `locationName:"architecture" type:"string"`
+
+	// A description of the import task.
+	Description *string `locationName:"description" type:"string"`
+
+	// The target hypervisor for the import task.
+	//
+	// Valid values: xen
+	Hypervisor *string `locationName:"hypervisor" type:"string"`
+
+	// The ID of the Amazon Machine Image (AMI) of the imported virtual machine.
+	ImageID *string `locationName:"imageId" type:"string"`
+
+	// The ID of the import image task.
+	ImportTaskID *string `locationName:"importTaskId" type:"string"`
+
+	// The license type of the virtual machine.
+	LicenseType *string `locationName:"licenseType" type:"string"`
+
+	// The description string for the import image task.
+	Platform *string `locationName:"platform" type:"string"`
+
+	// The percentage of progress of the import image task.
+	Progress *string `locationName:"progress" type:"string"`
+
+	// Information about the snapshots.
+	SnapshotDetails []*SnapshotDetail `locationName:"snapshotDetailSet" locationNameList:"item" type:"list"`
+
+	// A brief status for the import image task.
+	Status *string `locationName:"status" type:"string"`
+
+	// A descriptive status message for the import image task.
+	StatusMessage *string `locationName:"statusMessage" type:"string"`
+
+	metadataImportImageTask `json:"-" xml:"-"`
+}
+
+type metadataImportImageTask struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ImportImageTask) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ImportImageTask) GoString() string {
+	return s.String()
+}
+
+type ImportInstanceInput struct {
+	// A description for the instance being imported.
+	Description *string `locationName:"description" type:"string"`
+
+	// The disk image.
+	DiskImages []*DiskImage `locationName:"diskImage" type:"list"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The launch specification.
+	LaunchSpecification *ImportInstanceLaunchSpecification `locationName:"launchSpecification" type:"structure"`
+
+	// The instance operating system.
+	Platform *string `locationName:"platform" type:"string" required:"true" enum:"PlatformValues"`
+
+	metadataImportInstanceInput `json:"-" xml:"-"`
+}
+
+type metadataImportInstanceInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ImportInstanceInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ImportInstanceInput) GoString() string {
+	return s.String()
+}
+
+// Describes the launch specification for VM import.
+type ImportInstanceLaunchSpecification struct {
+	// Reserved.
+	AdditionalInfo *string `locationName:"additionalInfo" type:"string"`
+
+	// The architecture of the instance.
+	Architecture *string `locationName:"architecture" type:"string" enum:"ArchitectureValues"`
+
+	// One or more security group IDs.
+	GroupIDs []*string `locationName:"GroupId" locationNameList:"SecurityGroupId" type:"list"`
+
+	// One or more security group names.
+	GroupNames []*string `locationName:"GroupName" locationNameList:"SecurityGroup" type:"list"`
+
+	// Indicates whether an instance stops or terminates when you initiate shutdown
+	// from the instance (using the operating system command for system shutdown).
+	InstanceInitiatedShutdownBehavior *string `locationName:"instanceInitiatedShutdownBehavior" type:"string" enum:"ShutdownBehavior"`
+
+	// The instance type. For more information about the instance types that you
+	// can import, see Before You Get Started (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/VMImportPrerequisites.html)
+	// in the Amazon Elastic Compute Cloud User Guide.
+	InstanceType *string `locationName:"instanceType" type:"string" enum:"InstanceType"`
+
+	// Indicates whether monitoring is enabled.
+	Monitoring *bool `locationName:"monitoring" type:"boolean"`
+
+	// The placement information for the instance.
+	Placement *Placement `locationName:"placement" type:"structure"`
+
+	// [EC2-VPC] An available IP address from the IP address range of the subnet.
+	PrivateIPAddress *string `locationName:"privateIpAddress" type:"string"`
+
+	// [EC2-VPC] The ID of the subnet in which to launch the instance.
+	SubnetID *string `locationName:"subnetId" type:"string"`
+
+	// The Base64-encoded MIME user data to be made available to the instance.
+	UserData *UserData `locationName:"userData" type:"structure"`
+
+	metadataImportInstanceLaunchSpecification `json:"-" xml:"-"`
+}
+
+type metadataImportInstanceLaunchSpecification struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ImportInstanceLaunchSpecification) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ImportInstanceLaunchSpecification) GoString() string {
+	return s.String()
+}
+
+type ImportInstanceOutput struct {
+	// Information about the conversion task.
+	ConversionTask *ConversionTask `locationName:"conversionTask" type:"structure"`
+
+	metadataImportInstanceOutput `json:"-" xml:"-"`
+}
+
+type metadataImportInstanceOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ImportInstanceOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ImportInstanceOutput) GoString() string {
+	return s.String()
+}
+
+// Describes an import instance task.
+type ImportInstanceTaskDetails struct {
+	// A description of the task.
+	Description *string `locationName:"description" type:"string"`
+
+	// The ID of the instance.
+	InstanceID *string `locationName:"instanceId" type:"string"`
+
+	// The instance operating system.
+	Platform *string `locationName:"platform" type:"string" enum:"PlatformValues"`
+
+	// One or more volumes.
+	Volumes []*ImportInstanceVolumeDetailItem `locationName:"volumes" locationNameList:"item" type:"list" required:"true"`
+
+	metadataImportInstanceTaskDetails `json:"-" xml:"-"`
+}
+
+type metadataImportInstanceTaskDetails struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ImportInstanceTaskDetails) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ImportInstanceTaskDetails) GoString() string {
+	return s.String()
+}
+
+// Describes an import volume task.
+type ImportInstanceVolumeDetailItem struct {
+	// The Availability Zone where the resulting instance will reside.
+	AvailabilityZone *string `locationName:"availabilityZone" type:"string" required:"true"`
+
+	// The number of bytes converted so far.
+	BytesConverted *int64 `locationName:"bytesConverted" type:"long" required:"true"`
+
+	// A description of the task.
+	Description *string `locationName:"description" type:"string"`
+
+	// The image.
+	Image *DiskImageDescription `locationName:"image" type:"structure" required:"true"`
+
+	// The status of the import of this particular disk image.
+	Status *string `locationName:"status" type:"string" required:"true"`
+
+	// The status information or errors related to the disk image.
+	StatusMessage *string `locationName:"statusMessage" type:"string"`
+
+	// The volume.
+	Volume *DiskImageVolumeDescription `locationName:"volume" type:"structure" required:"true"`
+
+	metadataImportInstanceVolumeDetailItem `json:"-" xml:"-"`
+}
+
+type metadataImportInstanceVolumeDetailItem struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ImportInstanceVolumeDetailItem) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ImportInstanceVolumeDetailItem) GoString() string {
+	return s.String()
+}
+
+type ImportKeyPairInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// A unique name for the key pair.
+	KeyName *string `locationName:"keyName" type:"string" required:"true"`
+
+	// The public key. You must base64 encode the public key material before sending
+	// it to AWS.
+	PublicKeyMaterial []byte `locationName:"publicKeyMaterial" type:"blob" required:"true"`
+
+	metadataImportKeyPairInput `json:"-" xml:"-"`
+}
+
+type metadataImportKeyPairInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ImportKeyPairInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ImportKeyPairInput) GoString() string {
+	return s.String()
+}
+
+type ImportKeyPairOutput struct {
+	// The MD5 public key fingerprint as specified in section 4 of RFC 4716.
+	KeyFingerprint *string `locationName:"keyFingerprint" type:"string"`
+
+	// The key pair name you provided.
+	KeyName *string `locationName:"keyName" type:"string"`
+
+	metadataImportKeyPairOutput `json:"-" xml:"-"`
+}
+
+type metadataImportKeyPairOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ImportKeyPairOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ImportKeyPairOutput) GoString() string {
+	return s.String()
+}
+
+type ImportSnapshotInput struct {
+	// The client-specific data.
+	ClientData *ClientData `type:"structure"`
+
+	// Token to enable idempotency for VM import requests.
+	ClientToken *string `type:"string"`
+
+	// The description string for the import snapshot task.
+	Description *string `type:"string"`
+
+	// Information about the disk container.
+	DiskContainer *SnapshotDiskContainer `type:"structure"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `type:"boolean"`
+
+	// The name of the role to use when not using the default role, 'vmimport'.
+	RoleName *string `type:"string"`
+
+	metadataImportSnapshotInput `json:"-" xml:"-"`
+}
+
+type metadataImportSnapshotInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ImportSnapshotInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ImportSnapshotInput) GoString() string {
+	return s.String()
+}
+
+type ImportSnapshotOutput struct {
+	// A description of the import snapshot task.
+	Description *string `locationName:"description" type:"string"`
+
+	// The ID of the import snapshot task.
+	ImportTaskID *string `locationName:"importTaskId" type:"string"`
+
+	// Information about the import snapshot task.
+	SnapshotTaskDetail *SnapshotTaskDetail `locationName:"snapshotTaskDetail" type:"structure"`
+
+	metadataImportSnapshotOutput `json:"-" xml:"-"`
+}
+
+type metadataImportSnapshotOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ImportSnapshotOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ImportSnapshotOutput) GoString() string {
+	return s.String()
+}
+
+// Describes an import snapshot task.
+type ImportSnapshotTask struct {
+	// A description of the import snapshot task.
+	Description *string `locationName:"description" type:"string"`
+
+	// The ID of the import snapshot task.
+	ImportTaskID *string `locationName:"importTaskId" type:"string"`
+
+	// Describes an import snapshot task.
+	SnapshotTaskDetail *SnapshotTaskDetail `locationName:"snapshotTaskDetail" type:"structure"`
+
+	metadataImportSnapshotTask `json:"-" xml:"-"`
+}
+
+type metadataImportSnapshotTask struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ImportSnapshotTask) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ImportSnapshotTask) GoString() string {
+	return s.String()
+}
+
+type ImportVolumeInput struct {
+	// The Availability Zone for the resulting EBS volume.
+	AvailabilityZone *string `locationName:"availabilityZone" type:"string" required:"true"`
+
+	// A description of the volume.
+	Description *string `locationName:"description" type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The disk image.
+	Image *DiskImageDetail `locationName:"image" type:"structure" required:"true"`
+
+	// The volume size.
+	Volume *VolumeDetail `locationName:"volume" type:"structure" required:"true"`
+
+	metadataImportVolumeInput `json:"-" xml:"-"`
+}
+
+type metadataImportVolumeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ImportVolumeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ImportVolumeInput) GoString() string {
+	return s.String()
+}
+
+type ImportVolumeOutput struct {
+	// Information about the conversion task.
+	ConversionTask *ConversionTask `locationName:"conversionTask" type:"structure"`
+
+	metadataImportVolumeOutput `json:"-" xml:"-"`
+}
+
+type metadataImportVolumeOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ImportVolumeOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ImportVolumeOutput) GoString() string {
+	return s.String()
+}
+
+// Describes an import volume task.
+type ImportVolumeTaskDetails struct {
+	// The Availability Zone where the resulting volume will reside.
+	AvailabilityZone *string `locationName:"availabilityZone" type:"string" required:"true"`
+
+	// The number of bytes converted so far.
+	BytesConverted *int64 `locationName:"bytesConverted" type:"long" required:"true"`
+
+	// The description you provided when starting the import volume task.
+	Description *string `locationName:"description" type:"string"`
+
+	// The image.
+	Image *DiskImageDescription `locationName:"image" type:"structure" required:"true"`
+
+	// The volume.
+	Volume *DiskImageVolumeDescription `locationName:"volume" type:"structure" required:"true"`
+
+	metadataImportVolumeTaskDetails `json:"-" xml:"-"`
+}
+
+type metadataImportVolumeTaskDetails struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ImportVolumeTaskDetails) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ImportVolumeTaskDetails) GoString() string {
+	return s.String()
+}
+
+// Describes an instance.
+type Instance struct {
+	// The AMI launch index, which can be used to find this instance in the launch
+	// group.
+	AMILaunchIndex *int64 `locationName:"amiLaunchIndex" type:"integer"`
+
+	// The architecture of the image.
+	Architecture *string `locationName:"architecture" type:"string" enum:"ArchitectureValues"`
+
+	// Any block device mapping entries for the instance.
+	BlockDeviceMappings []*InstanceBlockDeviceMapping `locationName:"blockDeviceMapping" locationNameList:"item" type:"list"`
+
+	// The idempotency token you provided when you launched the instance.
+	ClientToken *string `locationName:"clientToken" type:"string"`
+
+	// Indicates whether the instance is optimized for EBS I/O. This optimization
+	// provides dedicated throughput to Amazon EBS and an optimized configuration
+	// stack to provide optimal I/O performance. This optimization isn't available
+	// with all instance types. Additional usage charges apply when using an EBS
+	// Optimized instance.
+	EBSOptimized *bool `locationName:"ebsOptimized" type:"boolean"`
+
+	// The hypervisor type of the instance.
+	Hypervisor *string `locationName:"hypervisor" type:"string" enum:"HypervisorType"`
+
+	// The IAM instance profile associated with the instance.
+	IAMInstanceProfile *IAMInstanceProfile `locationName:"iamInstanceProfile" type:"structure"`
+
+	// The ID of the AMI used to launch the instance.
+	ImageID *string `locationName:"imageId" type:"string"`
+
+	// The ID of the instance.
+	InstanceID *string `locationName:"instanceId" type:"string"`
+
+	// Indicates whether this is a Spot Instance.
+	InstanceLifecycle *string `locationName:"instanceLifecycle" type:"string" enum:"InstanceLifecycleType"`
+
+	// The instance type.
+	InstanceType *string `locationName:"instanceType" type:"string" enum:"InstanceType"`
+
+	// The kernel associated with this instance.
+	KernelID *string `locationName:"kernelId" type:"string"`
+
+	// The name of the key pair, if this instance was launched with an associated
+	// key pair.
+	KeyName *string `locationName:"keyName" type:"string"`
+
+	// The time the instance was launched.
+	LaunchTime *time.Time `locationName:"launchTime" type:"timestamp" timestampFormat:"iso8601"`
+
+	// The monitoring information for the instance.
+	Monitoring *Monitoring `locationName:"monitoring" type:"structure"`
+
+	// [EC2-VPC] One or more network interfaces for the instance.
+	NetworkInterfaces []*InstanceNetworkInterface `locationName:"networkInterfaceSet" locationNameList:"item" type:"list"`
+
+	// The location where the instance launched.
+	Placement *Placement `locationName:"placement" type:"structure"`
+
+	// The value is Windows for Windows instances; otherwise blank.
+	Platform *string `locationName:"platform" type:"string" enum:"PlatformValues"`
+
+	// The private DNS name assigned to the instance. This DNS name can only be
+	// used inside the Amazon EC2 network. This name is not available until the
+	// instance enters the running state.
+	PrivateDNSName *string `locationName:"privateDnsName" type:"string"`
+
+	// The private IP address assigned to the instance.
+	PrivateIPAddress *string `locationName:"privateIpAddress" type:"string"`
+
+	// The product codes attached to this instance.
+	ProductCodes []*ProductCode `locationName:"productCodes" locationNameList:"item" type:"list"`
+
+	// The public DNS name assigned to the instance. This name is not available
+	// until the instance enters the running state.
+	PublicDNSName *string `locationName:"dnsName" type:"string"`
+
+	// The public IP address assigned to the instance.
+	PublicIPAddress *string `locationName:"ipAddress" type:"string"`
+
+	// The RAM disk associated with this instance.
+	RAMDiskID *string `locationName:"ramdiskId" type:"string"`
+
+	// The root device name (for example, /dev/sda1 or /dev/xvda).
+	RootDeviceName *string `locationName:"rootDeviceName" type:"string"`
+
+	// The root device type used by the AMI. The AMI can use an EBS volume or an
+	// instance store volume.
+	RootDeviceType *string `locationName:"rootDeviceType" type:"string" enum:"DeviceType"`
+
+	// Specifies whether enhanced networking is enabled.
+	SRIOVNetSupport *string `locationName:"sriovNetSupport" type:"string"`
+
+	// One or more security groups for the instance.
+	SecurityGroups []*GroupIdentifier `locationName:"groupSet" locationNameList:"item" type:"list"`
+
+	// Specifies whether to enable an instance launched in a VPC to perform NAT.
+	// This controls whether source/destination checking is enabled on the instance.
+	// A value of true means checking is enabled, and false means checking is disabled.
+	// The value must be false for the instance to perform NAT. For more information,
+	// see NAT Instances (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_NAT_Instance.html)
+	// in the Amazon Virtual Private Cloud User Guide.
+	SourceDestCheck *bool `locationName:"sourceDestCheck" type:"boolean"`
+
+	// The ID of the Spot Instance request.
+	SpotInstanceRequestID *string `locationName:"spotInstanceRequestId" type:"string"`
+
+	// The current state of the instance.
+	State *InstanceState `locationName:"instanceState" type:"structure"`
+
+	// The reason for the most recent state transition.
+	StateReason *StateReason `locationName:"stateReason" type:"structure"`
+
+	// The reason for the most recent state transition. This might be an empty string.
+	StateTransitionReason *string `locationName:"reason" type:"string"`
+
+	// The ID of the subnet in which the instance is running.
+	SubnetID *string `locationName:"subnetId" type:"string"`
+
+	// Any tags assigned to the instance.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	// The ID of the VPC in which the instance is running.
+	VPCID *string `locationName:"vpcId" type:"string"`
+
+	// The virtualization type of the instance.
+	VirtualizationType *string `locationName:"virtualizationType" type:"string" enum:"VirtualizationType"`
+
+	metadataInstance `json:"-" xml:"-"`
+}
+
+type metadataInstance struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s Instance) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Instance) GoString() string {
+	return s.String()
+}
+
+// Describes a block device mapping.
+type InstanceBlockDeviceMapping struct {
+	// The device name exposed to the instance (for example, /dev/sdh or xvdh).
+	DeviceName *string `locationName:"deviceName" type:"string"`
+
+	// Parameters used to automatically set up EBS volumes when the instance is
+	// launched.
+	EBS *EBSInstanceBlockDevice `locationName:"ebs" type:"structure"`
+
+	metadataInstanceBlockDeviceMapping `json:"-" xml:"-"`
+}
+
+type metadataInstanceBlockDeviceMapping struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s InstanceBlockDeviceMapping) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InstanceBlockDeviceMapping) GoString() string {
+	return s.String()
+}
+
+// Describes a block device mapping entry.
+type InstanceBlockDeviceMappingSpecification struct {
+	// The device name exposed to the instance (for example, /dev/sdh or xvdh).
+	DeviceName *string `locationName:"deviceName" type:"string"`
+
+	// Parameters used to automatically set up EBS volumes when the instance is
+	// launched.
+	EBS *EBSInstanceBlockDeviceSpecification `locationName:"ebs" type:"structure"`
+
+	// suppress the specified device included in the block device mapping.
+	NoDevice *string `locationName:"noDevice" type:"string"`
+
+	// The virtual device name.
+	VirtualName *string `locationName:"virtualName" type:"string"`
+
+	metadataInstanceBlockDeviceMappingSpecification `json:"-" xml:"-"`
+}
+
+type metadataInstanceBlockDeviceMappingSpecification struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s InstanceBlockDeviceMappingSpecification) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InstanceBlockDeviceMappingSpecification) GoString() string {
+	return s.String()
+}
+
+// Describes a Reserved Instance listing state.
+type InstanceCount struct {
+	// The number of listed Reserved Instances in the state specified by the state.
+	InstanceCount *int64 `locationName:"instanceCount" type:"integer"`
+
+	// The states of the listed Reserved Instances.
+	State *string `locationName:"state" type:"string" enum:"ListingState"`
+
+	metadataInstanceCount `json:"-" xml:"-"`
+}
+
+type metadataInstanceCount struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s InstanceCount) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InstanceCount) GoString() string {
+	return s.String()
+}
+
+// Describes an instance to export.
+type InstanceExportDetails struct {
+	// The ID of the resource being exported.
+	InstanceID *string `locationName:"instanceId" type:"string"`
+
+	// The target virtualization environment.
+	TargetEnvironment *string `locationName:"targetEnvironment" type:"string" enum:"ExportEnvironment"`
+
+	metadataInstanceExportDetails `json:"-" xml:"-"`
+}
+
+type metadataInstanceExportDetails struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s InstanceExportDetails) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InstanceExportDetails) GoString() string {
+	return s.String()
+}
+
+// Describes the monitoring information of the instance.
+type InstanceMonitoring struct {
+	// The ID of the instance.
+	InstanceID *string `locationName:"instanceId" type:"string"`
+
+	// The monitoring information.
+	Monitoring *Monitoring `locationName:"monitoring" type:"structure"`
+
+	metadataInstanceMonitoring `json:"-" xml:"-"`
+}
+
+type metadataInstanceMonitoring struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s InstanceMonitoring) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InstanceMonitoring) GoString() string {
+	return s.String()
+}
+
+// Describes a network interface.
+type InstanceNetworkInterface struct {
+	// The association information for an Elastic IP associated with the network
+	// interface.
+	Association *InstanceNetworkInterfaceAssociation `locationName:"association" type:"structure"`
+
+	// The network interface attachment.
+	Attachment *InstanceNetworkInterfaceAttachment `locationName:"attachment" type:"structure"`
+
+	// The description.
+	Description *string `locationName:"description" type:"string"`
+
+	// One or more security groups.
+	Groups []*GroupIdentifier `locationName:"groupSet" locationNameList:"item" type:"list"`
+
+	// The MAC address.
+	MACAddress *string `locationName:"macAddress" type:"string"`
+
+	// The ID of the network interface.
+	NetworkInterfaceID *string `locationName:"networkInterfaceId" type:"string"`
+
+	// The ID of the AWS account that created the network interface.
+	OwnerID *string `locationName:"ownerId" type:"string"`
+
+	// The private DNS name.
+	PrivateDNSName *string `locationName:"privateDnsName" type:"string"`
+
+	// The IP address of the network interface within the subnet.
+	PrivateIPAddress *string `locationName:"privateIpAddress" type:"string"`
+
+	// The private IP addresses associated with the network interface.
+	PrivateIPAddresses []*InstancePrivateIPAddress `locationName:"privateIpAddressesSet" locationNameList:"item" type:"list"`
+
+	// Indicates whether to validate network traffic to or from this network interface.
+	SourceDestCheck *bool `locationName:"sourceDestCheck" type:"boolean"`
+
+	// The status of the network interface.
+	Status *string `locationName:"status" type:"string" enum:"NetworkInterfaceStatus"`
+
+	// The ID of the subnet.
+	SubnetID *string `locationName:"subnetId" type:"string"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"vpcId" type:"string"`
+
+	metadataInstanceNetworkInterface `json:"-" xml:"-"`
+}
+
+type metadataInstanceNetworkInterface struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s InstanceNetworkInterface) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InstanceNetworkInterface) GoString() string {
+	return s.String()
+}
+
+// Describes association information for an Elastic IP address.
+type InstanceNetworkInterfaceAssociation struct {
+	// The ID of the owner of the Elastic IP address.
+	IPOwnerID *string `locationName:"ipOwnerId" type:"string"`
+
+	// The public DNS name.
+	PublicDNSName *string `locationName:"publicDnsName" type:"string"`
+
+	// The public IP address or Elastic IP address bound to the network interface.
+	PublicIP *string `locationName:"publicIp" type:"string"`
+
+	metadataInstanceNetworkInterfaceAssociation `json:"-" xml:"-"`
+}
+
+type metadataInstanceNetworkInterfaceAssociation struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s InstanceNetworkInterfaceAssociation) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InstanceNetworkInterfaceAssociation) GoString() string {
+	return s.String()
+}
+
+// Describes a network interface attachment.
+type InstanceNetworkInterfaceAttachment struct {
+	// The time stamp when the attachment initiated.
+	AttachTime *time.Time `locationName:"attachTime" type:"timestamp" timestampFormat:"iso8601"`
+
+	// The ID of the network interface attachment.
+	AttachmentID *string `locationName:"attachmentId" type:"string"`
+
+	// Indicates whether the network interface is deleted when the instance is terminated.
+	DeleteOnTermination *bool `locationName:"deleteOnTermination" type:"boolean"`
+
+	// The index of the device on the instance for the network interface attachment.
+	DeviceIndex *int64 `locationName:"deviceIndex" type:"integer"`
+
+	// The attachment state.
+	Status *string `locationName:"status" type:"string" enum:"AttachmentStatus"`
+
+	metadataInstanceNetworkInterfaceAttachment `json:"-" xml:"-"`
+}
+
+type metadataInstanceNetworkInterfaceAttachment struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s InstanceNetworkInterfaceAttachment) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InstanceNetworkInterfaceAttachment) GoString() string {
+	return s.String()
+}
+
+// Describes a network interface.
+type InstanceNetworkInterfaceSpecification struct {
+	// Indicates whether to assign a public IP address to an instance you launch
+	// in a VPC. The public IP address can only be assigned to a network interface
+	// for eth0, and can only be assigned to a new network interface, not an existing
+	// one. You cannot specify more than one network interface in the request. If
+	// launching into a default subnet, the default value is true.
+	AssociatePublicIPAddress *bool `locationName:"associatePublicIpAddress" type:"boolean"`
+
+	// If set to true, the interface is deleted when the instance is terminated.
+	// You can specify true only if creating a new network interface when launching
+	// an instance.
+	DeleteOnTermination *bool `locationName:"deleteOnTermination" type:"boolean"`
+
+	// The description of the network interface. Applies only if creating a network
+	// interface when launching an instance.
+	Description *string `locationName:"description" type:"string"`
+
+	// The index of the device on the instance for the network interface attachment.
+	// If you are specifying a network interface in a RunInstances request, you
+	// must provide the device index.
+	DeviceIndex *int64 `locationName:"deviceIndex" type:"integer"`
+
+	// The IDs of the security groups for the network interface. Applies only if
+	// creating a network interface when launching an instance.
+	Groups []*string `locationName:"SecurityGroupId" locationNameList:"SecurityGroupId" type:"list"`
+
+	// The ID of the network interface.
+	NetworkInterfaceID *string `locationName:"networkInterfaceId" type:"string"`
+
+	// The private IP address of the network interface. Applies only if creating
+	// a network interface when launching an instance.
+	PrivateIPAddress *string `locationName:"privateIpAddress" type:"string"`
+
+	// One or more private IP addresses to assign to the network interface. Only
+	// one private IP address can be designated as primary.
+	PrivateIPAddresses []*PrivateIPAddressSpecification `locationName:"privateIpAddressesSet" queryName:"PrivateIpAddresses" locationNameList:"item" type:"list"`
+
+	// The number of secondary private IP addresses. You can't specify this option
+	// and specify more than one private IP address using the private IP addresses
+	// option.
+	SecondaryPrivateIPAddressCount *int64 `locationName:"secondaryPrivateIpAddressCount" type:"integer"`
+
+	// The ID of the subnet associated with the network string. Applies only if
+	// creating a network interface when launching an instance.
+	SubnetID *string `locationName:"subnetId" type:"string"`
+
+	metadataInstanceNetworkInterfaceSpecification `json:"-" xml:"-"`
+}
+
+type metadataInstanceNetworkInterfaceSpecification struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s InstanceNetworkInterfaceSpecification) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InstanceNetworkInterfaceSpecification) GoString() string {
+	return s.String()
+}
+
+// Describes a private IP address.
+type InstancePrivateIPAddress struct {
+	// The association information for an Elastic IP address for the network interface.
+	Association *InstanceNetworkInterfaceAssociation `locationName:"association" type:"structure"`
+
+	// Indicates whether this IP address is the primary private IP address of the
+	// network interface.
+	Primary *bool `locationName:"primary" type:"boolean"`
+
+	// The private DNS name.
+	PrivateDNSName *string `locationName:"privateDnsName" type:"string"`
+
+	// The private IP address of the network interface.
+	PrivateIPAddress *string `locationName:"privateIpAddress" type:"string"`
+
+	metadataInstancePrivateIPAddress `json:"-" xml:"-"`
+}
+
+type metadataInstancePrivateIPAddress struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s InstancePrivateIPAddress) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InstancePrivateIPAddress) GoString() string {
+	return s.String()
+}
+
+// Describes the current state of the instance.
+type InstanceState struct {
+	// The low byte represents the state. The high byte is an opaque internal value
+	// and should be ignored.
+	//
+	//  0 : pending
+	//
+	// 16 : running
+	//
+	// 32 : shutting-down
+	//
+	// 48 : terminated
+	//
+	// 64 : stopping
+	//
+	// 80 : stopped
+	Code *int64 `locationName:"code" type:"integer"`
+
+	// The current state of the instance.
+	Name *string `locationName:"name" type:"string" enum:"InstanceStateName"`
+
+	metadataInstanceState `json:"-" xml:"-"`
+}
+
+type metadataInstanceState struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s InstanceState) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InstanceState) GoString() string {
+	return s.String()
+}
+
+// Describes an instance state change.
+type InstanceStateChange struct {
+	// The current state of the instance.
+	CurrentState *InstanceState `locationName:"currentState" type:"structure"`
+
+	// The ID of the instance.
+	InstanceID *string `locationName:"instanceId" type:"string"`
+
+	// The previous state of the instance.
+	PreviousState *InstanceState `locationName:"previousState" type:"structure"`
+
+	metadataInstanceStateChange `json:"-" xml:"-"`
+}
+
+type metadataInstanceStateChange struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s InstanceStateChange) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InstanceStateChange) GoString() string {
+	return s.String()
+}
+
+// Describes the status of an instance.
+type InstanceStatus struct {
+	// The Availability Zone of the instance.
+	AvailabilityZone *string `locationName:"availabilityZone" type:"string"`
+
+	// Any scheduled events associated with the instance.
+	Events []*InstanceStatusEvent `locationName:"eventsSet" locationNameList:"item" type:"list"`
+
+	// The ID of the instance.
+	InstanceID *string `locationName:"instanceId" type:"string"`
+
+	// The intended state of the instance. DescribeInstanceStatus requires that
+	// an instance be in the running state.
+	InstanceState *InstanceState `locationName:"instanceState" type:"structure"`
+
+	// Reports impaired functionality that stems from issues internal to the instance,
+	// such as impaired reachability.
+	InstanceStatus *InstanceStatusSummary `locationName:"instanceStatus" type:"structure"`
+
+	// Reports impaired functionality that stems from issues related to the systems
+	// that support an instance, such as hardware failures and network connectivity
+	// problems.
+	SystemStatus *InstanceStatusSummary `locationName:"systemStatus" type:"structure"`
+
+	metadataInstanceStatus `json:"-" xml:"-"`
+}
+
+type metadataInstanceStatus struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s InstanceStatus) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InstanceStatus) GoString() string {
+	return s.String()
+}
+
+// Describes the instance status.
+type InstanceStatusDetails struct {
+	// The time when a status check failed. For an instance that was launched and
+	// impaired, this is the time when the instance was launched.
+	ImpairedSince *time.Time `locationName:"impairedSince" type:"timestamp" timestampFormat:"iso8601"`
+
+	// The type of instance status.
+	Name *string `locationName:"name" type:"string" enum:"StatusName"`
+
+	// The status.
+	Status *string `locationName:"status" type:"string" enum:"StatusType"`
+
+	metadataInstanceStatusDetails `json:"-" xml:"-"`
+}
+
+type metadataInstanceStatusDetails struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s InstanceStatusDetails) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InstanceStatusDetails) GoString() string {
+	return s.String()
+}
+
+// Describes a scheduled event for an instance.
+type InstanceStatusEvent struct {
+	// The event code.
+	Code *string `locationName:"code" type:"string" enum:"EventCode"`
+
+	// A description of the event.
+	//
+	// After a scheduled event is completed, it can still be described for up to
+	// a week. If the event has been completed, this description starts with the
+	// following text: [Completed].
+	Description *string `locationName:"description" type:"string"`
+
+	// The latest scheduled end time for the event.
+	NotAfter *time.Time `locationName:"notAfter" type:"timestamp" timestampFormat:"iso8601"`
+
+	// The earliest scheduled start time for the event.
+	NotBefore *time.Time `locationName:"notBefore" type:"timestamp" timestampFormat:"iso8601"`
+
+	metadataInstanceStatusEvent `json:"-" xml:"-"`
+}
+
+type metadataInstanceStatusEvent struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s InstanceStatusEvent) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InstanceStatusEvent) GoString() string {
+	return s.String()
+}
+
+// Describes the status of an instance.
+type InstanceStatusSummary struct {
+	// The system instance health or application instance health.
+	Details []*InstanceStatusDetails `locationName:"details" locationNameList:"item" type:"list"`
+
+	// The status.
+	Status *string `locationName:"status" type:"string" enum:"SummaryStatus"`
+
+	metadataInstanceStatusSummary `json:"-" xml:"-"`
+}
+
+type metadataInstanceStatusSummary struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s InstanceStatusSummary) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InstanceStatusSummary) GoString() string {
+	return s.String()
+}
+
+// Describes an Internet gateway.
+type InternetGateway struct {
+	// Any VPCs attached to the Internet gateway.
+	Attachments []*InternetGatewayAttachment `locationName:"attachmentSet" locationNameList:"item" type:"list"`
+
+	// The ID of the Internet gateway.
+	InternetGatewayID *string `locationName:"internetGatewayId" type:"string"`
+
+	// Any tags assigned to the Internet gateway.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	metadataInternetGateway `json:"-" xml:"-"`
+}
+
+type metadataInternetGateway struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s InternetGateway) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InternetGateway) GoString() string {
+	return s.String()
+}
+
+// Describes the attachment of a VPC to an Internet gateway.
+type InternetGatewayAttachment struct {
+	// The current state of the attachment.
+	State *string `locationName:"state" type:"string" enum:"AttachmentStatus"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"vpcId" type:"string"`
+
+	metadataInternetGatewayAttachment `json:"-" xml:"-"`
+}
+
+type metadataInternetGatewayAttachment struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s InternetGatewayAttachment) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InternetGatewayAttachment) GoString() string {
+	return s.String()
+}
+
+// Describes a key pair.
+type KeyPairInfo struct {
+	// If you used CreateKeyPair to create the key pair, this is the SHA-1 digest
+	// of the DER encoded private key. If you used ImportKeyPair to provide AWS
+	// the public key, this is the MD5 public key fingerprint as specified in section
+	// 4 of RFC4716.
+	KeyFingerprint *string `locationName:"keyFingerprint" type:"string"`
+
+	// The name of the key pair.
+	KeyName *string `locationName:"keyName" type:"string"`
+
+	metadataKeyPairInfo `json:"-" xml:"-"`
+}
+
+type metadataKeyPairInfo struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s KeyPairInfo) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s KeyPairInfo) GoString() string {
+	return s.String()
+}
+
+// Describes a launch permission.
+type LaunchPermission struct {
+	// The name of the group.
+	Group *string `locationName:"group" type:"string" enum:"PermissionGroup"`
+
+	// The AWS account ID.
+	UserID *string `locationName:"userId" type:"string"`
+
+	metadataLaunchPermission `json:"-" xml:"-"`
+}
+
+type metadataLaunchPermission struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s LaunchPermission) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s LaunchPermission) GoString() string {
+	return s.String()
+}
+
+// Describes a launch permission modification.
+type LaunchPermissionModifications struct {
+	// The AWS account ID to add to the list of launch permissions for the AMI.
+	Add []*LaunchPermission `locationNameList:"item" type:"list"`
+
+	// The AWS account ID to remove from the list of launch permissions for the
+	// AMI.
+	Remove []*LaunchPermission `locationNameList:"item" type:"list"`
+
+	metadataLaunchPermissionModifications `json:"-" xml:"-"`
+}
+
+type metadataLaunchPermissionModifications struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s LaunchPermissionModifications) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s LaunchPermissionModifications) GoString() string {
+	return s.String()
+}
+
+// Describes the launch specification for an instance.
+type LaunchSpecification struct {
+	// Deprecated.
+	AddressingType *string `locationName:"addressingType" type:"string"`
+
+	// One or more block device mapping entries.
+	BlockDeviceMappings []*BlockDeviceMapping `locationName:"blockDeviceMapping" locationNameList:"item" type:"list"`
+
+	// Indicates whether the instance is optimized for EBS I/O. This optimization
+	// provides dedicated throughput to Amazon EBS and an optimized configuration
+	// stack to provide optimal EBS I/O performance. This optimization isn't available
+	// with all instance types. Additional usage charges apply when using an EBS
+	// Optimized instance.
+	//
+	// Default: false
+	EBSOptimized *bool `locationName:"ebsOptimized" type:"boolean"`
+
+	// The IAM instance profile.
+	IAMInstanceProfile *IAMInstanceProfileSpecification `locationName:"iamInstanceProfile" type:"structure"`
+
+	// The ID of the AMI.
+	ImageID *string `locationName:"imageId" type:"string"`
+
+	// The instance type.
+	InstanceType *string `locationName:"instanceType" type:"string" enum:"InstanceType"`
+
+	// The ID of the kernel.
+	KernelID *string `locationName:"kernelId" type:"string"`
+
+	// The name of the key pair.
+	KeyName *string `locationName:"keyName" type:"string"`
+
+	// Describes the monitoring for the instance.
+	Monitoring *RunInstancesMonitoringEnabled `locationName:"monitoring" type:"structure"`
+
+	// One or more network interfaces.
+	NetworkInterfaces []*InstanceNetworkInterfaceSpecification `locationName:"networkInterfaceSet" locationNameList:"item" type:"list"`
+
+	// The placement information for the instance.
+	Placement *SpotPlacement `locationName:"placement" type:"structure"`
+
+	// The ID of the RAM disk.
+	RAMDiskID *string `locationName:"ramdiskId" type:"string"`
+
+	// One or more security groups. To request an instance in a nondefault VPC,
+	// you must specify the ID of the security group. To request an instance in
+	// EC2-Classic or a default VPC, you can specify the name or the ID of the security
+	// group.
+	SecurityGroups []*GroupIdentifier `locationName:"groupSet" locationNameList:"item" type:"list"`
+
+	// The ID of the subnet in which to launch the instance.
+	SubnetID *string `locationName:"subnetId" type:"string"`
+
+	// The Base64-encoded MIME user data to make available to the instances.
+	UserData *string `locationName:"userData" type:"string"`
+
+	metadataLaunchSpecification `json:"-" xml:"-"`
+}
+
+type metadataLaunchSpecification struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s LaunchSpecification) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s LaunchSpecification) GoString() string {
+	return s.String()
+}
+
+type ModifyImageAttributeInput struct {
+	// The name of the attribute to modify.
+	Attribute *string `type:"string"`
+
+	// A description for the AMI.
+	Description *AttributeValue `type:"structure"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the AMI.
+	ImageID *string `locationName:"ImageId" type:"string" required:"true"`
+
+	// A launch permission modification.
+	LaunchPermission *LaunchPermissionModifications `type:"structure"`
+
+	// The operation type.
+	OperationType *string `type:"string"`
+
+	// One or more product codes. After you add a product code to an AMI, it can't
+	// be removed. This is only valid when modifying the productCodes attribute.
+	ProductCodes []*string `locationName:"ProductCode" locationNameList:"ProductCode" type:"list"`
+
+	// One or more user groups. This is only valid when modifying the launchPermission
+	// attribute.
+	UserGroups []*string `locationName:"UserGroup" locationNameList:"UserGroup" type:"list"`
+
+	// One or more AWS account IDs. This is only valid when modifying the launchPermission
+	// attribute.
+	UserIDs []*string `locationName:"UserId" locationNameList:"UserId" type:"list"`
+
+	// The value of the attribute being modified. This is only valid when modifying
+	// the description attribute.
+	Value *string `type:"string"`
+
+	metadataModifyImageAttributeInput `json:"-" xml:"-"`
+}
+
+type metadataModifyImageAttributeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ModifyImageAttributeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ModifyImageAttributeInput) GoString() string {
+	return s.String()
+}
+
+type ModifyImageAttributeOutput struct {
+	metadataModifyImageAttributeOutput `json:"-" xml:"-"`
+}
+
+type metadataModifyImageAttributeOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ModifyImageAttributeOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ModifyImageAttributeOutput) GoString() string {
+	return s.String()
+}
+
+type ModifyInstanceAttributeInput struct {
+	// The name of the attribute.
+	Attribute *string `locationName:"attribute" type:"string" enum:"InstanceAttributeName"`
+
+	// Modifies the DeleteOnTermination attribute for volumes that are currently
+	// attached. The volume must be owned by the caller. If no value is specified
+	// for DeleteOnTermination, the default is true and the volume is deleted when
+	// the instance is terminated.
+	//
+	// To add instance store volumes to an Amazon EBS-backed instance, you must
+	// add them when you launch the instance. For more information, see Updating
+	// the Block Device Mapping when Launching an Instance (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html#Using_OverridingAMIBDM)
+	// in the Amazon Elastic Compute Cloud User Guide.
+	BlockDeviceMappings []*InstanceBlockDeviceMappingSpecification `locationName:"blockDeviceMapping" locationNameList:"item" type:"list"`
+
+	// If the value is true, you can't terminate the instance using the Amazon EC2
+	// console, CLI, or API; otherwise, you can.
+	DisableAPITermination *AttributeBooleanValue `locationName:"disableApiTermination" type:"structure"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// Specifies whether the instance is optimized for EBS I/O. This optimization
+	// provides dedicated throughput to Amazon EBS and an optimized configuration
+	// stack to provide optimal EBS I/O performance. This optimization isn't available
+	// with all instance types. Additional usage charges apply when using an EBS
+	// Optimized instance.
+	EBSOptimized *AttributeBooleanValue `locationName:"ebsOptimized" type:"structure"`
+
+	// [EC2-VPC] Changes the security groups of the instance. You must specify at
+	// least one security group, even if it's just the default security group for
+	// the VPC. You must specify the security group ID, not the security group name.
+	Groups []*string `locationName:"GroupId" locationNameList:"groupId" type:"list"`
+
+	// The ID of the instance.
+	InstanceID *string `locationName:"instanceId" type:"string" required:"true"`
+
+	// Specifies whether an instance stops or terminates when you initiate shutdown
+	// from the instance (using the operating system command for system shutdown).
+	InstanceInitiatedShutdownBehavior *AttributeValue `locationName:"instanceInitiatedShutdownBehavior" type:"structure"`
+
+	// Changes the instance type to the specified value. For more information, see
+	// Instance Types (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html).
+	// If the instance type is not valid, the error returned is InvalidInstanceAttributeValue.
+	InstanceType *AttributeValue `locationName:"instanceType" type:"structure"`
+
+	// Changes the instance's kernel to the specified value. We recommend that you
+	// use PV-GRUB instead of kernels and RAM disks. For more information, see PV-GRUB
+	// (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UserProvidedKernels.html).
+	Kernel *AttributeValue `locationName:"kernel" type:"structure"`
+
+	// Changes the instance's RAM disk to the specified value. We recommend that
+	// you use PV-GRUB instead of kernels and RAM disks. For more information, see
+	// PV-GRUB (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UserProvidedKernels.html).
+	RAMDisk *AttributeValue `locationName:"ramdisk" type:"structure"`
+
+	// Set to simple to enable enhanced networking for the instance.
+	//
+	// There is no way to disable enhanced networking at this time.
+	//
+	// This option is supported only for HVM instances. Specifying this option
+	// with a PV instance can make it unreachable.
+	SRIOVNetSupport *AttributeValue `locationName:"sriovNetSupport" type:"structure"`
+
+	// Specifies whether source/destination checking is enabled. A value of true
+	// means that checking is enabled, and false means checking is disabled. This
+	// value must be false for a NAT instance to perform NAT.
+	SourceDestCheck *AttributeBooleanValue `type:"structure"`
+
+	// Changes the instance's user data to the specified value.
+	UserData *BlobAttributeValue `locationName:"userData" type:"structure"`
+
+	// A new value for the attribute. Use only with the kernel, ramdisk, userData,
+	// disableApiTermination, or intanceInitiateShutdownBehavior attribute.
+	Value *string `locationName:"value" type:"string"`
+
+	metadataModifyInstanceAttributeInput `json:"-" xml:"-"`
+}
+
+type metadataModifyInstanceAttributeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ModifyInstanceAttributeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ModifyInstanceAttributeInput) GoString() string {
+	return s.String()
+}
+
+type ModifyInstanceAttributeOutput struct {
+	metadataModifyInstanceAttributeOutput `json:"-" xml:"-"`
+}
+
+type metadataModifyInstanceAttributeOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ModifyInstanceAttributeOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ModifyInstanceAttributeOutput) GoString() string {
+	return s.String()
+}
+
+type ModifyNetworkInterfaceAttributeInput struct {
+	// Information about the interface attachment. If modifying the 'delete on termination'
+	// attribute, you must specify the ID of the interface attachment.
+	Attachment *NetworkInterfaceAttachmentChanges `locationName:"attachment" type:"structure"`
+
+	// A description for the network interface.
+	Description *AttributeValue `locationName:"description" type:"structure"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// Changes the security groups for the network interface. The new set of groups
+	// you specify replaces the current set. You must specify at least one group,
+	// even if it's just the default security group in the VPC. You must specify
+	// the ID of the security group, not the name.
+	Groups []*string `locationName:"SecurityGroupId" locationNameList:"SecurityGroupId" type:"list"`
+
+	// The ID of the network interface.
+	NetworkInterfaceID *string `locationName:"networkInterfaceId" type:"string" required:"true"`
+
+	// Indicates whether source/destination checking is enabled. A value of true
+	// means checking is enabled, and false means checking is disabled. This value
+	// must be false for a NAT instance to perform NAT. For more information, see
+	// NAT Instances (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_NAT_Instance.html)
+	// in the Amazon Virtual Private Cloud User Guide.
+	SourceDestCheck *AttributeBooleanValue `locationName:"sourceDestCheck" type:"structure"`
+
+	metadataModifyNetworkInterfaceAttributeInput `json:"-" xml:"-"`
+}
+
+type metadataModifyNetworkInterfaceAttributeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ModifyNetworkInterfaceAttributeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ModifyNetworkInterfaceAttributeInput) GoString() string {
+	return s.String()
+}
+
+type ModifyNetworkInterfaceAttributeOutput struct {
+	metadataModifyNetworkInterfaceAttributeOutput `json:"-" xml:"-"`
+}
+
+type metadataModifyNetworkInterfaceAttributeOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ModifyNetworkInterfaceAttributeOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ModifyNetworkInterfaceAttributeOutput) GoString() string {
+	return s.String()
+}
+
+type ModifyReservedInstancesInput struct {
+	// A unique, case-sensitive token you provide to ensure idempotency of your
+	// modification request. For more information, see Ensuring Idempotency (http://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html).
+	ClientToken *string `locationName:"clientToken" type:"string"`
+
+	// The IDs of the Reserved Instances to modify.
+	ReservedInstancesIDs []*string `locationName:"ReservedInstancesId" locationNameList:"ReservedInstancesId" type:"list" required:"true"`
+
+	// The configuration settings for the Reserved Instances to modify.
+	TargetConfigurations []*ReservedInstancesConfiguration `locationName:"ReservedInstancesConfigurationSetItemType" locationNameList:"item" type:"list" required:"true"`
+
+	metadataModifyReservedInstancesInput `json:"-" xml:"-"`
+}
+
+type metadataModifyReservedInstancesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ModifyReservedInstancesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ModifyReservedInstancesInput) GoString() string {
+	return s.String()
+}
+
+type ModifyReservedInstancesOutput struct {
+	// The ID for the modification.
+	ReservedInstancesModificationID *string `locationName:"reservedInstancesModificationId" type:"string"`
+
+	metadataModifyReservedInstancesOutput `json:"-" xml:"-"`
+}
+
+type metadataModifyReservedInstancesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ModifyReservedInstancesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ModifyReservedInstancesOutput) GoString() string {
+	return s.String()
+}
+
+type ModifySnapshotAttributeInput struct {
+	// The snapshot attribute to modify.
+	//
+	//  Only volume creation permissions may be modified at the customer level.
+	Attribute *string `type:"string" enum:"SnapshotAttributeName"`
+
+	// A JSON representation of the snapshot attribute modification.
+	CreateVolumePermission *CreateVolumePermissionModifications `type:"structure"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The group to modify for the snapshot.
+	GroupNames []*string `locationName:"UserGroup" locationNameList:"GroupName" type:"list"`
+
+	// The type of operation to perform to the attribute.
+	OperationType *string `type:"string"`
+
+	// The ID of the snapshot.
+	SnapshotID *string `locationName:"SnapshotId" type:"string" required:"true"`
+
+	// The account ID to modify for the snapshot.
+	UserIDs []*string `locationName:"UserId" locationNameList:"UserId" type:"list"`
+
+	metadataModifySnapshotAttributeInput `json:"-" xml:"-"`
+}
+
+type metadataModifySnapshotAttributeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ModifySnapshotAttributeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ModifySnapshotAttributeInput) GoString() string {
+	return s.String()
+}
+
+type ModifySnapshotAttributeOutput struct {
+	metadataModifySnapshotAttributeOutput `json:"-" xml:"-"`
+}
+
+type metadataModifySnapshotAttributeOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ModifySnapshotAttributeOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ModifySnapshotAttributeOutput) GoString() string {
+	return s.String()
+}
+
+type ModifySubnetAttributeInput struct {
+	// Specify true to indicate that instances launched into the specified subnet
+	// should be assigned public IP address.
+	MapPublicIPOnLaunch *AttributeBooleanValue `locationName:"MapPublicIpOnLaunch" type:"structure"`
+
+	// The ID of the subnet.
+	SubnetID *string `locationName:"subnetId" type:"string" required:"true"`
+
+	metadataModifySubnetAttributeInput `json:"-" xml:"-"`
+}
+
+type metadataModifySubnetAttributeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ModifySubnetAttributeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ModifySubnetAttributeInput) GoString() string {
+	return s.String()
+}
+
+type ModifySubnetAttributeOutput struct {
+	metadataModifySubnetAttributeOutput `json:"-" xml:"-"`
+}
+
+type metadataModifySubnetAttributeOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ModifySubnetAttributeOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ModifySubnetAttributeOutput) GoString() string {
+	return s.String()
+}
+
+type ModifyVPCAttributeInput struct {
+	// Indicates whether the instances launched in the VPC get DNS hostnames. If
+	// enabled, instances in the VPC get DNS hostnames; otherwise, they do not.
+	//
+	// You can only enable DNS hostnames if you also enable DNS support.
+	EnableDNSHostnames *AttributeBooleanValue `locationName:"EnableDnsHostnames" type:"structure"`
+
+	// Indicates whether the DNS resolution is supported for the VPC. If enabled,
+	// queries to the Amazon provided DNS server at the 169.254.169.253 IP address,
+	// or the reserved IP address at the base of the VPC network range "plus two"
+	// will succeed. If disabled, the Amazon provided DNS service in the VPC that
+	// resolves public DNS hostnames to IP addresses is not enabled.
+	EnableDNSSupport *AttributeBooleanValue `locationName:"EnableDnsSupport" type:"structure"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"vpcId" type:"string" required:"true"`
+
+	metadataModifyVPCAttributeInput `json:"-" xml:"-"`
+}
+
+type metadataModifyVPCAttributeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ModifyVPCAttributeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ModifyVPCAttributeInput) GoString() string {
+	return s.String()
+}
+
+type ModifyVPCAttributeOutput struct {
+	metadataModifyVPCAttributeOutput `json:"-" xml:"-"`
+}
+
+type metadataModifyVPCAttributeOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ModifyVPCAttributeOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ModifyVPCAttributeOutput) GoString() string {
+	return s.String()
+}
+
+type ModifyVPCEndpointInput struct {
+	// One or more route tables IDs to associate with the endpoint.
+	AddRouteTableIDs []*string `locationName:"AddRouteTableId" locationNameList:"item" type:"list"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `type:"boolean"`
+
+	// A policy document to attach to the endpoint. The policy must be in valid
+	// JSON format.
+	PolicyDocument *string `type:"string"`
+
+	// One or more route table IDs to disassociate from the endpoint.
+	RemoveRouteTableIDs []*string `locationName:"RemoveRouteTableId" locationNameList:"item" type:"list"`
+
+	// Specify true to reset the policy document to the default policy. The default
+	// policy allows access to the service.
+	ResetPolicy *bool `type:"boolean"`
+
+	// The ID of the endpoint.
+	VPCEndpointID *string `locationName:"VpcEndpointId" type:"string" required:"true"`
+
+	metadataModifyVPCEndpointInput `json:"-" xml:"-"`
+}
+
+type metadataModifyVPCEndpointInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ModifyVPCEndpointInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ModifyVPCEndpointInput) GoString() string {
+	return s.String()
+}
+
+type ModifyVPCEndpointOutput struct {
+	// Returns true if the request succeeds; otherwise, it returns an error.
+	Return *bool `locationName:"return" type:"boolean"`
+
+	metadataModifyVPCEndpointOutput `json:"-" xml:"-"`
+}
+
+type metadataModifyVPCEndpointOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ModifyVPCEndpointOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ModifyVPCEndpointOutput) GoString() string {
+	return s.String()
+}
+
+type ModifyVolumeAttributeInput struct {
+	// Indicates whether the volume should be auto-enabled for I/O operations.
+	AutoEnableIO *AttributeBooleanValue `type:"structure"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the volume.
+	VolumeID *string `locationName:"VolumeId" type:"string" required:"true"`
+
+	metadataModifyVolumeAttributeInput `json:"-" xml:"-"`
+}
+
+type metadataModifyVolumeAttributeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ModifyVolumeAttributeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ModifyVolumeAttributeInput) GoString() string {
+	return s.String()
+}
+
+type ModifyVolumeAttributeOutput struct {
+	metadataModifyVolumeAttributeOutput `json:"-" xml:"-"`
+}
+
+type metadataModifyVolumeAttributeOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ModifyVolumeAttributeOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ModifyVolumeAttributeOutput) GoString() string {
+	return s.String()
+}
+
+type MonitorInstancesInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more instance IDs.
+	InstanceIDs []*string `locationName:"InstanceId" locationNameList:"InstanceId" type:"list" required:"true"`
+
+	metadataMonitorInstancesInput `json:"-" xml:"-"`
+}
+
+type metadataMonitorInstancesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s MonitorInstancesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s MonitorInstancesInput) GoString() string {
+	return s.String()
+}
+
+type MonitorInstancesOutput struct {
+	// Monitoring information for one or more instances.
+	InstanceMonitorings []*InstanceMonitoring `locationName:"instancesSet" locationNameList:"item" type:"list"`
+
+	metadataMonitorInstancesOutput `json:"-" xml:"-"`
+}
+
+type metadataMonitorInstancesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s MonitorInstancesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s MonitorInstancesOutput) GoString() string {
+	return s.String()
+}
+
+// Describes the monitoring for the instance.
+type Monitoring struct {
+	// Indicates whether monitoring is enabled for the instance.
+	State *string `locationName:"state" type:"string" enum:"MonitoringState"`
+
+	metadataMonitoring `json:"-" xml:"-"`
+}
+
+type metadataMonitoring struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s Monitoring) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Monitoring) GoString() string {
+	return s.String()
+}
+
+type MoveAddressToVPCInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The Elastic IP address.
+	PublicIP *string `locationName:"publicIp" type:"string" required:"true"`
+
+	metadataMoveAddressToVPCInput `json:"-" xml:"-"`
+}
+
+type metadataMoveAddressToVPCInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s MoveAddressToVPCInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s MoveAddressToVPCInput) GoString() string {
+	return s.String()
+}
+
+type MoveAddressToVPCOutput struct {
+	// The allocation ID for the Elastic IP address.
+	AllocationID *string `locationName:"allocationId" type:"string"`
+
+	// The status of the move of the IP address.
+	Status *string `locationName:"status" type:"string" enum:"Status"`
+
+	metadataMoveAddressToVPCOutput `json:"-" xml:"-"`
+}
+
+type metadataMoveAddressToVPCOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s MoveAddressToVPCOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s MoveAddressToVPCOutput) GoString() string {
+	return s.String()
+}
+
+// Describes the status of a moving Elastic IP address.
+type MovingAddressStatus struct {
+	// The status of the Elastic IP address that's being moved to the EC2-VPC platform,
+	// or restored to the EC2-Classic platform.
+	MoveStatus *string `locationName:"moveStatus" type:"string" enum:"MoveStatus"`
+
+	// The Elastic IP address.
+	PublicIP *string `locationName:"publicIp" type:"string"`
+
+	metadataMovingAddressStatus `json:"-" xml:"-"`
+}
+
+type metadataMovingAddressStatus struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s MovingAddressStatus) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s MovingAddressStatus) GoString() string {
+	return s.String()
+}
+
+// Describes a network ACL.
+type NetworkACL struct {
+	// Any associations between the network ACL and one or more subnets
+	Associations []*NetworkACLAssociation `locationName:"associationSet" locationNameList:"item" type:"list"`
+
+	// One or more entries (rules) in the network ACL.
+	Entries []*NetworkACLEntry `locationName:"entrySet" locationNameList:"item" type:"list"`
+
+	// Indicates whether this is the default network ACL for the VPC.
+	IsDefault *bool `locationName:"default" type:"boolean"`
+
+	// The ID of the network ACL.
+	NetworkACLID *string `locationName:"networkAclId" type:"string"`
+
+	// Any tags assigned to the network ACL.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	// The ID of the VPC for the network ACL.
+	VPCID *string `locationName:"vpcId" type:"string"`
+
+	metadataNetworkACL `json:"-" xml:"-"`
+}
+
+type metadataNetworkACL struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s NetworkACL) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s NetworkACL) GoString() string {
+	return s.String()
+}
+
+// Describes an association between a network ACL and a subnet.
+type NetworkACLAssociation struct {
+	// The ID of the association between a network ACL and a subnet.
+	NetworkACLAssociationID *string `locationName:"networkAclAssociationId" type:"string"`
+
+	// The ID of the network ACL.
+	NetworkACLID *string `locationName:"networkAclId" type:"string"`
+
+	// The ID of the subnet.
+	SubnetID *string `locationName:"subnetId" type:"string"`
+
+	metadataNetworkACLAssociation `json:"-" xml:"-"`
+}
+
+type metadataNetworkACLAssociation struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s NetworkACLAssociation) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s NetworkACLAssociation) GoString() string {
+	return s.String()
+}
+
+// Describes an entry in a network ACL.
+type NetworkACLEntry struct {
+	// The network range to allow or deny, in CIDR notation.
+	CIDRBlock *string `locationName:"cidrBlock" type:"string"`
+
+	// Indicates whether the rule is an egress rule (applied to traffic leaving
+	// the subnet).
+	Egress *bool `locationName:"egress" type:"boolean"`
+
+	// ICMP protocol: The ICMP type and code.
+	ICMPTypeCode *ICMPTypeCode `locationName:"icmpTypeCode" type:"structure"`
+
+	// TCP or UDP protocols: The range of ports the rule applies to.
+	PortRange *PortRange `locationName:"portRange" type:"structure"`
+
+	// The protocol. A value of -1 means all protocols.
+	Protocol *string `locationName:"protocol" type:"string"`
+
+	// Indicates whether to allow or deny the traffic that matches the rule.
+	RuleAction *string `locationName:"ruleAction" type:"string" enum:"RuleAction"`
+
+	// The rule number for the entry. ACL entries are processed in ascending order
+	// by rule number.
+	RuleNumber *int64 `locationName:"ruleNumber" type:"integer"`
+
+	metadataNetworkACLEntry `json:"-" xml:"-"`
+}
+
+type metadataNetworkACLEntry struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s NetworkACLEntry) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s NetworkACLEntry) GoString() string {
+	return s.String()
+}
+
+// Describes a network interface.
+type NetworkInterface struct {
+	// The association information for an Elastic IP associated with the network
+	// interface.
+	Association *NetworkInterfaceAssociation `locationName:"association" type:"structure"`
+
+	// The network interface attachment.
+	Attachment *NetworkInterfaceAttachment `locationName:"attachment" type:"structure"`
+
+	// The Availability Zone.
+	AvailabilityZone *string `locationName:"availabilityZone" type:"string"`
+
+	// A description.
+	Description *string `locationName:"description" type:"string"`
+
+	// Any security groups for the network interface.
+	Groups []*GroupIdentifier `locationName:"groupSet" locationNameList:"item" type:"list"`
+
+	// The MAC address.
+	MACAddress *string `locationName:"macAddress" type:"string"`
+
+	// The ID of the network interface.
+	NetworkInterfaceID *string `locationName:"networkInterfaceId" type:"string"`
+
+	// The AWS account ID of the owner of the network interface.
+	OwnerID *string `locationName:"ownerId" type:"string"`
+
+	// The private DNS name.
+	PrivateDNSName *string `locationName:"privateDnsName" type:"string"`
+
+	// The IP address of the network interface within the subnet.
+	PrivateIPAddress *string `locationName:"privateIpAddress" type:"string"`
+
+	// The private IP addresses associated with the network interface.
+	PrivateIPAddresses []*NetworkInterfacePrivateIPAddress `locationName:"privateIpAddressesSet" locationNameList:"item" type:"list"`
+
+	// The ID of the entity that launched the instance on your behalf (for example,
+	// AWS Management Console or Auto Scaling).
+	RequesterID *string `locationName:"requesterId" type:"string"`
+
+	// Indicates whether the network interface is being managed by AWS.
+	RequesterManaged *bool `locationName:"requesterManaged" type:"boolean"`
+
+	// Indicates whether traffic to or from the instance is validated.
+	SourceDestCheck *bool `locationName:"sourceDestCheck" type:"boolean"`
+
+	// The status of the network interface.
+	Status *string `locationName:"status" type:"string" enum:"NetworkInterfaceStatus"`
+
+	// The ID of the subnet.
+	SubnetID *string `locationName:"subnetId" type:"string"`
+
+	// Any tags assigned to the network interface.
+	TagSet []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"vpcId" type:"string"`
+
+	metadataNetworkInterface `json:"-" xml:"-"`
+}
+
+type metadataNetworkInterface struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s NetworkInterface) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s NetworkInterface) GoString() string {
+	return s.String()
+}
+
+// Describes association information for an Elastic IP address.
+type NetworkInterfaceAssociation struct {
+	// The allocation ID.
+	AllocationID *string `locationName:"allocationId" type:"string"`
+
+	// The association ID.
+	AssociationID *string `locationName:"associationId" type:"string"`
+
+	// The ID of the Elastic IP address owner.
+	IPOwnerID *string `locationName:"ipOwnerId" type:"string"`
+
+	// The public DNS name.
+	PublicDNSName *string `locationName:"publicDnsName" type:"string"`
+
+	// The address of the Elastic IP address bound to the network interface.
+	PublicIP *string `locationName:"publicIp" type:"string"`
+
+	metadataNetworkInterfaceAssociation `json:"-" xml:"-"`
+}
+
+type metadataNetworkInterfaceAssociation struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s NetworkInterfaceAssociation) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s NetworkInterfaceAssociation) GoString() string {
+	return s.String()
+}
+
+// Describes a network interface attachment.
+type NetworkInterfaceAttachment struct {
+	// The timestamp indicating when the attachment initiated.
+	AttachTime *time.Time `locationName:"attachTime" type:"timestamp" timestampFormat:"iso8601"`
+
+	// The ID of the network interface attachment.
+	AttachmentID *string `locationName:"attachmentId" type:"string"`
+
+	// Indicates whether the network interface is deleted when the instance is terminated.
+	DeleteOnTermination *bool `locationName:"deleteOnTermination" type:"boolean"`
+
+	// The device index of the network interface attachment on the instance.
+	DeviceIndex *int64 `locationName:"deviceIndex" type:"integer"`
+
+	// The ID of the instance.
+	InstanceID *string `locationName:"instanceId" type:"string"`
+
+	// The AWS account ID of the owner of the instance.
+	InstanceOwnerID *string `locationName:"instanceOwnerId" type:"string"`
+
+	// The attachment state.
+	Status *string `locationName:"status" type:"string" enum:"AttachmentStatus"`
+
+	metadataNetworkInterfaceAttachment `json:"-" xml:"-"`
+}
+
+type metadataNetworkInterfaceAttachment struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s NetworkInterfaceAttachment) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s NetworkInterfaceAttachment) GoString() string {
+	return s.String()
+}
+
+// Describes an attachment change.
+type NetworkInterfaceAttachmentChanges struct {
+	// The ID of the network interface attachment.
+	AttachmentID *string `locationName:"attachmentId" type:"string"`
+
+	// Indicates whether the network interface is deleted when the instance is terminated.
+	DeleteOnTermination *bool `locationName:"deleteOnTermination" type:"boolean"`
+
+	metadataNetworkInterfaceAttachmentChanges `json:"-" xml:"-"`
+}
+
+type metadataNetworkInterfaceAttachmentChanges struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s NetworkInterfaceAttachmentChanges) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s NetworkInterfaceAttachmentChanges) GoString() string {
+	return s.String()
+}
+
+// Describes the private IP address of a network interface.
+type NetworkInterfacePrivateIPAddress struct {
+	// The association information for an Elastic IP address associated with the
+	// network interface.
+	Association *NetworkInterfaceAssociation `locationName:"association" type:"structure"`
+
+	// Indicates whether this IP address is the primary private IP address of the
+	// network interface.
+	Primary *bool `locationName:"primary" type:"boolean"`
+
+	// The private DNS name.
+	PrivateDNSName *string `locationName:"privateDnsName" type:"string"`
+
+	// The private IP address.
+	PrivateIPAddress *string `locationName:"privateIpAddress" type:"string"`
+
+	metadataNetworkInterfacePrivateIPAddress `json:"-" xml:"-"`
+}
+
+type metadataNetworkInterfacePrivateIPAddress struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s NetworkInterfacePrivateIPAddress) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s NetworkInterfacePrivateIPAddress) GoString() string {
+	return s.String()
+}
+
+type NewDHCPConfiguration struct {
+	Key *string `locationName:"key" type:"string"`
+
+	Values []*string `locationName:"Value" locationNameList:"item" type:"list"`
+
+	metadataNewDHCPConfiguration `json:"-" xml:"-"`
+}
+
+type metadataNewDHCPConfiguration struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s NewDHCPConfiguration) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s NewDHCPConfiguration) GoString() string {
+	return s.String()
+}
+
+// Describes the placement for the instance.
+type Placement struct {
+	// The Availability Zone of the instance.
+	AvailabilityZone *string `locationName:"availabilityZone" type:"string"`
+
+	// The name of the placement group the instance is in (for cluster compute instances).
+	GroupName *string `locationName:"groupName" type:"string"`
+
+	// The tenancy of the instance (if the instance is running in a VPC). An instance
+	// with a tenancy of dedicated runs on single-tenant hardware.
+	Tenancy *string `locationName:"tenancy" type:"string" enum:"Tenancy"`
+
+	metadataPlacement `json:"-" xml:"-"`
+}
+
+type metadataPlacement struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s Placement) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Placement) GoString() string {
+	return s.String()
+}
+
+// Describes a placement group.
+type PlacementGroup struct {
+	// The name of the placement group.
+	GroupName *string `locationName:"groupName" type:"string"`
+
+	// The state of the placement group.
+	State *string `locationName:"state" type:"string" enum:"PlacementGroupState"`
+
+	// The placement strategy.
+	Strategy *string `locationName:"strategy" type:"string" enum:"PlacementStrategy"`
+
+	metadataPlacementGroup `json:"-" xml:"-"`
+}
+
+type metadataPlacementGroup struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s PlacementGroup) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PlacementGroup) GoString() string {
+	return s.String()
+}
+
+// Describes a range of ports.
+type PortRange struct {
+	// The first port in the range.
+	From *int64 `locationName:"from" type:"integer"`
+
+	// The last port in the range.
+	To *int64 `locationName:"to" type:"integer"`
+
+	metadataPortRange `json:"-" xml:"-"`
+}
+
+type metadataPortRange struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s PortRange) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PortRange) GoString() string {
+	return s.String()
+}
+
+// Describes prefixes for AWS services.
+type PrefixList struct {
+	// The IP address range of the AWS service.
+	CIDRs []*string `locationName:"cidrSet" locationNameList:"item" type:"list"`
+
+	// The ID of the prefix.
+	PrefixListID *string `locationName:"prefixListId" type:"string"`
+
+	// The name of the prefix.
+	PrefixListName *string `locationName:"prefixListName" type:"string"`
+
+	metadataPrefixList `json:"-" xml:"-"`
+}
+
+type metadataPrefixList struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s PrefixList) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PrefixList) GoString() string {
+	return s.String()
+}
+
+// The ID of the prefix.
+type PrefixListID struct {
+	// The ID of the prefix.
+	PrefixListID *string `locationName:"prefixListId" type:"string"`
+
+	metadataPrefixListID `json:"-" xml:"-"`
+}
+
+type metadataPrefixListID struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s PrefixListID) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PrefixListID) GoString() string {
+	return s.String()
+}
+
+// Describes the price for a Reserved Instance.
+type PriceSchedule struct {
+	// The current price schedule, as determined by the term remaining for the Reserved
+	// Instance in the listing.
+	//
+	// A specific price schedule is always in effect, but only one price schedule
+	// can be active at any time. Take, for example, a Reserved Instance listing
+	// that has five months remaining in its term. When you specify price schedules
+	// for five months and two months, this means that schedule 1, covering the
+	// first three months of the remaining term, will be active during months 5,
+	// 4, and 3. Then schedule 2, covering the last two months of the term, will
+	// be active for months 2 and 1.
+	Active *bool `locationName:"active" type:"boolean"`
+
+	// The currency for transacting the Reserved Instance resale. At this time,
+	// the only supported currency is USD.
+	CurrencyCode *string `locationName:"currencyCode" type:"string" enum:"CurrencyCodeValues"`
+
+	// The fixed price for the term.
+	Price *float64 `locationName:"price" type:"double"`
+
+	// The number of months remaining in the reservation. For example, 2 is the
+	// second to the last month before the capacity reservation expires.
+	Term *int64 `locationName:"term" type:"long"`
+
+	metadataPriceSchedule `json:"-" xml:"-"`
+}
+
+type metadataPriceSchedule struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s PriceSchedule) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PriceSchedule) GoString() string {
+	return s.String()
+}
+
+// Describes the price for a Reserved Instance.
+type PriceScheduleSpecification struct {
+	// The currency for transacting the Reserved Instance resale. At this time,
+	// the only supported currency is USD.
+	CurrencyCode *string `locationName:"currencyCode" type:"string" enum:"CurrencyCodeValues"`
+
+	// The fixed price for the term.
+	Price *float64 `locationName:"price" type:"double"`
+
+	// The number of months remaining in the reservation. For example, 2 is the
+	// second to the last month before the capacity reservation expires.
+	Term *int64 `locationName:"term" type:"long"`
+
+	metadataPriceScheduleSpecification `json:"-" xml:"-"`
+}
+
+type metadataPriceScheduleSpecification struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s PriceScheduleSpecification) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PriceScheduleSpecification) GoString() string {
+	return s.String()
+}
+
+// Describes a Reserved Instance offering.
+type PricingDetail struct {
+	// The number of instances available for the price.
+	Count *int64 `locationName:"count" type:"integer"`
+
+	// The price per instance.
+	Price *float64 `locationName:"price" type:"double"`
+
+	metadataPricingDetail `json:"-" xml:"-"`
+}
+
+type metadataPricingDetail struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s PricingDetail) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PricingDetail) GoString() string {
+	return s.String()
+}
+
+// Describes a secondary private IP address for a network interface.
+type PrivateIPAddressSpecification struct {
+	// Indicates whether the private IP address is the primary private IP address.
+	// Only one IP address can be designated as primary.
+	Primary *bool `locationName:"primary" type:"boolean"`
+
+	// The private IP addresses.
+	PrivateIPAddress *string `locationName:"privateIpAddress" type:"string" required:"true"`
+
+	metadataPrivateIPAddressSpecification `json:"-" xml:"-"`
+}
+
+type metadataPrivateIPAddressSpecification struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s PrivateIPAddressSpecification) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PrivateIPAddressSpecification) GoString() string {
+	return s.String()
+}
+
+// Describes a product code.
+type ProductCode struct {
+	// The product code.
+	ProductCodeID *string `locationName:"productCode" type:"string"`
+
+	// The type of product code.
+	ProductCodeType *string `locationName:"type" type:"string" enum:"ProductCodeValues"`
+
+	metadataProductCode `json:"-" xml:"-"`
+}
+
+type metadataProductCode struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ProductCode) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ProductCode) GoString() string {
+	return s.String()
+}
+
+// Describes a virtual private gateway propagating route.
+type PropagatingVGW struct {
+	// The ID of the virtual private gateway (VGW).
+	GatewayID *string `locationName:"gatewayId" type:"string"`
+
+	metadataPropagatingVGW `json:"-" xml:"-"`
+}
+
+type metadataPropagatingVGW struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s PropagatingVGW) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PropagatingVGW) GoString() string {
+	return s.String()
+}
+
+type PurchaseReservedInstancesOfferingInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The number of Reserved Instances to purchase.
+	InstanceCount *int64 `type:"integer" required:"true"`
+
+	// Specified for Reserved Instance Marketplace offerings to limit the total
+	// order and ensure that the Reserved Instances are not purchased at unexpected
+	// prices.
+	LimitPrice *ReservedInstanceLimitPrice `locationName:"limitPrice" type:"structure"`
+
+	// The ID of the Reserved Instance offering to purchase.
+	ReservedInstancesOfferingID *string `locationName:"ReservedInstancesOfferingId" type:"string" required:"true"`
+
+	metadataPurchaseReservedInstancesOfferingInput `json:"-" xml:"-"`
+}
+
+type metadataPurchaseReservedInstancesOfferingInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s PurchaseReservedInstancesOfferingInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PurchaseReservedInstancesOfferingInput) GoString() string {
+	return s.String()
+}
+
+type PurchaseReservedInstancesOfferingOutput struct {
+	// The IDs of the purchased Reserved Instances.
+	ReservedInstancesID *string `locationName:"reservedInstancesId" type:"string"`
+
+	metadataPurchaseReservedInstancesOfferingOutput `json:"-" xml:"-"`
+}
+
+type metadataPurchaseReservedInstancesOfferingOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s PurchaseReservedInstancesOfferingOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PurchaseReservedInstancesOfferingOutput) GoString() string {
+	return s.String()
+}
+
+type RebootInstancesInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more instance IDs.
+	InstanceIDs []*string `locationName:"InstanceId" locationNameList:"InstanceId" type:"list" required:"true"`
+
+	metadataRebootInstancesInput `json:"-" xml:"-"`
+}
+
+type metadataRebootInstancesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RebootInstancesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RebootInstancesInput) GoString() string {
+	return s.String()
+}
+
+type RebootInstancesOutput struct {
+	metadataRebootInstancesOutput `json:"-" xml:"-"`
+}
+
+type metadataRebootInstancesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RebootInstancesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RebootInstancesOutput) GoString() string {
+	return s.String()
+}
+
+// Describes a recurring charge.
+type RecurringCharge struct {
+	// The amount of the recurring charge.
+	Amount *float64 `locationName:"amount" type:"double"`
+
+	// The frequency of the recurring charge.
+	Frequency *string `locationName:"frequency" type:"string" enum:"RecurringChargeFrequency"`
+
+	metadataRecurringCharge `json:"-" xml:"-"`
+}
+
+type metadataRecurringCharge struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RecurringCharge) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RecurringCharge) GoString() string {
+	return s.String()
+}
+
+// Describes a region.
+type Region struct {
+	// The region service endpoint.
+	Endpoint *string `locationName:"regionEndpoint" type:"string"`
+
+	// The name of the region.
+	RegionName *string `locationName:"regionName" type:"string"`
+
+	metadataRegion `json:"-" xml:"-"`
+}
+
+type metadataRegion struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s Region) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Region) GoString() string {
+	return s.String()
+}
+
+type RegisterImageInput struct {
+	// The architecture of the AMI.
+	//
+	// Default: For Amazon EBS-backed AMIs, i386. For instance store-backed AMIs,
+	// the architecture specified in the manifest file.
+	Architecture *string `locationName:"architecture" type:"string" enum:"ArchitectureValues"`
+
+	// One or more block device mapping entries.
+	BlockDeviceMappings []*BlockDeviceMapping `locationName:"BlockDeviceMapping" locationNameList:"BlockDeviceMapping" type:"list"`
+
+	// A description for your AMI.
+	Description *string `locationName:"description" type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The full path to your AMI manifest in Amazon S3 storage.
+	ImageLocation *string `type:"string"`
+
+	// The ID of the kernel.
+	KernelID *string `locationName:"kernelId" type:"string"`
+
+	// A name for your AMI.
+	//
+	// Constraints: 3-128 alphanumeric characters, parentheses (()), square brackets
+	// ([]), spaces ( ), periods (.), slashes (/), dashes (-), single quotes ('),
+	// at-signs (@), or underscores(_)
+	Name *string `locationName:"name" type:"string" required:"true"`
+
+	// The ID of the RAM disk.
+	RAMDiskID *string `locationName:"ramdiskId" type:"string"`
+
+	// The name of the root device (for example, /dev/sda1, or /dev/xvda).
+	RootDeviceName *string `locationName:"rootDeviceName" type:"string"`
+
+	// Set to simple to enable enhanced networking for the AMI and any instances
+	// that you launch from the AMI.
+	//
+	// There is no way to disable enhanced networking at this time.
+	//
+	// This option is supported only for HVM AMIs. Specifying this option with
+	// a PV AMI can make instances launched from the AMI unreachable.
+	SRIOVNetSupport *string `locationName:"sriovNetSupport" type:"string"`
+
+	// The type of virtualization.
+	//
+	// Default: paravirtual
+	VirtualizationType *string `locationName:"virtualizationType" type:"string"`
+
+	metadataRegisterImageInput `json:"-" xml:"-"`
+}
+
+type metadataRegisterImageInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RegisterImageInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RegisterImageInput) GoString() string {
+	return s.String()
+}
+
+type RegisterImageOutput struct {
+	// The ID of the newly registered AMI.
+	ImageID *string `locationName:"imageId" type:"string"`
+
+	metadataRegisterImageOutput `json:"-" xml:"-"`
+}
+
+type metadataRegisterImageOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RegisterImageOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RegisterImageOutput) GoString() string {
+	return s.String()
+}
+
+type RejectVPCPeeringConnectionInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the VPC peering connection.
+	VPCPeeringConnectionID *string `locationName:"vpcPeeringConnectionId" type:"string" required:"true"`
+
+	metadataRejectVPCPeeringConnectionInput `json:"-" xml:"-"`
+}
+
+type metadataRejectVPCPeeringConnectionInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RejectVPCPeeringConnectionInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RejectVPCPeeringConnectionInput) GoString() string {
+	return s.String()
+}
+
+type RejectVPCPeeringConnectionOutput struct {
+	// Returns true if the request succeeds; otherwise, it returns an error.
+	Return *bool `locationName:"return" type:"boolean"`
+
+	metadataRejectVPCPeeringConnectionOutput `json:"-" xml:"-"`
+}
+
+type metadataRejectVPCPeeringConnectionOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RejectVPCPeeringConnectionOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RejectVPCPeeringConnectionOutput) GoString() string {
+	return s.String()
+}
+
+type ReleaseAddressInput struct {
+	// [EC2-VPC] The allocation ID. Required for EC2-VPC.
+	AllocationID *string `locationName:"AllocationId" type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// [EC2-Classic] The Elastic IP address. Required for EC2-Classic.
+	PublicIP *string `locationName:"PublicIp" type:"string"`
+
+	metadataReleaseAddressInput `json:"-" xml:"-"`
+}
+
+type metadataReleaseAddressInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ReleaseAddressInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReleaseAddressInput) GoString() string {
+	return s.String()
+}
+
+type ReleaseAddressOutput struct {
+	metadataReleaseAddressOutput `json:"-" xml:"-"`
+}
+
+type metadataReleaseAddressOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ReleaseAddressOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReleaseAddressOutput) GoString() string {
+	return s.String()
+}
+
+type ReplaceNetworkACLAssociationInput struct {
+	// The ID of the current association between the original network ACL and the
+	// subnet.
+	AssociationID *string `locationName:"associationId" type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the new network ACL to associate with the subnet.
+	NetworkACLID *string `locationName:"networkAclId" type:"string" required:"true"`
+
+	metadataReplaceNetworkACLAssociationInput `json:"-" xml:"-"`
+}
+
+type metadataReplaceNetworkACLAssociationInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ReplaceNetworkACLAssociationInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReplaceNetworkACLAssociationInput) GoString() string {
+	return s.String()
+}
+
+type ReplaceNetworkACLAssociationOutput struct {
+	// The ID of the new association.
+	NewAssociationID *string `locationName:"newAssociationId" type:"string"`
+
+	metadataReplaceNetworkACLAssociationOutput `json:"-" xml:"-"`
+}
+
+type metadataReplaceNetworkACLAssociationOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ReplaceNetworkACLAssociationOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReplaceNetworkACLAssociationOutput) GoString() string {
+	return s.String()
+}
+
+type ReplaceNetworkACLEntryInput struct {
+	// The network range to allow or deny, in CIDR notation.
+	CIDRBlock *string `locationName:"cidrBlock" type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// Indicates whether to replace the egress rule.
+	//
+	// Default: If no value is specified, we replace the ingress rule.
+	Egress *bool `locationName:"egress" type:"boolean" required:"true"`
+
+	// ICMP protocol: The ICMP type and code. Required if specifying 1 (ICMP) for
+	// the protocol.
+	ICMPTypeCode *ICMPTypeCode `locationName:"Icmp" type:"structure"`
+
+	// The ID of the ACL.
+	NetworkACLID *string `locationName:"networkAclId" type:"string" required:"true"`
+
+	// TCP or UDP protocols: The range of ports the rule applies to. Required if
+	// specifying 6 (TCP) or 17 (UDP) for the protocol.
+	PortRange *PortRange `locationName:"portRange" type:"structure"`
+
+	// The IP protocol. You can specify all or -1 to mean all protocols.
+	Protocol *string `locationName:"protocol" type:"string" required:"true"`
+
+	// Indicates whether to allow or deny the traffic that matches the rule.
+	RuleAction *string `locationName:"ruleAction" type:"string" required:"true" enum:"RuleAction"`
+
+	// The rule number of the entry to replace.
+	RuleNumber *int64 `locationName:"ruleNumber" type:"integer" required:"true"`
+
+	metadataReplaceNetworkACLEntryInput `json:"-" xml:"-"`
+}
+
+type metadataReplaceNetworkACLEntryInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ReplaceNetworkACLEntryInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReplaceNetworkACLEntryInput) GoString() string {
+	return s.String()
+}
+
+type ReplaceNetworkACLEntryOutput struct {
+	metadataReplaceNetworkACLEntryOutput `json:"-" xml:"-"`
+}
+
+type metadataReplaceNetworkACLEntryOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ReplaceNetworkACLEntryOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReplaceNetworkACLEntryOutput) GoString() string {
+	return s.String()
+}
+
+type ReplaceRouteInput struct {
+	// The CIDR address block used for the destination match. The value you provide
+	// must match the CIDR of an existing route in the table.
+	DestinationCIDRBlock *string `locationName:"destinationCidrBlock" type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of an Internet gateway or virtual private gateway.
+	GatewayID *string `locationName:"gatewayId" type:"string"`
+
+	// The ID of a NAT instance in your VPC.
+	InstanceID *string `locationName:"instanceId" type:"string"`
+
+	// The ID of a network interface.
+	NetworkInterfaceID *string `locationName:"networkInterfaceId" type:"string"`
+
+	// The ID of the route table.
+	RouteTableID *string `locationName:"routeTableId" type:"string" required:"true"`
+
+	// The ID of a VPC peering connection.
+	VPCPeeringConnectionID *string `locationName:"vpcPeeringConnectionId" type:"string"`
+
+	metadataReplaceRouteInput `json:"-" xml:"-"`
+}
+
+type metadataReplaceRouteInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ReplaceRouteInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReplaceRouteInput) GoString() string {
+	return s.String()
+}
+
+type ReplaceRouteOutput struct {
+	metadataReplaceRouteOutput `json:"-" xml:"-"`
+}
+
+type metadataReplaceRouteOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ReplaceRouteOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReplaceRouteOutput) GoString() string {
+	return s.String()
+}
+
+type ReplaceRouteTableAssociationInput struct {
+	// The association ID.
+	AssociationID *string `locationName:"associationId" type:"string" required:"true"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the new route table to associate with the subnet.
+	RouteTableID *string `locationName:"routeTableId" type:"string" required:"true"`
+
+	metadataReplaceRouteTableAssociationInput `json:"-" xml:"-"`
+}
+
+type metadataReplaceRouteTableAssociationInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ReplaceRouteTableAssociationInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReplaceRouteTableAssociationInput) GoString() string {
+	return s.String()
+}
+
+type ReplaceRouteTableAssociationOutput struct {
+	// The ID of the new association.
+	NewAssociationID *string `locationName:"newAssociationId" type:"string"`
+
+	metadataReplaceRouteTableAssociationOutput `json:"-" xml:"-"`
+}
+
+type metadataReplaceRouteTableAssociationOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ReplaceRouteTableAssociationOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReplaceRouteTableAssociationOutput) GoString() string {
+	return s.String()
+}
+
+type ReportInstanceStatusInput struct {
+	// Descriptive text about the health state of your instance.
+	Description *string `locationName:"description" type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The time at which the reported instance health state ended.
+	EndTime *time.Time `locationName:"endTime" type:"timestamp" timestampFormat:"iso8601"`
+
+	// One or more instances.
+	Instances []*string `locationName:"instanceId" locationNameList:"InstanceId" type:"list" required:"true"`
+
+	// One or more reason codes that describes the health state of your instance.
+	//
+	//  instance-stuck-in-state: My instance is stuck in a state.
+	//
+	// unresponsive: My instance is unresponsive.
+	//
+	// not-accepting-credentials: My instance is not accepting my credentials.
+	//
+	// password-not-available: A password is not available for my instance.
+	//
+	// performance-network: My instance is experiencing performance problems which
+	// I believe are network related.
+	//
+	// performance-instance-store: My instance is experiencing performance problems
+	// which I believe are related to the instance stores.
+	//
+	// performance-ebs-volume: My instance is experiencing performance problems
+	// which I believe are related to an EBS volume.
+	//
+	// performance-other: My instance is experiencing performance problems.
+	//
+	// other: [explain using the description parameter]
+	ReasonCodes []*string `locationName:"reasonCode" locationNameList:"item" type:"list" required:"true"`
+
+	// The time at which the reported instance health state began.
+	StartTime *time.Time `locationName:"startTime" type:"timestamp" timestampFormat:"iso8601"`
+
+	// The status of all instances listed.
+	Status *string `locationName:"status" type:"string" required:"true" enum:"ReportStatusType"`
+
+	metadataReportInstanceStatusInput `json:"-" xml:"-"`
+}
+
+type metadataReportInstanceStatusInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ReportInstanceStatusInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReportInstanceStatusInput) GoString() string {
+	return s.String()
+}
+
+type ReportInstanceStatusOutput struct {
+	metadataReportInstanceStatusOutput `json:"-" xml:"-"`
+}
+
+type metadataReportInstanceStatusOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ReportInstanceStatusOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReportInstanceStatusOutput) GoString() string {
+	return s.String()
+}
+
+// Contains the parameters for RequestSpotFleet.
+type RequestSpotFleetInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The configuration for the Spot fleet request.
+	SpotFleetRequestConfig *SpotFleetRequestConfigData `locationName:"spotFleetRequestConfig" type:"structure" required:"true"`
+
+	metadataRequestSpotFleetInput `json:"-" xml:"-"`
+}
+
+type metadataRequestSpotFleetInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RequestSpotFleetInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RequestSpotFleetInput) GoString() string {
+	return s.String()
+}
+
+// Contains the output of RequestSpotFleet.
+type RequestSpotFleetOutput struct {
+	// The ID of the Spot fleet request.
+	SpotFleetRequestID *string `locationName:"spotFleetRequestId" type:"string" required:"true"`
+
+	metadataRequestSpotFleetOutput `json:"-" xml:"-"`
+}
+
+type metadataRequestSpotFleetOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RequestSpotFleetOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RequestSpotFleetOutput) GoString() string {
+	return s.String()
+}
+
+// Contains the parameters for RequestSpotInstances.
+type RequestSpotInstancesInput struct {
+	// The user-specified name for a logical grouping of bids.
+	//
+	// When you specify an Availability Zone group in a Spot Instance request,
+	// all Spot Instances in the request are launched in the same Availability Zone.
+	// Instance proximity is maintained with this parameter, but the choice of Availability
+	// Zone is not. The group applies only to bids for Spot Instances of the same
+	// instance type. Any additional Spot Instance requests that are specified with
+	// the same Availability Zone group name are launched in that same Availability
+	// Zone, as long as at least one instance from the group is still active.
+	//
+	// If there is no active instance running in the Availability Zone group that
+	// you specify for a new Spot Instance request (all instances are terminated,
+	// the bid is expired, or the bid falls below current market), then Amazon EC2
+	// launches the instance in any Availability Zone where the constraint can be
+	// met. Consequently, the subsequent set of Spot Instances could be placed in
+	// a different zone from the original request, even if you specified the same
+	// Availability Zone group.
+	//
+	// Default: Instances are launched in any available Availability Zone.
+	AvailabilityZoneGroup *string `locationName:"availabilityZoneGroup" type:"string"`
+
+	// Unique, case-sensitive identifier that you provide to ensure the idempotency
+	// of the request. For more information, see How to Ensure Idempotency (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Run_Instance_Idempotency.html)
+	// in the Amazon Elastic Compute Cloud User Guide.
+	ClientToken *string `locationName:"clientToken" type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The maximum number of Spot Instances to launch.
+	//
+	// Default: 1
+	InstanceCount *int64 `locationName:"instanceCount" type:"integer"`
+
+	// The instance launch group. Launch groups are Spot Instances that launch together
+	// and terminate together.
+	//
+	// Default: Instances are launched and terminated individually
+	LaunchGroup *string `locationName:"launchGroup" type:"string"`
+
+	// Describes the launch specification for an instance.
+	LaunchSpecification *RequestSpotLaunchSpecification `type:"structure"`
+
+	// The maximum hourly price (bid) for any Spot Instance launched to fulfill
+	// the request.
+	SpotPrice *string `locationName:"spotPrice" type:"string" required:"true"`
+
+	// The Spot Instance request type.
+	//
+	// Default: one-time
+	Type *string `locationName:"type" type:"string" enum:"SpotInstanceType"`
+
+	// The start date of the request. If this is a one-time request, the request
+	// becomes active at this date and time and remains active until all instances
+	// launch, the request expires, or the request is canceled. If the request is
+	// persistent, the request becomes active at this date and time and remains
+	// active until it expires or is canceled.
+	//
+	// Default: The request is effective indefinitely.
+	ValidFrom *time.Time `locationName:"validFrom" type:"timestamp" timestampFormat:"iso8601"`
+
+	// The end date of the request. If this is a one-time request, the request remains
+	// active until all instances launch, the request is canceled, or this date
+	// is reached. If the request is persistent, it remains active until it is canceled
+	// or this date and time is reached.
+	//
+	// Default: The request is effective indefinitely.
+	ValidUntil *time.Time `locationName:"validUntil" type:"timestamp" timestampFormat:"iso8601"`
+
+	metadataRequestSpotInstancesInput `json:"-" xml:"-"`
+}
+
+type metadataRequestSpotInstancesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RequestSpotInstancesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RequestSpotInstancesInput) GoString() string {
+	return s.String()
+}
+
+// Contains the output of RequestSpotInstances.
+type RequestSpotInstancesOutput struct {
+	// One or more Spot Instance requests.
+	SpotInstanceRequests []*SpotInstanceRequest `locationName:"spotInstanceRequestSet" locationNameList:"item" type:"list"`
+
+	metadataRequestSpotInstancesOutput `json:"-" xml:"-"`
+}
+
+type metadataRequestSpotInstancesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RequestSpotInstancesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RequestSpotInstancesOutput) GoString() string {
+	return s.String()
+}
+
+// Describes the launch specification for an instance.
+type RequestSpotLaunchSpecification struct {
+	// Deprecated.
+	AddressingType *string `locationName:"addressingType" type:"string"`
+
+	// One or more block device mapping entries.
+	BlockDeviceMappings []*BlockDeviceMapping `locationName:"blockDeviceMapping" locationNameList:"item" type:"list"`
+
+	// Indicates whether the instance is optimized for EBS I/O. This optimization
+	// provides dedicated throughput to Amazon EBS and an optimized configuration
+	// stack to provide optimal EBS I/O performance. This optimization isn't available
+	// with all instance types. Additional usage charges apply when using an EBS
+	// Optimized instance.
+	//
+	// Default: false
+	EBSOptimized *bool `locationName:"ebsOptimized" type:"boolean"`
+
+	// The IAM instance profile.
+	IAMInstanceProfile *IAMInstanceProfileSpecification `locationName:"iamInstanceProfile" type:"structure"`
+
+	// The ID of the AMI.
+	ImageID *string `locationName:"imageId" type:"string"`
+
+	// The instance type.
+	InstanceType *string `locationName:"instanceType" type:"string" enum:"InstanceType"`
+
+	// The ID of the kernel.
+	KernelID *string `locationName:"kernelId" type:"string"`
+
+	// The name of the key pair.
+	KeyName *string `locationName:"keyName" type:"string"`
+
+	// Describes the monitoring for the instance.
+	Monitoring *RunInstancesMonitoringEnabled `locationName:"monitoring" type:"structure"`
+
+	// One or more network interfaces.
+	NetworkInterfaces []*InstanceNetworkInterfaceSpecification `locationName:"NetworkInterface" locationNameList:"item" type:"list"`
+
+	// The placement information for the instance.
+	Placement *SpotPlacement `locationName:"placement" type:"structure"`
+
+	// The ID of the RAM disk.
+	RAMDiskID *string `locationName:"ramdiskId" type:"string"`
+
+	SecurityGroupIDs []*string `locationName:"SecurityGroupId" locationNameList:"item" type:"list"`
+
+	SecurityGroups []*string `locationName:"SecurityGroup" locationNameList:"item" type:"list"`
+
+	// The ID of the subnet in which to launch the instance.
+	SubnetID *string `locationName:"subnetId" type:"string"`
+
+	// The Base64-encoded MIME user data to make available to the instances.
+	UserData *string `locationName:"userData" type:"string"`
+
+	metadataRequestSpotLaunchSpecification `json:"-" xml:"-"`
+}
+
+type metadataRequestSpotLaunchSpecification struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RequestSpotLaunchSpecification) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RequestSpotLaunchSpecification) GoString() string {
+	return s.String()
+}
+
+// Describes a reservation.
+type Reservation struct {
+	// One or more security groups.
+	Groups []*GroupIdentifier `locationName:"groupSet" locationNameList:"item" type:"list"`
+
+	// One or more instances.
+	Instances []*Instance `locationName:"instancesSet" locationNameList:"item" type:"list"`
+
+	// The ID of the AWS account that owns the reservation.
+	OwnerID *string `locationName:"ownerId" type:"string"`
+
+	// The ID of the requester that launched the instances on your behalf (for example,
+	// AWS Management Console or Auto Scaling).
+	RequesterID *string `locationName:"requesterId" type:"string"`
+
+	// The ID of the reservation.
+	ReservationID *string `locationName:"reservationId" type:"string"`
+
+	metadataReservation `json:"-" xml:"-"`
+}
+
+type metadataReservation struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s Reservation) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Reservation) GoString() string {
+	return s.String()
+}
+
+// Describes the limit price of a Reserved Instance offering.
+type ReservedInstanceLimitPrice struct {
+	// Used for Reserved Instance Marketplace offerings. Specifies the limit price
+	// on the total order (instanceCount * price).
+	Amount *float64 `locationName:"amount" type:"double"`
+
+	// The currency in which the limitPrice amount is specified. At this time, the
+	// only supported currency is USD.
+	CurrencyCode *string `locationName:"currencyCode" type:"string" enum:"CurrencyCodeValues"`
+
+	metadataReservedInstanceLimitPrice `json:"-" xml:"-"`
+}
+
+type metadataReservedInstanceLimitPrice struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ReservedInstanceLimitPrice) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReservedInstanceLimitPrice) GoString() string {
+	return s.String()
+}
+
+// Describes a Reserved Instance.
+type ReservedInstances struct {
+	// The Availability Zone in which the Reserved Instance can be used.
+	AvailabilityZone *string `locationName:"availabilityZone" type:"string"`
+
+	// The currency of the Reserved Instance. It's specified using ISO 4217 standard
+	// currency codes. At this time, the only supported currency is USD.
+	CurrencyCode *string `locationName:"currencyCode" type:"string" enum:"CurrencyCodeValues"`
+
+	// The duration of the Reserved Instance, in seconds.
+	Duration *int64 `locationName:"duration" type:"long"`
+
+	// The time when the Reserved Instance expires.
+	End *time.Time `locationName:"end" type:"timestamp" timestampFormat:"iso8601"`
+
+	// The purchase price of the Reserved Instance.
+	FixedPrice *float64 `locationName:"fixedPrice" type:"float"`
+
+	// The number of Reserved Instances purchased.
+	InstanceCount *int64 `locationName:"instanceCount" type:"integer"`
+
+	// The tenancy of the reserved instance.
+	InstanceTenancy *string `locationName:"instanceTenancy" type:"string" enum:"Tenancy"`
+
+	// The instance type on which the Reserved Instance can be used.
+	InstanceType *string `locationName:"instanceType" type:"string" enum:"InstanceType"`
+
+	// The Reserved Instance offering type.
+	OfferingType *string `locationName:"offeringType" type:"string" enum:"OfferingTypeValues"`
+
+	// The Reserved Instance product platform description.
+	ProductDescription *string `locationName:"productDescription" type:"string" enum:"RIProductDescription"`
+
+	// The recurring charge tag assigned to the resource.
+	RecurringCharges []*RecurringCharge `locationName:"recurringCharges" locationNameList:"item" type:"list"`
+
+	// The ID of the Reserved Instance.
+	ReservedInstancesID *string `locationName:"reservedInstancesId" type:"string"`
+
+	// The date and time the Reserved Instance started.
+	Start *time.Time `locationName:"start" type:"timestamp" timestampFormat:"iso8601"`
+
+	// The state of the Reserved Instance purchase.
+	State *string `locationName:"state" type:"string" enum:"ReservedInstanceState"`
+
+	// Any tags assigned to the resource.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	// The usage price of the Reserved Instance, per hour.
+	UsagePrice *float64 `locationName:"usagePrice" type:"float"`
+
+	metadataReservedInstances `json:"-" xml:"-"`
+}
+
+type metadataReservedInstances struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ReservedInstances) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReservedInstances) GoString() string {
+	return s.String()
+}
+
+// Describes the configuration settings for the modified Reserved Instances.
+type ReservedInstancesConfiguration struct {
+	// The Availability Zone for the modified Reserved Instances.
+	AvailabilityZone *string `locationName:"availabilityZone" type:"string"`
+
+	// The number of modified Reserved Instances.
+	InstanceCount *int64 `locationName:"instanceCount" type:"integer"`
+
+	// The instance type for the modified Reserved Instances.
+	InstanceType *string `locationName:"instanceType" type:"string" enum:"InstanceType"`
+
+	// The network platform of the modified Reserved Instances, which is either
+	// EC2-Classic or EC2-VPC.
+	Platform *string `locationName:"platform" type:"string"`
+
+	metadataReservedInstancesConfiguration `json:"-" xml:"-"`
+}
+
+type metadataReservedInstancesConfiguration struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ReservedInstancesConfiguration) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReservedInstancesConfiguration) GoString() string {
+	return s.String()
+}
+
+// Describes the ID of a Reserved Instance.
+type ReservedInstancesID struct {
+	// The ID of the Reserved Instance.
+	ReservedInstancesID *string `locationName:"reservedInstancesId" type:"string"`
+
+	metadataReservedInstancesID `json:"-" xml:"-"`
+}
+
+type metadataReservedInstancesID struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ReservedInstancesID) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReservedInstancesID) GoString() string {
+	return s.String()
+}
+
+// Describes a Reserved Instance listing.
+type ReservedInstancesListing struct {
+	// A unique, case-sensitive key supplied by the client to ensure that the request
+	// is idempotent. For more information, see Ensuring Idempotency (http://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html).
+	ClientToken *string `locationName:"clientToken" type:"string"`
+
+	// The time the listing was created.
+	CreateDate *time.Time `locationName:"createDate" type:"timestamp" timestampFormat:"iso8601"`
+
+	// The number of instances in this state.
+	InstanceCounts []*InstanceCount `locationName:"instanceCounts" locationNameList:"item" type:"list"`
+
+	// The price of the Reserved Instance listing.
+	PriceSchedules []*PriceSchedule `locationName:"priceSchedules" locationNameList:"item" type:"list"`
+
+	// The ID of the Reserved Instance.
+	ReservedInstancesID *string `locationName:"reservedInstancesId" type:"string"`
+
+	// The ID of the Reserved Instance listing.
+	ReservedInstancesListingID *string `locationName:"reservedInstancesListingId" type:"string"`
+
+	// The status of the Reserved Instance listing.
+	Status *string `locationName:"status" type:"string" enum:"ListingStatus"`
+
+	// The reason for the current status of the Reserved Instance listing. The response
+	// can be blank.
+	StatusMessage *string `locationName:"statusMessage" type:"string"`
+
+	// Any tags assigned to the resource.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	// The last modified timestamp of the listing.
+	UpdateDate *time.Time `locationName:"updateDate" type:"timestamp" timestampFormat:"iso8601"`
+
+	metadataReservedInstancesListing `json:"-" xml:"-"`
+}
+
+type metadataReservedInstancesListing struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ReservedInstancesListing) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReservedInstancesListing) GoString() string {
+	return s.String()
+}
+
+// Describes a Reserved Instance modification.
+type ReservedInstancesModification struct {
+	// A unique, case-sensitive key supplied by the client to ensure that the request
+	// is idempotent. For more information, see Ensuring Idempotency (http://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html).
+	ClientToken *string `locationName:"clientToken" type:"string"`
+
+	// The time when the modification request was created.
+	CreateDate *time.Time `locationName:"createDate" type:"timestamp" timestampFormat:"iso8601"`
+
+	// The time for the modification to become effective.
+	EffectiveDate *time.Time `locationName:"effectiveDate" type:"timestamp" timestampFormat:"iso8601"`
+
+	// Contains target configurations along with their corresponding new Reserved
+	// Instance IDs.
+	ModificationResults []*ReservedInstancesModificationResult `locationName:"modificationResultSet" locationNameList:"item" type:"list"`
+
+	// The IDs of one or more Reserved Instances.
+	ReservedInstancesIDs []*ReservedInstancesID `locationName:"reservedInstancesSet" locationNameList:"item" type:"list"`
+
+	// A unique ID for the Reserved Instance modification.
+	ReservedInstancesModificationID *string `locationName:"reservedInstancesModificationId" type:"string"`
+
+	// The status of the Reserved Instances modification request.
+	Status *string `locationName:"status" type:"string"`
+
+	// The reason for the status.
+	StatusMessage *string `locationName:"statusMessage" type:"string"`
+
+	// The time when the modification request was last updated.
+	UpdateDate *time.Time `locationName:"updateDate" type:"timestamp" timestampFormat:"iso8601"`
+
+	metadataReservedInstancesModification `json:"-" xml:"-"`
+}
+
+type metadataReservedInstancesModification struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ReservedInstancesModification) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReservedInstancesModification) GoString() string {
+	return s.String()
+}
+
+type ReservedInstancesModificationResult struct {
+	// The ID for the Reserved Instances that were created as part of the modification
+	// request. This field is only available when the modification is fulfilled.
+	ReservedInstancesID *string `locationName:"reservedInstancesId" type:"string"`
+
+	// The target Reserved Instances configurations supplied as part of the modification
+	// request.
+	TargetConfiguration *ReservedInstancesConfiguration `locationName:"targetConfiguration" type:"structure"`
+
+	metadataReservedInstancesModificationResult `json:"-" xml:"-"`
+}
+
+type metadataReservedInstancesModificationResult struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ReservedInstancesModificationResult) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReservedInstancesModificationResult) GoString() string {
+	return s.String()
+}
+
+// Describes a Reserved Instance offering.
+type ReservedInstancesOffering struct {
+	// The Availability Zone in which the Reserved Instance can be used.
+	AvailabilityZone *string `locationName:"availabilityZone" type:"string"`
+
+	// The currency of the Reserved Instance offering you are purchasing. It's specified
+	// using ISO 4217 standard currency codes. At this time, the only supported
+	// currency is USD.
+	CurrencyCode *string `locationName:"currencyCode" type:"string" enum:"CurrencyCodeValues"`
+
+	// The duration of the Reserved Instance, in seconds.
+	Duration *int64 `locationName:"duration" type:"long"`
+
+	// The purchase price of the Reserved Instance.
+	FixedPrice *float64 `locationName:"fixedPrice" type:"float"`
+
+	// The tenancy of the reserved instance.
+	InstanceTenancy *string `locationName:"instanceTenancy" type:"string" enum:"Tenancy"`
+
+	// The instance type on which the Reserved Instance can be used.
+	InstanceType *string `locationName:"instanceType" type:"string" enum:"InstanceType"`
+
+	// Indicates whether the offering is available through the Reserved Instance
+	// Marketplace (resale) or AWS. If it's a Reserved Instance Marketplace offering,
+	// this is true.
+	Marketplace *bool `locationName:"marketplace" type:"boolean"`
+
+	// The Reserved Instance offering type.
+	OfferingType *string `locationName:"offeringType" type:"string" enum:"OfferingTypeValues"`
+
+	// The pricing details of the Reserved Instance offering.
+	PricingDetails []*PricingDetail `locationName:"pricingDetailsSet" locationNameList:"item" type:"list"`
+
+	// The Reserved Instance product platform description.
+	ProductDescription *string `locationName:"productDescription" type:"string" enum:"RIProductDescription"`
+
+	// The recurring charge tag assigned to the resource.
+	RecurringCharges []*RecurringCharge `locationName:"recurringCharges" locationNameList:"item" type:"list"`
+
+	// The ID of the Reserved Instance offering.
+	ReservedInstancesOfferingID *string `locationName:"reservedInstancesOfferingId" type:"string"`
+
+	// The usage price of the Reserved Instance, per hour.
+	UsagePrice *float64 `locationName:"usagePrice" type:"float"`
+
+	metadataReservedInstancesOffering `json:"-" xml:"-"`
+}
+
+type metadataReservedInstancesOffering struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ReservedInstancesOffering) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReservedInstancesOffering) GoString() string {
+	return s.String()
+}
+
+type ResetImageAttributeInput struct {
+	// The attribute to reset (currently you can only reset the launch permission
+	// attribute).
+	Attribute *string `type:"string" required:"true" enum:"ResetImageAttributeName"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the AMI.
+	ImageID *string `locationName:"ImageId" type:"string" required:"true"`
+
+	metadataResetImageAttributeInput `json:"-" xml:"-"`
+}
+
+type metadataResetImageAttributeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ResetImageAttributeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ResetImageAttributeInput) GoString() string {
+	return s.String()
+}
+
+type ResetImageAttributeOutput struct {
+	metadataResetImageAttributeOutput `json:"-" xml:"-"`
+}
+
+type metadataResetImageAttributeOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ResetImageAttributeOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ResetImageAttributeOutput) GoString() string {
+	return s.String()
+}
+
+type ResetInstanceAttributeInput struct {
+	// The attribute to reset.
+	Attribute *string `locationName:"attribute" type:"string" required:"true" enum:"InstanceAttributeName"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the instance.
+	InstanceID *string `locationName:"instanceId" type:"string" required:"true"`
+
+	metadataResetInstanceAttributeInput `json:"-" xml:"-"`
+}
+
+type metadataResetInstanceAttributeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ResetInstanceAttributeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ResetInstanceAttributeInput) GoString() string {
+	return s.String()
+}
+
+type ResetInstanceAttributeOutput struct {
+	metadataResetInstanceAttributeOutput `json:"-" xml:"-"`
+}
+
+type metadataResetInstanceAttributeOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ResetInstanceAttributeOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ResetInstanceAttributeOutput) GoString() string {
+	return s.String()
+}
+
+type ResetNetworkInterfaceAttributeInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the network interface.
+	NetworkInterfaceID *string `locationName:"networkInterfaceId" type:"string" required:"true"`
+
+	// The source/destination checking attribute. Resets the value to true.
+	SourceDestCheck *string `locationName:"sourceDestCheck" type:"string"`
+
+	metadataResetNetworkInterfaceAttributeInput `json:"-" xml:"-"`
+}
+
+type metadataResetNetworkInterfaceAttributeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ResetNetworkInterfaceAttributeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ResetNetworkInterfaceAttributeInput) GoString() string {
+	return s.String()
+}
+
+type ResetNetworkInterfaceAttributeOutput struct {
+	metadataResetNetworkInterfaceAttributeOutput `json:"-" xml:"-"`
+}
+
+type metadataResetNetworkInterfaceAttributeOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ResetNetworkInterfaceAttributeOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ResetNetworkInterfaceAttributeOutput) GoString() string {
+	return s.String()
+}
+
+type ResetSnapshotAttributeInput struct {
+	// The attribute to reset. Currently, only the attribute for permission to create
+	// volumes can be reset.
+	Attribute *string `type:"string" required:"true" enum:"SnapshotAttributeName"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The ID of the snapshot.
+	SnapshotID *string `locationName:"SnapshotId" type:"string" required:"true"`
+
+	metadataResetSnapshotAttributeInput `json:"-" xml:"-"`
+}
+
+type metadataResetSnapshotAttributeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ResetSnapshotAttributeInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ResetSnapshotAttributeInput) GoString() string {
+	return s.String()
+}
+
+type ResetSnapshotAttributeOutput struct {
+	metadataResetSnapshotAttributeOutput `json:"-" xml:"-"`
+}
+
+type metadataResetSnapshotAttributeOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s ResetSnapshotAttributeOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ResetSnapshotAttributeOutput) GoString() string {
+	return s.String()
+}
+
+type RestoreAddressToClassicInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The Elastic IP address.
+	PublicIP *string `locationName:"publicIp" type:"string" required:"true"`
+
+	metadataRestoreAddressToClassicInput `json:"-" xml:"-"`
+}
+
+type metadataRestoreAddressToClassicInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RestoreAddressToClassicInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RestoreAddressToClassicInput) GoString() string {
+	return s.String()
+}
+
+type RestoreAddressToClassicOutput struct {
+	// The Elastic IP address.
+	PublicIP *string `locationName:"publicIp" type:"string"`
+
+	// The move status for the IP address.
+	Status *string `locationName:"status" type:"string" enum:"Status"`
+
+	metadataRestoreAddressToClassicOutput `json:"-" xml:"-"`
+}
+
+type metadataRestoreAddressToClassicOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RestoreAddressToClassicOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RestoreAddressToClassicOutput) GoString() string {
+	return s.String()
+}
+
+type RevokeSecurityGroupEgressInput struct {
+	// The CIDR IP address range. You can't specify this parameter when specifying
+	// a source security group.
+	CIDRIP *string `locationName:"cidrIp" type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The start of port range for the TCP and UDP protocols, or an ICMP type number.
+	// For the ICMP type number, use -1 to specify all ICMP types.
+	FromPort *int64 `locationName:"fromPort" type:"integer"`
+
+	// The ID of the security group.
+	GroupID *string `locationName:"groupId" type:"string" required:"true"`
+
+	// A set of IP permissions. You can't specify a destination security group and
+	// a CIDR IP address range.
+	IPPermissions []*IPPermission `locationName:"ipPermissions" locationNameList:"item" type:"list"`
+
+	// The IP protocol name (tcp, udp, icmp) or number (see Protocol Numbers (http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml)).
+	// Use -1 to specify all.
+	IPProtocol *string `locationName:"ipProtocol" type:"string"`
+
+	// The name of a destination security group. To revoke outbound access to a
+	// destination security group, we recommend that you use a set of IP permissions
+	// instead.
+	SourceSecurityGroupName *string `locationName:"sourceSecurityGroupName" type:"string"`
+
+	// The AWS account number for a destination security group. To revoke outbound
+	// access to a destination security group, we recommend that you use a set of
+	// IP permissions instead.
+	SourceSecurityGroupOwnerID *string `locationName:"sourceSecurityGroupOwnerId" type:"string"`
+
+	// The end of port range for the TCP and UDP protocols, or an ICMP code number.
+	// For the ICMP code number, use -1 to specify all ICMP codes for the ICMP type.
+	ToPort *int64 `locationName:"toPort" type:"integer"`
+
+	metadataRevokeSecurityGroupEgressInput `json:"-" xml:"-"`
+}
+
+type metadataRevokeSecurityGroupEgressInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RevokeSecurityGroupEgressInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RevokeSecurityGroupEgressInput) GoString() string {
+	return s.String()
+}
+
+type RevokeSecurityGroupEgressOutput struct {
+	metadataRevokeSecurityGroupEgressOutput `json:"-" xml:"-"`
+}
+
+type metadataRevokeSecurityGroupEgressOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RevokeSecurityGroupEgressOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RevokeSecurityGroupEgressOutput) GoString() string {
+	return s.String()
+}
+
+type RevokeSecurityGroupIngressInput struct {
+	// The CIDR IP address range. You can't specify this parameter when specifying
+	// a source security group.
+	CIDRIP *string `locationName:"CidrIp" type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// The start of port range for the TCP and UDP protocols, or an ICMP type number.
+	// For the ICMP type number, use -1 to specify all ICMP types.
+	FromPort *int64 `type:"integer"`
+
+	// The ID of the security group. Required for a security group in a nondefault
+	// VPC.
+	GroupID *string `locationName:"GroupId" type:"string"`
+
+	// [EC2-Classic, default VPC] The name of the security group.
+	GroupName *string `type:"string"`
+
+	// A set of IP permissions. You can't specify a source security group and a
+	// CIDR IP address range.
+	IPPermissions []*IPPermission `locationName:"IpPermissions" locationNameList:"item" type:"list"`
+
+	// The IP protocol name (tcp, udp, icmp) or number (see Protocol Numbers (http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml)).
+	// Use -1 to specify all.
+	IPProtocol *string `locationName:"IpProtocol" type:"string"`
+
+	// [EC2-Classic, default VPC] The name of the source security group. You can't
+	// specify this parameter in combination with the following parameters: the
+	// CIDR IP address range, the start of the port range, the IP protocol, and
+	// the end of the port range. For EC2-VPC, the source security group must be
+	// in the same VPC.
+	SourceSecurityGroupName *string `type:"string"`
+
+	// [EC2-Classic, default VPC] The AWS account ID of the source security group.
+	// For EC2-VPC, the source security group must be in the same VPC. You can't
+	// specify this parameter in combination with the following parameters: the
+	// CIDR IP address range, the IP protocol, the start of the port range, and
+	// the end of the port range. To revoke a specific rule for an IP protocol and
+	// port range, use a set of IP permissions instead.
+	SourceSecurityGroupOwnerID *string `locationName:"SourceSecurityGroupOwnerId" type:"string"`
+
+	// The end of port range for the TCP and UDP protocols, or an ICMP code number.
+	// For the ICMP code number, use -1 to specify all ICMP codes for the ICMP type.
+	ToPort *int64 `type:"integer"`
+
+	metadataRevokeSecurityGroupIngressInput `json:"-" xml:"-"`
+}
+
+type metadataRevokeSecurityGroupIngressInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RevokeSecurityGroupIngressInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RevokeSecurityGroupIngressInput) GoString() string {
+	return s.String()
+}
+
+type RevokeSecurityGroupIngressOutput struct {
+	metadataRevokeSecurityGroupIngressOutput `json:"-" xml:"-"`
+}
+
+type metadataRevokeSecurityGroupIngressOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RevokeSecurityGroupIngressOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RevokeSecurityGroupIngressOutput) GoString() string {
+	return s.String()
+}
+
+// Describes a route in a route table.
+type Route struct {
+	// The CIDR block used for the destination match.
+	DestinationCIDRBlock *string `locationName:"destinationCidrBlock" type:"string"`
+
+	// The prefix of the AWS service.
+	DestinationPrefixListID *string `locationName:"destinationPrefixListId" type:"string"`
+
+	// The ID of a gateway attached to your VPC.
+	GatewayID *string `locationName:"gatewayId" type:"string"`
+
+	// The ID of a NAT instance in your VPC.
+	InstanceID *string `locationName:"instanceId" type:"string"`
+
+	// The AWS account ID of the owner of the instance.
+	InstanceOwnerID *string `locationName:"instanceOwnerId" type:"string"`
+
+	// The ID of the network interface.
+	NetworkInterfaceID *string `locationName:"networkInterfaceId" type:"string"`
+
+	// Describes how the route was created.
+	//
+	//   CreateRouteTable indicates that route was automatically created when the
+	// route table was created.  CreateRoute indicates that the route was manually
+	// added to the route table.  EnableVgwRoutePropagation indicates that the route
+	// was propagated by route propagation.
+	Origin *string `locationName:"origin" type:"string" enum:"RouteOrigin"`
+
+	// The state of the route. The blackhole state indicates that the route's target
+	// isn't available (for example, the specified gateway isn't attached to the
+	// VPC, or the specified NAT instance has been terminated).
+	State *string `locationName:"state" type:"string" enum:"RouteState"`
+
+	// The ID of the VPC peering connection.
+	VPCPeeringConnectionID *string `locationName:"vpcPeeringConnectionId" type:"string"`
+
+	metadataRoute `json:"-" xml:"-"`
+}
+
+type metadataRoute struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s Route) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Route) GoString() string {
+	return s.String()
+}
+
+// Describes a route table.
+type RouteTable struct {
+	// The associations between the route table and one or more subnets.
+	Associations []*RouteTableAssociation `locationName:"associationSet" locationNameList:"item" type:"list"`
+
+	// Any virtual private gateway (VGW) propagating routes.
+	PropagatingVGWs []*PropagatingVGW `locationName:"propagatingVgwSet" locationNameList:"item" type:"list"`
+
+	// The ID of the route table.
+	RouteTableID *string `locationName:"routeTableId" type:"string"`
+
+	// The routes in the route table.
+	Routes []*Route `locationName:"routeSet" locationNameList:"item" type:"list"`
+
+	// Any tags assigned to the route table.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"vpcId" type:"string"`
+
+	metadataRouteTable `json:"-" xml:"-"`
+}
+
+type metadataRouteTable struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RouteTable) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RouteTable) GoString() string {
+	return s.String()
+}
+
+// Describes an association between a route table and a subnet.
+type RouteTableAssociation struct {
+	// Indicates whether this is the main route table.
+	Main *bool `locationName:"main" type:"boolean"`
+
+	// The ID of the association between a route table and a subnet.
+	RouteTableAssociationID *string `locationName:"routeTableAssociationId" type:"string"`
+
+	// The ID of the route table.
+	RouteTableID *string `locationName:"routeTableId" type:"string"`
+
+	// The ID of the subnet. A subnet ID is not returned for an implicit association.
+	SubnetID *string `locationName:"subnetId" type:"string"`
+
+	metadataRouteTableAssociation `json:"-" xml:"-"`
+}
+
+type metadataRouteTableAssociation struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RouteTableAssociation) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RouteTableAssociation) GoString() string {
+	return s.String()
+}
+
+type RunInstancesInput struct {
+	// Reserved.
+	AdditionalInfo *string `locationName:"additionalInfo" type:"string"`
+
+	// The block device mapping.
+	BlockDeviceMappings []*BlockDeviceMapping `locationName:"BlockDeviceMapping" locationNameList:"BlockDeviceMapping" type:"list"`
+
+	// Unique, case-sensitive identifier you provide to ensure the idempotency of
+	// the request. For more information, see Ensuring Idempotency (http://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html).
+	//
+	// Constraints: Maximum 64 ASCII characters
+	ClientToken *string `locationName:"clientToken" type:"string"`
+
+	// If you set this parameter to true, you can't terminate the instance using
+	// the Amazon EC2 console, CLI, or API; otherwise, you can. If you set this
+	// parameter to true and then later want to be able to terminate the instance,
+	// you must first change the value of the disableApiTermination attribute to
+	// false using ModifyInstanceAttribute. Alternatively, if you set InstanceInitiatedShutdownBehavior
+	// to terminate, you can terminate the instance by running the shutdown command
+	// from the instance.
+	//
+	// Default: false
+	DisableAPITermination *bool `locationName:"disableApiTermination" type:"boolean"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// Indicates whether the instance is optimized for EBS I/O. This optimization
+	// provides dedicated throughput to Amazon EBS and an optimized configuration
+	// stack to provide optimal EBS I/O performance. This optimization isn't available
+	// with all instance types. Additional usage charges apply when using an EBS-optimized
+	// instance.
+	//
+	// Default: false
+	EBSOptimized *bool `locationName:"ebsOptimized" type:"boolean"`
+
+	// The IAM instance profile.
+	IAMInstanceProfile *IAMInstanceProfileSpecification `locationName:"iamInstanceProfile" type:"structure"`
+
+	// The ID of the AMI, which you can get by calling DescribeImages.
+	ImageID *string `locationName:"ImageId" type:"string" required:"true"`
+
+	// Indicates whether an instance stops or terminates when you initiate shutdown
+	// from the instance (using the operating system command for system shutdown).
+	//
+	// Default: stop
+	InstanceInitiatedShutdownBehavior *string `locationName:"instanceInitiatedShutdownBehavior" type:"string" enum:"ShutdownBehavior"`
+
+	// The instance type. For more information, see Instance Types (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html)
+	// in the Amazon Elastic Compute Cloud User Guide.
+	//
+	// Default: m1.small
+	InstanceType *string `type:"string" enum:"InstanceType"`
+
+	// The ID of the kernel.
+	//
+	//  We recommend that you use PV-GRUB instead of kernels and RAM disks. For
+	// more information, see  PV-GRUB (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UserProvidedkernels.html)
+	// in the Amazon Elastic Compute Cloud User Guide.
+	KernelID *string `locationName:"KernelId" type:"string"`
+
+	// The name of the key pair. You can create a key pair using CreateKeyPair or
+	// ImportKeyPair.
+	//
+	//  If you do not specify a key pair, you can't connect to the instance unless
+	// you choose an AMI that is configured to allow users another way to log in.
+	KeyName *string `type:"string"`
+
+	// The maximum number of instances to launch. If you specify more instances
+	// than Amazon EC2 can launch in the target Availability Zone, Amazon EC2 launches
+	// the largest possible number of instances above MinCount.
+	//
+	// Constraints: Between 1 and the maximum number you're allowed for the specified
+	// instance type. For more information about the default limits, and how to
+	// request an increase, see How many instances can I run in Amazon EC2 (http://aws.amazon.com/ec2/faqs/#How_many_instances_can_I_run_in_Amazon_EC2)
+	// in the Amazon EC2 General FAQ.
+	MaxCount *int64 `type:"integer" required:"true"`
+
+	// The minimum number of instances to launch. If you specify a minimum that
+	// is more instances than Amazon EC2 can launch in the target Availability Zone,
+	// Amazon EC2 launches no instances.
+	//
+	// Constraints: Between 1 and the maximum number you're allowed for the specified
+	// instance type. For more information about the default limits, and how to
+	// request an increase, see How many instances can I run in Amazon EC2 (http://aws.amazon.com/ec2/faqs/#How_many_instances_can_I_run_in_Amazon_EC2)
+	// in the Amazon EC2 General FAQ.
+	MinCount *int64 `type:"integer" required:"true"`
+
+	// The monitoring for the instance.
+	Monitoring *RunInstancesMonitoringEnabled `type:"structure"`
+
+	// One or more network interfaces.
+	NetworkInterfaces []*InstanceNetworkInterfaceSpecification `locationName:"networkInterface" locationNameList:"item" type:"list"`
+
+	// The placement for the instance.
+	Placement *Placement `type:"structure"`
+
+	// [EC2-VPC] The primary IP address. You must specify a value from the IP address
+	// range of the subnet.
+	//
+	// Only one private IP address can be designated as primary. Therefore, you
+	// can't specify this parameter if PrivateIpAddresses.n.Primary is set to true
+	// and PrivateIpAddresses.n.PrivateIpAddress is set to an IP address.
+	//
+	// Default: We select an IP address from the IP address range of the subnet.
+	PrivateIPAddress *string `locationName:"privateIpAddress" type:"string"`
+
+	// The ID of the RAM disk.
+	//
+	//  We recommend that you use PV-GRUB instead of kernels and RAM disks. For
+	// more information, see  PV-GRUB (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UserProvidedkernels.html)
+	// in the Amazon Elastic Compute Cloud User Guide.
+	RAMDiskID *string `locationName:"RamdiskId" type:"string"`
+
+	// One or more security group IDs. You can create a security group using CreateSecurityGroup.
+	//
+	// Default: Amazon EC2 uses the default security group.
+	SecurityGroupIDs []*string `locationName:"SecurityGroupId" locationNameList:"SecurityGroupId" type:"list"`
+
+	// [EC2-Classic, default VPC] One or more security group names. For a nondefault
+	// VPC, you must use security group IDs instead.
+	//
+	// Default: Amazon EC2 uses the default security group.
+	SecurityGroups []*string `locationName:"SecurityGroup" locationNameList:"SecurityGroup" type:"list"`
+
+	// [EC2-VPC] The ID of the subnet to launch the instance into.
+	SubnetID *string `locationName:"SubnetId" type:"string"`
+
+	// The Base64-encoded MIME user data for the instances.
+	UserData *string `type:"string"`
+
+	metadataRunInstancesInput `json:"-" xml:"-"`
+}
+
+type metadataRunInstancesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RunInstancesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RunInstancesInput) GoString() string {
+	return s.String()
+}
+
+// Describes the monitoring for the instance.
+type RunInstancesMonitoringEnabled struct {
+	// Indicates whether monitoring is enabled for the instance.
+	Enabled *bool `locationName:"enabled" type:"boolean" required:"true"`
+
+	metadataRunInstancesMonitoringEnabled `json:"-" xml:"-"`
+}
+
+type metadataRunInstancesMonitoringEnabled struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s RunInstancesMonitoringEnabled) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RunInstancesMonitoringEnabled) GoString() string {
+	return s.String()
+}
+
+// Describes the storage parameters for S3 and S3 buckets for an instance store-backed
+// AMI.
+type S3Storage struct {
+	// The access key ID of the owner of the bucket. Before you specify a value
+	// for your access key ID, review and follow the guidance in Best Practices
+	// for Managing AWS Access Keys (http://docs.aws.amazon.com/general/latest/gr/aws-access-keys-best-practices.html).
+	AWSAccessKeyID *string `locationName:"AWSAccessKeyId" type:"string"`
+
+	// The bucket in which to store the AMI. You can specify a bucket that you already
+	// own or a new bucket that Amazon EC2 creates on your behalf. If you specify
+	// a bucket that belongs to someone else, Amazon EC2 returns an error.
+	Bucket *string `locationName:"bucket" type:"string"`
+
+	// The beginning of the file name of the AMI.
+	Prefix *string `locationName:"prefix" type:"string"`
+
+	// A Base64-encoded Amazon S3 upload policy that gives Amazon EC2 permission
+	// to upload items into Amazon S3 on your behalf.
+	UploadPolicy []byte `locationName:"uploadPolicy" type:"blob"`
+
+	// The signature of the Base64 encoded JSON document.
+	UploadPolicySignature *string `locationName:"uploadPolicySignature" type:"string"`
+
+	metadataS3Storage `json:"-" xml:"-"`
+}
+
+type metadataS3Storage struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s S3Storage) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s S3Storage) GoString() string {
+	return s.String()
+}
+
+// Describes a security group
+type SecurityGroup struct {
+	// A description of the security group.
+	Description *string `locationName:"groupDescription" type:"string"`
+
+	// The ID of the security group.
+	GroupID *string `locationName:"groupId" type:"string"`
+
+	// The name of the security group.
+	GroupName *string `locationName:"groupName" type:"string"`
+
+	// One or more inbound rules associated with the security group.
+	IPPermissions []*IPPermission `locationName:"ipPermissions" locationNameList:"item" type:"list"`
+
+	// [EC2-VPC] One or more outbound rules associated with the security group.
+	IPPermissionsEgress []*IPPermission `locationName:"ipPermissionsEgress" locationNameList:"item" type:"list"`
+
+	// The AWS account ID of the owner of the security group.
+	OwnerID *string `locationName:"ownerId" type:"string"`
+
+	// Any tags assigned to the security group.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	// [EC2-VPC] The ID of the VPC for the security group.
+	VPCID *string `locationName:"vpcId" type:"string"`
+
+	metadataSecurityGroup `json:"-" xml:"-"`
+}
+
+type metadataSecurityGroup struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s SecurityGroup) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SecurityGroup) GoString() string {
+	return s.String()
+}
+
+// Describes a snapshot.
+type Snapshot struct {
+	// The description for the snapshot.
+	Description *string `locationName:"description" type:"string"`
+
+	// Indicates whether the snapshot is encrypted.
+	Encrypted *bool `locationName:"encrypted" type:"boolean"`
+
+	// The full ARN of the AWS Key Management Service (AWS KMS) customer master
+	// key (CMK) that was used to protect the volume encryption key for the parent
+	// volume.
+	KMSKeyID *string `locationName:"kmsKeyId" type:"string"`
+
+	// The AWS account alias (for example, amazon, self) or AWS account ID that
+	// owns the snapshot.
+	OwnerAlias *string `locationName:"ownerAlias" type:"string"`
+
+	// The AWS account ID of the EBS snapshot owner.
+	OwnerID *string `locationName:"ownerId" type:"string"`
+
+	// The progress of the snapshot, as a percentage.
+	Progress *string `locationName:"progress" type:"string"`
+
+	// The ID of the snapshot.
+	SnapshotID *string `locationName:"snapshotId" type:"string"`
+
+	// The time stamp when the snapshot was initiated.
+	StartTime *time.Time `locationName:"startTime" type:"timestamp" timestampFormat:"iso8601"`
+
+	// The snapshot state.
+	State *string `locationName:"status" type:"string" enum:"SnapshotState"`
+
+	// Any tags assigned to the snapshot.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	// The ID of the volume.
+	VolumeID *string `locationName:"volumeId" type:"string"`
+
+	// The size of the volume, in GiB.
+	VolumeSize *int64 `locationName:"volumeSize" type:"integer"`
+
+	metadataSnapshot `json:"-" xml:"-"`
+}
+
+type metadataSnapshot struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s Snapshot) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Snapshot) GoString() string {
+	return s.String()
+}
+
+// Describes the snapshot created from the imported disk.
+type SnapshotDetail struct {
+	// A description for the snapshot.
+	Description *string `locationName:"description" type:"string"`
+
+	// The block device mapping for the snapshot.
+	DeviceName *string `locationName:"deviceName" type:"string"`
+
+	// The size of the disk in the snapshot, in GiB.
+	DiskImageSize *float64 `locationName:"diskImageSize" type:"double"`
+
+	// The format of the disk image from which the snapshot is created.
+	Format *string `locationName:"format" type:"string"`
+
+	// The percentage of progress for the task.
+	Progress *string `locationName:"progress" type:"string"`
+
+	// The snapshot ID of the disk being imported.
+	SnapshotID *string `locationName:"snapshotId" type:"string"`
+
+	// A brief status of the snapshot creation.
+	Status *string `locationName:"status" type:"string"`
+
+	// A detailed status message for the snapshot creation.
+	StatusMessage *string `locationName:"statusMessage" type:"string"`
+
+	// The URL used to access the disk image.
+	URL *string `locationName:"url" type:"string"`
+
+	// Describes the S3 bucket for the disk image.
+	UserBucket *UserBucketDetails `locationName:"userBucket" type:"structure"`
+
+	metadataSnapshotDetail `json:"-" xml:"-"`
+}
+
+type metadataSnapshotDetail struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s SnapshotDetail) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SnapshotDetail) GoString() string {
+	return s.String()
+}
+
+// The disk container object for the import snapshot request.
+type SnapshotDiskContainer struct {
+	// The description of the disk image being imported.
+	Description *string `type:"string"`
+
+	// The format of the disk image being imported.
+	//
+	// Valid values: RAW | VHD | VMDK | OVA
+	Format *string `type:"string"`
+
+	// The URL to the Amazon S3-based disk image being imported. It can either be
+	// a https URL (https://..) or an Amazon S3 URL (s3://..).
+	URL *string `locationName:"Url" type:"string"`
+
+	// Describes the S3 bucket for the disk image.
+	UserBucket *UserBucket `type:"structure"`
+
+	metadataSnapshotDiskContainer `json:"-" xml:"-"`
+}
+
+type metadataSnapshotDiskContainer struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s SnapshotDiskContainer) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SnapshotDiskContainer) GoString() string {
+	return s.String()
+}
+
+// Details about the import snapshot task.
+type SnapshotTaskDetail struct {
+	// The description of the snapshot.
+	Description *string `locationName:"description" type:"string"`
+
+	// The size of the disk in the snapshot, in GiB.
+	DiskImageSize *float64 `locationName:"diskImageSize" type:"double"`
+
+	// The format of the disk image from which the snapshot is created.
+	Format *string `locationName:"format" type:"string"`
+
+	// The percentage of completion for the import snapshot task.
+	Progress *string `locationName:"progress" type:"string"`
+
+	// The snapshot ID of the disk being imported.
+	SnapshotID *string `locationName:"snapshotId" type:"string"`
+
+	// A brief status for the import snapshot task.
+	Status *string `locationName:"status" type:"string"`
+
+	// A detailed status message for the import snapshot task.
+	StatusMessage *string `locationName:"statusMessage" type:"string"`
+
+	// The URL of the disk image from which the snapshot is created.
+	URL *string `locationName:"url" type:"string"`
+
+	// The S3 bucket for the disk image.
+	UserBucket *UserBucketDetails `locationName:"userBucket" type:"structure"`
+
+	metadataSnapshotTaskDetail `json:"-" xml:"-"`
+}
+
+type metadataSnapshotTaskDetail struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s SnapshotTaskDetail) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SnapshotTaskDetail) GoString() string {
+	return s.String()
+}
+
+// Describes the data feed for a Spot Instance.
+type SpotDatafeedSubscription struct {
+	// The Amazon S3 bucket where the Spot Instance data feed is located.
+	Bucket *string `locationName:"bucket" type:"string"`
+
+	// The fault codes for the Spot Instance request, if any.
+	Fault *SpotInstanceStateFault `locationName:"fault" type:"structure"`
+
+	// The AWS account ID of the account.
+	OwnerID *string `locationName:"ownerId" type:"string"`
+
+	// The prefix that is prepended to data feed files.
+	Prefix *string `locationName:"prefix" type:"string"`
+
+	// The state of the Spot Instance data feed subscription.
+	State *string `locationName:"state" type:"string" enum:"DatafeedSubscriptionState"`
+
+	metadataSpotDatafeedSubscription `json:"-" xml:"-"`
+}
+
+type metadataSpotDatafeedSubscription struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s SpotDatafeedSubscription) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SpotDatafeedSubscription) GoString() string {
+	return s.String()
+}
+
+// Describes the launch specification for an instance.
+type SpotFleetLaunchSpecification struct {
+	// Deprecated.
+	AddressingType *string `locationName:"addressingType" type:"string"`
+
+	// One or more block device mapping entries.
+	BlockDeviceMappings []*BlockDeviceMapping `locationName:"blockDeviceMapping" locationNameList:"item" type:"list"`
+
+	// Indicates whether the instance is optimized for EBS I/O. This optimization
+	// provides dedicated throughput to Amazon EBS and an optimized configuration
+	// stack to provide optimal EBS I/O performance. This optimization isn't available
+	// with all instance types. Additional usage charges apply when using an EBS
+	// Optimized instance.
+	//
+	// Default: false
+	EBSOptimized *bool `locationName:"ebsOptimized" type:"boolean"`
+
+	// Describes an IAM instance profile.
+	IAMInstanceProfile *IAMInstanceProfileSpecification `locationName:"iamInstanceProfile" type:"structure"`
+
+	// The ID of the AMI.
+	ImageID *string `locationName:"imageId" type:"string"`
+
+	// The instance type.
+	InstanceType *string `locationName:"instanceType" type:"string" enum:"InstanceType"`
+
+	// The ID of the kernel.
+	KernelID *string `locationName:"kernelId" type:"string"`
+
+	// The name of the key pair.
+	KeyName *string `locationName:"keyName" type:"string"`
+
+	// Enable or disable monitoring for the instance.
+	Monitoring *SpotFleetMonitoring `locationName:"monitoring" type:"structure"`
+
+	// One or more network interfaces.
+	NetworkInterfaces []*InstanceNetworkInterfaceSpecification `locationName:"networkInterfaceSet" locationNameList:"item" type:"list"`
+
+	// Describes Spot Instance placement.
+	Placement *SpotPlacement `locationName:"placement" type:"structure"`
+
+	// The ID of the RAM disk.
+	RAMDiskID *string `locationName:"ramdiskId" type:"string"`
+
+	// One or more security groups. To request an instance in a nondefault VPC,
+	// you must specify the ID of the security group. To request an instance in
+	// EC2-Classic or a default VPC, you can specify the name or the ID of the security
+	// group.
+	SecurityGroups []*GroupIdentifier `locationName:"groupSet" locationNameList:"item" type:"list"`
+
+	// The ID of the subnet in which to launch the instance.
+	SubnetID *string `locationName:"subnetId" type:"string"`
+
+	// The Base64-encoded MIME user data to make available to the instances.
+	UserData *string `locationName:"userData" type:"string"`
+
+	metadataSpotFleetLaunchSpecification `json:"-" xml:"-"`
+}
+
+type metadataSpotFleetLaunchSpecification struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s SpotFleetLaunchSpecification) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SpotFleetLaunchSpecification) GoString() string {
+	return s.String()
+}
+
+// Describes whether monitoring is enabled.
+type SpotFleetMonitoring struct {
+	// Enables monitoring for the instance.
+	//
+	// Default: false
+	Enabled *bool `locationName:"enabled" type:"boolean"`
+
+	metadataSpotFleetMonitoring `json:"-" xml:"-"`
+}
+
+type metadataSpotFleetMonitoring struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s SpotFleetMonitoring) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SpotFleetMonitoring) GoString() string {
+	return s.String()
+}
+
+// Describes a Spot fleet request.
+type SpotFleetRequestConfig struct {
+	// Information about the configuration of the Spot fleet request.
+	SpotFleetRequestConfig *SpotFleetRequestConfigData `locationName:"spotFleetRequestConfig" type:"structure" required:"true"`
+
+	// The ID of the Spot fleet request.
+	SpotFleetRequestID *string `locationName:"spotFleetRequestId" type:"string" required:"true"`
+
+	// The state of the Spot fleet request.
+	SpotFleetRequestState *string `locationName:"spotFleetRequestState" type:"string" required:"true" enum:"BatchState"`
+
+	metadataSpotFleetRequestConfig `json:"-" xml:"-"`
+}
+
+type metadataSpotFleetRequestConfig struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s SpotFleetRequestConfig) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SpotFleetRequestConfig) GoString() string {
+	return s.String()
+}
+
+// Describes the configuration of a Spot fleet request.
+type SpotFleetRequestConfigData struct {
+	// A unique, case-sensitive identifier you provide to ensure idempotency of
+	// your listings. This helps avoid duplicate listings. For more information,
+	// see Ensuring Idempotency (http://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html).
+	ClientToken *string `locationName:"clientToken" type:"string"`
+
+	// Grants the Spot fleet service permission to terminate instances on your behalf
+	// when you cancel a Spot fleet request using CancelSpotFleetRequests or when
+	// the Spot fleet request expires, if you set terminateInstancesWithExpiration.
+	IAMFleetRole *string `locationName:"iamFleetRole" type:"string" required:"true"`
+
+	// Information about the launch specifications for the instances.
+	LaunchSpecifications []*SpotFleetLaunchSpecification `locationName:"launchSpecifications" locationNameList:"item" type:"list" required:"true"`
+
+	// The maximum hourly price (bid) for any Spot Instance launched to fulfill
+	// the request.
+	SpotPrice *string `locationName:"spotPrice" type:"string" required:"true"`
+
+	// The maximum number of Spot Instances to launch.
+	TargetCapacity *int64 `locationName:"targetCapacity" type:"integer" required:"true"`
+
+	// Indicates whether running instances should be terminated when the Spot fleet
+	// request expires.
+	TerminateInstancesWithExpiration *bool `locationName:"terminateInstancesWithExpiration" type:"boolean"`
+
+	// The start date and time of the request, in UTC format (for example, YYYY-MM-DDTHH:MM:SSZ).
+	// The default is to start fulfilling the request immediately.
+	ValidFrom *time.Time `locationName:"validFrom" type:"timestamp" timestampFormat:"iso8601"`
+
+	// The end date and time of the request, in UTC format (for example, YYYY-MM-DDTHH:MM:SSZ).
+	// At this point, no new Spot Instance requests are placed or enabled to fulfill
+	// the request.
+	ValidUntil *time.Time `locationName:"validUntil" type:"timestamp" timestampFormat:"iso8601"`
+
+	metadataSpotFleetRequestConfigData `json:"-" xml:"-"`
+}
+
+type metadataSpotFleetRequestConfigData struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s SpotFleetRequestConfigData) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SpotFleetRequestConfigData) GoString() string {
+	return s.String()
+}
+
+// Describe a Spot Instance request.
+type SpotInstanceRequest struct {
+	// The Availability Zone group. If you specify the same Availability Zone group
+	// for all Spot Instance requests, all Spot Instances are launched in the same
+	// Availability Zone.
+	AvailabilityZoneGroup *string `locationName:"availabilityZoneGroup" type:"string"`
+
+	// The date and time when the Spot Instance request was created, in UTC format
+	// (for example, YYYY-MM-DDTHH:MM:SSZ).
+	CreateTime *time.Time `locationName:"createTime" type:"timestamp" timestampFormat:"iso8601"`
+
+	// The fault codes for the Spot Instance request, if any.
+	Fault *SpotInstanceStateFault `locationName:"fault" type:"structure"`
+
+	// The instance ID, if an instance has been launched to fulfill the Spot Instance
+	// request.
+	InstanceID *string `locationName:"instanceId" type:"string"`
+
+	// The instance launch group. Launch groups are Spot Instances that launch together
+	// and terminate together.
+	LaunchGroup *string `locationName:"launchGroup" type:"string"`
+
+	// Additional information for launching instances.
+	LaunchSpecification *LaunchSpecification `locationName:"launchSpecification" type:"structure"`
+
+	// The Availability Zone in which the bid is launched.
+	LaunchedAvailabilityZone *string `locationName:"launchedAvailabilityZone" type:"string"`
+
+	// The product description associated with the Spot Instance.
+	ProductDescription *string `locationName:"productDescription" type:"string" enum:"RIProductDescription"`
+
+	// The ID of the Spot Instance request.
+	SpotInstanceRequestID *string `locationName:"spotInstanceRequestId" type:"string"`
+
+	// The maximum hourly price (bid) for any Spot Instance launched to fulfill
+	// the request.
+	SpotPrice *string `locationName:"spotPrice" type:"string"`
+
+	// The state of the Spot Instance request. Spot bid status information can help
+	// you track your Spot Instance requests. For more information, see Spot Bid
+	// Status (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-bid-status.html)
+	// in the Amazon Elastic Compute Cloud User Guide.
+	State *string `locationName:"state" type:"string" enum:"SpotInstanceState"`
+
+	// The status code and status message describing the Spot Instance request.
+	Status *SpotInstanceStatus `locationName:"status" type:"structure"`
+
+	// Any tags assigned to the resource.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	// The Spot Instance request type.
+	Type *string `locationName:"type" type:"string" enum:"SpotInstanceType"`
+
+	// The start date of the request, in UTC format (for example, YYYY-MM-DDTHH:MM:SSZ).
+	// If this is a one-time request, the request becomes active at this date and
+	// time and remains active until all instances launch, the request expires,
+	// or the request is canceled. If the request is persistent, the request becomes
+	// active at this date and time and remains active until it expires or is canceled.
+	ValidFrom *time.Time `locationName:"validFrom" type:"timestamp" timestampFormat:"iso8601"`
+
+	// The end date of the request, in UTC format (for example, YYYY-MM-DDTHH:MM:SSZ).
+	// If this is a one-time request, the request remains active until all instances
+	// launch, the request is canceled, or this date is reached. If the request
+	// is persistent, it remains active until it is canceled or this date is reached.
+	ValidUntil *time.Time `locationName:"validUntil" type:"timestamp" timestampFormat:"iso8601"`
+
+	metadataSpotInstanceRequest `json:"-" xml:"-"`
+}
+
+type metadataSpotInstanceRequest struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s SpotInstanceRequest) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SpotInstanceRequest) GoString() string {
+	return s.String()
+}
+
+// Describes a Spot Instance state change.
+type SpotInstanceStateFault struct {
+	// The reason code for the Spot Instance state change.
+	Code *string `locationName:"code" type:"string"`
+
+	// The message for the Spot Instance state change.
+	Message *string `locationName:"message" type:"string"`
+
+	metadataSpotInstanceStateFault `json:"-" xml:"-"`
+}
+
+type metadataSpotInstanceStateFault struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s SpotInstanceStateFault) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SpotInstanceStateFault) GoString() string {
+	return s.String()
+}
+
+// Describes the status of a Spot Instance request.
+type SpotInstanceStatus struct {
+	// The status code.
+	Code *string `locationName:"code" type:"string"`
+
+	// The description for the status code.
+	Message *string `locationName:"message" type:"string"`
+
+	// The date and time of the most recent status update, in UTC format (for example,
+	// YYYY-MM-DDTHH:MM:SSZ).
+	UpdateTime *time.Time `locationName:"updateTime" type:"timestamp" timestampFormat:"iso8601"`
+
+	metadataSpotInstanceStatus `json:"-" xml:"-"`
+}
+
+type metadataSpotInstanceStatus struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s SpotInstanceStatus) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SpotInstanceStatus) GoString() string {
+	return s.String()
+}
+
+// Describes Spot Instance placement.
+type SpotPlacement struct {
+	// The Availability Zone.
+	AvailabilityZone *string `locationName:"availabilityZone" type:"string"`
+
+	// The name of the placement group (for cluster instances).
+	GroupName *string `locationName:"groupName" type:"string"`
+
+	metadataSpotPlacement `json:"-" xml:"-"`
+}
+
+type metadataSpotPlacement struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s SpotPlacement) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SpotPlacement) GoString() string {
+	return s.String()
+}
+
+// Describes the maximum hourly price (bid) for any Spot Instance launched to
+// fulfill the request.
+type SpotPrice struct {
+	// The Availability Zone.
+	AvailabilityZone *string `locationName:"availabilityZone" type:"string"`
+
+	// The instance type.
+	InstanceType *string `locationName:"instanceType" type:"string" enum:"InstanceType"`
+
+	// A general description of the AMI.
+	ProductDescription *string `locationName:"productDescription" type:"string" enum:"RIProductDescription"`
+
+	// The maximum price (bid) that you are willing to pay for a Spot Instance.
+	SpotPrice *string `locationName:"spotPrice" type:"string"`
+
+	// The date and time the request was created, in UTC format (for example, YYYY-MM-DDTHH:MM:SSZ).
+	Timestamp *time.Time `locationName:"timestamp" type:"timestamp" timestampFormat:"iso8601"`
+
+	metadataSpotPrice `json:"-" xml:"-"`
+}
+
+type metadataSpotPrice struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s SpotPrice) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SpotPrice) GoString() string {
+	return s.String()
+}
+
+type StartInstancesInput struct {
+	// Reserved.
+	AdditionalInfo *string `locationName:"additionalInfo" type:"string"`
+
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more instance IDs.
+	InstanceIDs []*string `locationName:"InstanceId" locationNameList:"InstanceId" type:"list" required:"true"`
+
+	metadataStartInstancesInput `json:"-" xml:"-"`
+}
+
+type metadataStartInstancesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s StartInstancesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s StartInstancesInput) GoString() string {
+	return s.String()
+}
+
+type StartInstancesOutput struct {
+	// Information about one or more started instances.
+	StartingInstances []*InstanceStateChange `locationName:"instancesSet" locationNameList:"item" type:"list"`
+
+	metadataStartInstancesOutput `json:"-" xml:"-"`
+}
+
+type metadataStartInstancesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s StartInstancesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s StartInstancesOutput) GoString() string {
+	return s.String()
+}
+
+// Describes a state change.
+type StateReason struct {
+	// The reason code for the state change.
+	Code *string `locationName:"code" type:"string"`
+
+	// The message for the state change.
+	//
+	//  Server.SpotInstanceTermination: A Spot Instance was terminated due to an
+	// increase in the market price.
+	//
+	// Server.InternalError: An internal error occurred during instance launch,
+	// resulting in termination.
+	//
+	// Server.InsufficientInstanceCapacity: There was insufficient instance capacity
+	// to satisfy the launch request.
+	//
+	// Client.InternalError: A client error caused the instance to terminate on
+	// launch.
+	//
+	// Client.InstanceInitiatedShutdown: The instance was shut down using the shutdown
+	// -h command from the instance.
+	//
+	// Client.UserInitiatedShutdown: The instance was shut down using the Amazon
+	// EC2 API.
+	//
+	// Client.VolumeLimitExceeded: The volume limit was exceeded.
+	//
+	// Client.InvalidSnapshot.NotFound: The specified snapshot was not found.
+	Message *string `locationName:"message" type:"string"`
+
+	metadataStateReason `json:"-" xml:"-"`
+}
+
+type metadataStateReason struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s StateReason) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s StateReason) GoString() string {
+	return s.String()
+}
+
+type StopInstancesInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// Forces the instances to stop. The instances do not have an opportunity to
+	// flush file system caches or file system metadata. If you use this option,
+	// you must perform file system check and repair procedures. This option is
+	// not recommended for Windows instances.
+	//
+	// Default: false
+	Force *bool `locationName:"force" type:"boolean"`
+
+	// One or more instance IDs.
+	InstanceIDs []*string `locationName:"InstanceId" locationNameList:"InstanceId" type:"list" required:"true"`
+
+	metadataStopInstancesInput `json:"-" xml:"-"`
+}
+
+type metadataStopInstancesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s StopInstancesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s StopInstancesInput) GoString() string {
+	return s.String()
+}
+
+type StopInstancesOutput struct {
+	// Information about one or more stopped instances.
+	StoppingInstances []*InstanceStateChange `locationName:"instancesSet" locationNameList:"item" type:"list"`
+
+	metadataStopInstancesOutput `json:"-" xml:"-"`
+}
+
+type metadataStopInstancesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s StopInstancesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s StopInstancesOutput) GoString() string {
+	return s.String()
+}
+
+// Describes the storage location for an instance store-backed AMI.
+type Storage struct {
+	// An Amazon S3 storage location.
+	S3 *S3Storage `type:"structure"`
+
+	metadataStorage `json:"-" xml:"-"`
+}
+
+type metadataStorage struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s Storage) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Storage) GoString() string {
+	return s.String()
+}
+
+// Describes a subnet.
+type Subnet struct {
+	// The Availability Zone of the subnet.
+	AvailabilityZone *string `locationName:"availabilityZone" type:"string"`
+
+	// The number of unused IP addresses in the subnet. Note that the IP addresses
+	// for any stopped instances are considered unavailable.
+	AvailableIPAddressCount *int64 `locationName:"availableIpAddressCount" type:"integer"`
+
+	// The CIDR block assigned to the subnet.
+	CIDRBlock *string `locationName:"cidrBlock" type:"string"`
+
+	// Indicates whether this is the default subnet for the Availability Zone.
+	DefaultForAZ *bool `locationName:"defaultForAz" type:"boolean"`
+
+	// Indicates whether instances launched in this subnet receive a public IP address.
+	MapPublicIPOnLaunch *bool `locationName:"mapPublicIpOnLaunch" type:"boolean"`
+
+	// The current state of the subnet.
+	State *string `locationName:"state" type:"string" enum:"SubnetState"`
+
+	// The ID of the subnet.
+	SubnetID *string `locationName:"subnetId" type:"string"`
+
+	// Any tags assigned to the subnet.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	// The ID of the VPC the subnet is in.
+	VPCID *string `locationName:"vpcId" type:"string"`
+
+	metadataSubnet `json:"-" xml:"-"`
+}
+
+type metadataSubnet struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s Subnet) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Subnet) GoString() string {
+	return s.String()
+}
+
+// Describes a tag.
+type Tag struct {
+	// The key of the tag.
+	//
+	// Constraints: Tag keys are case-sensitive and accept a maximum of 127 Unicode
+	// characters. May not begin with aws:
+	Key *string `locationName:"key" type:"string"`
+
+	// The value of the tag.
+	//
+	// Constraints: Tag values are case-sensitive and accept a maximum of 255 Unicode
+	// characters.
+	Value *string `locationName:"value" type:"string"`
+
+	metadataTag `json:"-" xml:"-"`
+}
+
+type metadataTag struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s Tag) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Tag) GoString() string {
+	return s.String()
+}
+
+// Describes a tag.
+type TagDescription struct {
+	// The tag key.
+	Key *string `locationName:"key" type:"string"`
+
+	// The ID of the resource. For example, ami-1a2b3c4d.
+	ResourceID *string `locationName:"resourceId" type:"string"`
+
+	// The resource type.
+	ResourceType *string `locationName:"resourceType" type:"string" enum:"ResourceType"`
+
+	// The tag value.
+	Value *string `locationName:"value" type:"string"`
+
+	metadataTagDescription `json:"-" xml:"-"`
+}
+
+type metadataTagDescription struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s TagDescription) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s TagDescription) GoString() string {
+	return s.String()
+}
+
+type TerminateInstancesInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more instance IDs.
+	InstanceIDs []*string `locationName:"InstanceId" locationNameList:"InstanceId" type:"list" required:"true"`
+
+	metadataTerminateInstancesInput `json:"-" xml:"-"`
+}
+
+type metadataTerminateInstancesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s TerminateInstancesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s TerminateInstancesInput) GoString() string {
+	return s.String()
+}
+
+type TerminateInstancesOutput struct {
+	// Information about one or more terminated instances.
+	TerminatingInstances []*InstanceStateChange `locationName:"instancesSet" locationNameList:"item" type:"list"`
+
+	metadataTerminateInstancesOutput `json:"-" xml:"-"`
+}
+
+type metadataTerminateInstancesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s TerminateInstancesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s TerminateInstancesOutput) GoString() string {
+	return s.String()
+}
+
+type UnassignPrivateIPAddressesInput struct {
+	// The ID of the network interface.
+	NetworkInterfaceID *string `locationName:"networkInterfaceId" type:"string" required:"true"`
+
+	// The secondary private IP addresses to unassign from the network interface.
+	// You can specify this option multiple times to unassign more than one IP address.
+	PrivateIPAddresses []*string `locationName:"privateIpAddress" locationNameList:"PrivateIpAddress" type:"list" required:"true"`
+
+	metadataUnassignPrivateIPAddressesInput `json:"-" xml:"-"`
+}
+
+type metadataUnassignPrivateIPAddressesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s UnassignPrivateIPAddressesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UnassignPrivateIPAddressesInput) GoString() string {
+	return s.String()
+}
+
+type UnassignPrivateIPAddressesOutput struct {
+	metadataUnassignPrivateIPAddressesOutput `json:"-" xml:"-"`
+}
+
+type metadataUnassignPrivateIPAddressesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s UnassignPrivateIPAddressesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UnassignPrivateIPAddressesOutput) GoString() string {
+	return s.String()
+}
+
+type UnmonitorInstancesInput struct {
+	// Checks whether you have the required permissions for the action, without
+	// actually making the request, and provides an error response. If you have
+	// the required permissions, the error response is DryRunOperation. Otherwise,
+	// it is UnauthorizedOperation.
+	DryRun *bool `locationName:"dryRun" type:"boolean"`
+
+	// One or more instance IDs.
+	InstanceIDs []*string `locationName:"InstanceId" locationNameList:"InstanceId" type:"list" required:"true"`
+
+	metadataUnmonitorInstancesInput `json:"-" xml:"-"`
+}
+
+type metadataUnmonitorInstancesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s UnmonitorInstancesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UnmonitorInstancesInput) GoString() string {
+	return s.String()
+}
+
+type UnmonitorInstancesOutput struct {
+	// Monitoring information for one or more instances.
+	InstanceMonitorings []*InstanceMonitoring `locationName:"instancesSet" locationNameList:"item" type:"list"`
+
+	metadataUnmonitorInstancesOutput `json:"-" xml:"-"`
+}
+
+type metadataUnmonitorInstancesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s UnmonitorInstancesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UnmonitorInstancesOutput) GoString() string {
+	return s.String()
+}
+
+// Information about items that were not successfully processed in a batch call.
+type UnsuccessfulItem struct {
+	// Information about the error.
+	Error *UnsuccessfulItemError `locationName:"error" type:"structure" required:"true"`
+
+	// The ID of the resource.
+	ResourceID *string `locationName:"resourceId" type:"string"`
+
+	metadataUnsuccessfulItem `json:"-" xml:"-"`
+}
+
+type metadataUnsuccessfulItem struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s UnsuccessfulItem) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UnsuccessfulItem) GoString() string {
+	return s.String()
+}
+
+// Information about the error that occured. For more information about errors,
+// see Error Codes (http://docs.aws.amazon.com/AWSEC2/latest/APIReference/errors-overview.html).
+type UnsuccessfulItemError struct {
+	// The error code.
+	Code *string `locationName:"code" type:"string" required:"true"`
+
+	// The error message accompanying the error code.
+	Message *string `locationName:"message" type:"string" required:"true"`
+
+	metadataUnsuccessfulItemError `json:"-" xml:"-"`
+}
+
+type metadataUnsuccessfulItemError struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s UnsuccessfulItemError) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UnsuccessfulItemError) GoString() string {
+	return s.String()
+}
+
+// Describes the S3 bucket for the disk image.
+type UserBucket struct {
+	// The name of the S3 bucket where the disk image is located.
+	S3Bucket *string `type:"string"`
+
+	// The key for the disk image.
+	S3Key *string `type:"string"`
+
+	metadataUserBucket `json:"-" xml:"-"`
+}
+
+type metadataUserBucket struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s UserBucket) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UserBucket) GoString() string {
+	return s.String()
+}
+
+// Describes the S3 bucket for the disk image.
+type UserBucketDetails struct {
+	// The S3 bucket from which the disk image was created.
+	S3Bucket *string `locationName:"s3Bucket" type:"string"`
+
+	// The key from which the disk image was created.
+	S3Key *string `locationName:"s3Key" type:"string"`
+
+	metadataUserBucketDetails `json:"-" xml:"-"`
+}
+
+type metadataUserBucketDetails struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s UserBucketDetails) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UserBucketDetails) GoString() string {
+	return s.String()
+}
+
+// Describes the user data to be made available to an instance.
+type UserData struct {
+	// The Base64-encoded MIME user data for the instance.
+	Data *string `locationName:"data" type:"string"`
+
+	metadataUserData `json:"-" xml:"-"`
+}
+
+type metadataUserData struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s UserData) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UserData) GoString() string {
+	return s.String()
+}
+
+// Describes a security group and AWS account ID pair.
+type UserIDGroupPair struct {
+	// The ID of the security group.
+	GroupID *string `locationName:"groupId" type:"string"`
+
+	// The name of the security group. In a request, use this parameter for a security
+	// group in EC2-Classic or a default VPC only. For a security group in a nondefault
+	// VPC, use GroupId.
+	GroupName *string `locationName:"groupName" type:"string"`
+
+	// The ID of an AWS account. EC2-Classic only.
+	UserID *string `locationName:"userId" type:"string"`
+
+	metadataUserIDGroupPair `json:"-" xml:"-"`
+}
+
+type metadataUserIDGroupPair struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s UserIDGroupPair) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UserIDGroupPair) GoString() string {
+	return s.String()
+}
+
+// Describes telemetry for a VPN tunnel.
+type VGWTelemetry struct {
+	// The number of accepted routes.
+	AcceptedRouteCount *int64 `locationName:"acceptedRouteCount" type:"integer"`
+
+	// The date and time of the last change in status.
+	LastStatusChange *time.Time `locationName:"lastStatusChange" type:"timestamp" timestampFormat:"iso8601"`
+
+	// The Internet-routable IP address of the virtual private gateway's outside
+	// interface.
+	OutsideIPAddress *string `locationName:"outsideIpAddress" type:"string"`
+
+	// The status of the VPN tunnel.
+	Status *string `locationName:"status" type:"string" enum:"TelemetryStatus"`
+
+	// If an error occurs, a description of the error.
+	StatusMessage *string `locationName:"statusMessage" type:"string"`
+
+	metadataVGWTelemetry `json:"-" xml:"-"`
+}
+
+type metadataVGWTelemetry struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s VGWTelemetry) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VGWTelemetry) GoString() string {
+	return s.String()
+}
+
+// Describes a VPC.
+type VPC struct {
+	// The CIDR block for the VPC.
+	CIDRBlock *string `locationName:"cidrBlock" type:"string"`
+
+	// The ID of the set of DHCP options you've associated with the VPC (or default
+	// if the default options are associated with the VPC).
+	DHCPOptionsID *string `locationName:"dhcpOptionsId" type:"string"`
+
+	// The allowed tenancy of instances launched into the VPC.
+	InstanceTenancy *string `locationName:"instanceTenancy" type:"string" enum:"Tenancy"`
+
+	// Indicates whether the VPC is the default VPC.
+	IsDefault *bool `locationName:"isDefault" type:"boolean"`
+
+	// The current state of the VPC.
+	State *string `locationName:"state" type:"string" enum:"VpcState"`
+
+	// Any tags assigned to the VPC.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"vpcId" type:"string"`
+
+	metadataVPC `json:"-" xml:"-"`
+}
+
+type metadataVPC struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s VPC) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VPC) GoString() string {
+	return s.String()
+}
+
+// Describes an attachment between a virtual private gateway and a VPC.
+type VPCAttachment struct {
+	// The current state of the attachment.
+	State *string `locationName:"state" type:"string" enum:"AttachmentStatus"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"vpcId" type:"string"`
+
+	metadataVPCAttachment `json:"-" xml:"-"`
+}
+
+type metadataVPCAttachment struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s VPCAttachment) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VPCAttachment) GoString() string {
+	return s.String()
+}
+
+// Describes whether a VPC is enabled for ClassicLink.
+type VPCClassicLink struct {
+	// Indicates whether the VPC is enabled for ClassicLink.
+	ClassicLinkEnabled *bool `locationName:"classicLinkEnabled" type:"boolean"`
+
+	// Any tags assigned to the VPC.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"vpcId" type:"string"`
+
+	metadataVPCClassicLink `json:"-" xml:"-"`
+}
+
+type metadataVPCClassicLink struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s VPCClassicLink) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VPCClassicLink) GoString() string {
+	return s.String()
+}
+
+// Describes a VPC endpoint.
+type VPCEndpoint struct {
+	// The date and time the VPC endpoint was created.
+	CreationTimestamp *time.Time `locationName:"creationTimestamp" type:"timestamp" timestampFormat:"iso8601"`
+
+	// The policy document associated with the endpoint.
+	PolicyDocument *string `locationName:"policyDocument" type:"string"`
+
+	// One or more route tables associated with the endpoint.
+	RouteTableIDs []*string `locationName:"routeTableIdSet" locationNameList:"item" type:"list"`
+
+	// The name of the AWS service to which the endpoint is associated.
+	ServiceName *string `locationName:"serviceName" type:"string"`
+
+	// The state of the VPC endpoint.
+	State *string `locationName:"state" type:"string" enum:"State"`
+
+	// The ID of the VPC endpoint.
+	VPCEndpointID *string `locationName:"vpcEndpointId" type:"string"`
+
+	// The ID of the VPC to which the endpoint is associated.
+	VPCID *string `locationName:"vpcId" type:"string"`
+
+	metadataVPCEndpoint `json:"-" xml:"-"`
+}
+
+type metadataVPCEndpoint struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s VPCEndpoint) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VPCEndpoint) GoString() string {
+	return s.String()
+}
+
+// Describes a VPC peering connection.
+type VPCPeeringConnection struct {
+	// The information of the peer VPC.
+	AccepterVPCInfo *VPCPeeringConnectionVPCInfo `locationName:"accepterVpcInfo" type:"structure"`
+
+	// The time that an unaccepted VPC peering connection will expire.
+	ExpirationTime *time.Time `locationName:"expirationTime" type:"timestamp" timestampFormat:"iso8601"`
+
+	// The information of the requester VPC.
+	RequesterVPCInfo *VPCPeeringConnectionVPCInfo `locationName:"requesterVpcInfo" type:"structure"`
+
+	// The status of the VPC peering connection.
+	Status *VPCPeeringConnectionStateReason `locationName:"status" type:"structure"`
+
+	// Any tags assigned to the resource.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	// The ID of the VPC peering connection.
+	VPCPeeringConnectionID *string `locationName:"vpcPeeringConnectionId" type:"string"`
+
+	metadataVPCPeeringConnection `json:"-" xml:"-"`
+}
+
+type metadataVPCPeeringConnection struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s VPCPeeringConnection) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VPCPeeringConnection) GoString() string {
+	return s.String()
+}
+
+// Describes the status of a VPC peering connection.
+type VPCPeeringConnectionStateReason struct {
+	// The status of the VPC peering connection.
+	Code *string `locationName:"code" type:"string" enum:"VpcPeeringConnectionStateReasonCode"`
+
+	// A message that provides more information about the status, if applicable.
+	Message *string `locationName:"message" type:"string"`
+
+	metadataVPCPeeringConnectionStateReason `json:"-" xml:"-"`
+}
+
+type metadataVPCPeeringConnectionStateReason struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s VPCPeeringConnectionStateReason) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VPCPeeringConnectionStateReason) GoString() string {
+	return s.String()
+}
+
+// Describes a VPC in a VPC peering connection.
+type VPCPeeringConnectionVPCInfo struct {
+	// The CIDR block for the VPC.
+	CIDRBlock *string `locationName:"cidrBlock" type:"string"`
+
+	// The AWS account ID of the VPC owner.
+	OwnerID *string `locationName:"ownerId" type:"string"`
+
+	// The ID of the VPC.
+	VPCID *string `locationName:"vpcId" type:"string"`
+
+	metadataVPCPeeringConnectionVPCInfo `json:"-" xml:"-"`
+}
+
+type metadataVPCPeeringConnectionVPCInfo struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s VPCPeeringConnectionVPCInfo) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VPCPeeringConnectionVPCInfo) GoString() string {
+	return s.String()
+}
+
+// Describes a VPN connection.
+type VPNConnection struct {
+	// The configuration information for the VPN connection's customer gateway (in
+	// the native XML format). This element is always present in the CreateVpnConnection
+	// response; however, it's present in the DescribeVpnConnections response only
+	// if the VPN connection is in the pending or available state.
+	CustomerGatewayConfiguration *string `locationName:"customerGatewayConfiguration" type:"string"`
+
+	// The ID of the customer gateway at your end of the VPN connection.
+	CustomerGatewayID *string `locationName:"customerGatewayId" type:"string"`
+
+	// The VPN connection options.
+	Options *VPNConnectionOptions `locationName:"options" type:"structure"`
+
+	// The static routes associated with the VPN connection.
+	Routes []*VPNStaticRoute `locationName:"routes" locationNameList:"item" type:"list"`
+
+	// The current state of the VPN connection.
+	State *string `locationName:"state" type:"string" enum:"VpnState"`
+
+	// Any tags assigned to the VPN connection.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	// The type of VPN connection.
+	Type *string `locationName:"type" type:"string" enum:"GatewayType"`
+
+	// Information about the VPN tunnel.
+	VGWTelemetry []*VGWTelemetry `locationName:"vgwTelemetry" locationNameList:"item" type:"list"`
+
+	// The ID of the VPN connection.
+	VPNConnectionID *string `locationName:"vpnConnectionId" type:"string"`
+
+	// The ID of the virtual private gateway at the AWS side of the VPN connection.
+	VPNGatewayID *string `locationName:"vpnGatewayId" type:"string"`
+
+	metadataVPNConnection `json:"-" xml:"-"`
+}
+
+type metadataVPNConnection struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s VPNConnection) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VPNConnection) GoString() string {
+	return s.String()
+}
+
+// Describes VPN connection options.
+type VPNConnectionOptions struct {
+	// Indicates whether the VPN connection uses static routes only. Static routes
+	// must be used for devices that don't support BGP.
+	StaticRoutesOnly *bool `locationName:"staticRoutesOnly" type:"boolean"`
+
+	metadataVPNConnectionOptions `json:"-" xml:"-"`
+}
+
+type metadataVPNConnectionOptions struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s VPNConnectionOptions) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VPNConnectionOptions) GoString() string {
+	return s.String()
+}
+
+// Describes VPN connection options.
+type VPNConnectionOptionsSpecification struct {
+	// Indicates whether the VPN connection uses static routes only. Static routes
+	// must be used for devices that don't support BGP.
+	StaticRoutesOnly *bool `locationName:"staticRoutesOnly" type:"boolean"`
+
+	metadataVPNConnectionOptionsSpecification `json:"-" xml:"-"`
+}
+
+type metadataVPNConnectionOptionsSpecification struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s VPNConnectionOptionsSpecification) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VPNConnectionOptionsSpecification) GoString() string {
+	return s.String()
+}
+
+// Describes a virtual private gateway.
+type VPNGateway struct {
+	// The Availability Zone where the virtual private gateway was created.
+	AvailabilityZone *string `locationName:"availabilityZone" type:"string"`
+
+	// The current state of the virtual private gateway.
+	State *string `locationName:"state" type:"string" enum:"VpnState"`
+
+	// Any tags assigned to the virtual private gateway.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	// The type of VPN connection the virtual private gateway supports.
+	Type *string `locationName:"type" type:"string" enum:"GatewayType"`
+
+	// Any VPCs attached to the virtual private gateway.
+	VPCAttachments []*VPCAttachment `locationName:"attachments" locationNameList:"item" type:"list"`
+
+	// The ID of the virtual private gateway.
+	VPNGatewayID *string `locationName:"vpnGatewayId" type:"string"`
+
+	metadataVPNGateway `json:"-" xml:"-"`
+}
+
+type metadataVPNGateway struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s VPNGateway) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VPNGateway) GoString() string {
+	return s.String()
+}
+
+// Describes a static route for a VPN connection.
+type VPNStaticRoute struct {
+	// The CIDR block associated with the local subnet of the customer data center.
+	DestinationCIDRBlock *string `locationName:"destinationCidrBlock" type:"string"`
+
+	// Indicates how the routes were provided.
+	Source *string `locationName:"source" type:"string" enum:"VpnStaticRouteSource"`
+
+	// The current state of the static route.
+	State *string `locationName:"state" type:"string" enum:"VpnState"`
+
+	metadataVPNStaticRoute `json:"-" xml:"-"`
+}
+
+type metadataVPNStaticRoute struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s VPNStaticRoute) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VPNStaticRoute) GoString() string {
+	return s.String()
+}
+
+// Describes a volume.
+type Volume struct {
+	// Information about the volume attachments.
+	Attachments []*VolumeAttachment `locationName:"attachmentSet" locationNameList:"item" type:"list"`
+
+	// The Availability Zone for the volume.
+	AvailabilityZone *string `locationName:"availabilityZone" type:"string"`
+
+	// The time stamp when volume creation was initiated.
+	CreateTime *time.Time `locationName:"createTime" type:"timestamp" timestampFormat:"iso8601"`
+
+	// Indicates whether the volume will be encrypted.
+	Encrypted *bool `locationName:"encrypted" type:"boolean"`
+
+	// The number of I/O operations per second (IOPS) that the volume supports.
+	// For Provisioned IOPS (SSD) volumes, this represents the number of IOPS that
+	// are provisioned for the volume. For General Purpose (SSD) volumes, this represents
+	// the baseline performance of the volume and the rate at which the volume accumulates
+	// I/O credits for bursting. For more information on General Purpose (SSD) baseline
+	// performance, I/O credits, and bursting, see Amazon EBS Volume Types (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html)
+	// in the Amazon Elastic Compute Cloud User Guide.
+	//
+	// Constraint: Range is 100 to 20000 for Provisioned IOPS (SSD) volumes and
+	// 3 to 10000 for General Purpose (SSD) volumes.
+	//
+	// Condition: This parameter is required for requests to create io1 volumes;
+	// it is not used in requests to create standard or gp2 volumes.
+	IOPS *int64 `locationName:"iops" type:"integer"`
+
+	// The full ARN of the AWS Key Management Service (AWS KMS) customer master
+	// key (CMK) that was used to protect the volume encryption key for the volume.
+	KMSKeyID *string `locationName:"kmsKeyId" type:"string"`
+
+	// The size of the volume, in GiBs.
+	Size *int64 `locationName:"size" type:"integer"`
+
+	// The snapshot from which the volume was created, if applicable.
+	SnapshotID *string `locationName:"snapshotId" type:"string"`
+
+	// The volume state.
+	State *string `locationName:"status" type:"string" enum:"VolumeState"`
+
+	// Any tags assigned to the volume.
+	Tags []*Tag `locationName:"tagSet" locationNameList:"item" type:"list"`
+
+	// The ID of the volume.
+	VolumeID *string `locationName:"volumeId" type:"string"`
+
+	// The volume type. This can be gp2 for General Purpose (SSD) volumes, io1 for
+	// Provisioned IOPS (SSD) volumes, or standard for Magnetic volumes.
+	VolumeType *string `locationName:"volumeType" type:"string" enum:"VolumeType"`
+
+	metadataVolume `json:"-" xml:"-"`
+}
+
+type metadataVolume struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s Volume) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Volume) GoString() string {
+	return s.String()
+}
+
+// Describes volume attachment details.
+type VolumeAttachment struct {
+	// The time stamp when the attachment initiated.
+	AttachTime *time.Time `locationName:"attachTime" type:"timestamp" timestampFormat:"iso8601"`
+
+	// Indicates whether the EBS volume is deleted on instance termination.
+	DeleteOnTermination *bool `locationName:"deleteOnTermination" type:"boolean"`
+
+	// The device name.
+	Device *string `locationName:"device" type:"string"`
+
+	// The ID of the instance.
+	InstanceID *string `locationName:"instanceId" type:"string"`
+
+	// The attachment state of the volume.
+	State *string `locationName:"status" type:"string" enum:"VolumeAttachmentState"`
+
+	// The ID of the volume.
+	VolumeID *string `locationName:"volumeId" type:"string"`
+
+	metadataVolumeAttachment `json:"-" xml:"-"`
+}
+
+type metadataVolumeAttachment struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s VolumeAttachment) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VolumeAttachment) GoString() string {
+	return s.String()
+}
+
+// Describes an EBS volume.
+type VolumeDetail struct {
+	// The size of the volume, in GiB.
+	Size *int64 `locationName:"size" type:"long" required:"true"`
+
+	metadataVolumeDetail `json:"-" xml:"-"`
+}
+
+type metadataVolumeDetail struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s VolumeDetail) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VolumeDetail) GoString() string {
+	return s.String()
+}
+
+// Describes a volume status operation code.
+type VolumeStatusAction struct {
+	// The code identifying the operation, for example, enable-volume-io.
+	Code *string `locationName:"code" type:"string"`
+
+	// A description of the operation.
+	Description *string `locationName:"description" type:"string"`
+
+	// The ID of the event associated with this operation.
+	EventID *string `locationName:"eventId" type:"string"`
+
+	// The event type associated with this operation.
+	EventType *string `locationName:"eventType" type:"string"`
+
+	metadataVolumeStatusAction `json:"-" xml:"-"`
+}
+
+type metadataVolumeStatusAction struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s VolumeStatusAction) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VolumeStatusAction) GoString() string {
+	return s.String()
+}
+
+// Describes a volume status.
+type VolumeStatusDetails struct {
+	// The name of the volume status.
+	Name *string `locationName:"name" type:"string" enum:"VolumeStatusName"`
+
+	// The intended status of the volume status.
+	Status *string `locationName:"status" type:"string"`
+
+	metadataVolumeStatusDetails `json:"-" xml:"-"`
+}
+
+type metadataVolumeStatusDetails struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s VolumeStatusDetails) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VolumeStatusDetails) GoString() string {
+	return s.String()
+}
+
+// Describes a volume status event.
+type VolumeStatusEvent struct {
+	// A description of the event.
+	Description *string `locationName:"description" type:"string"`
+
+	// The ID of this event.
+	EventID *string `locationName:"eventId" type:"string"`
+
+	// The type of this event.
+	EventType *string `locationName:"eventType" type:"string"`
+
+	// The latest end time of the event.
+	NotAfter *time.Time `locationName:"notAfter" type:"timestamp" timestampFormat:"iso8601"`
+
+	// The earliest start time of the event.
+	NotBefore *time.Time `locationName:"notBefore" type:"timestamp" timestampFormat:"iso8601"`
+
+	metadataVolumeStatusEvent `json:"-" xml:"-"`
+}
+
+type metadataVolumeStatusEvent struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s VolumeStatusEvent) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VolumeStatusEvent) GoString() string {
+	return s.String()
+}
+
+// Describes the status of a volume.
+type VolumeStatusInfo struct {
+	// The details of the volume status.
+	Details []*VolumeStatusDetails `locationName:"details" locationNameList:"item" type:"list"`
+
+	// The status of the volume.
+	Status *string `locationName:"status" type:"string" enum:"VolumeStatusInfoStatus"`
+
+	metadataVolumeStatusInfo `json:"-" xml:"-"`
+}
+
+type metadataVolumeStatusInfo struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s VolumeStatusInfo) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VolumeStatusInfo) GoString() string {
+	return s.String()
+}
+
+// Describes the volume status.
+type VolumeStatusItem struct {
+	// The details of the operation.
+	Actions []*VolumeStatusAction `locationName:"actionsSet" locationNameList:"item" type:"list"`
+
+	// The Availability Zone of the volume.
+	AvailabilityZone *string `locationName:"availabilityZone" type:"string"`
+
+	// A list of events associated with the volume.
+	Events []*VolumeStatusEvent `locationName:"eventsSet" locationNameList:"item" type:"list"`
+
+	// The volume ID.
+	VolumeID *string `locationName:"volumeId" type:"string"`
+
+	// The volume status.
+	VolumeStatus *VolumeStatusInfo `locationName:"volumeStatus" type:"structure"`
+
+	metadataVolumeStatusItem `json:"-" xml:"-"`
+}
+
+type metadataVolumeStatusItem struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// String returns the string representation
+func (s VolumeStatusItem) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VolumeStatusItem) GoString() string {
+	return s.String()
+}
+
+const (
+	// @enum AccountAttributeName
+	AccountAttributeNameSupportedPlatforms = "supported-platforms"
+	// @enum AccountAttributeName
+	AccountAttributeNameDefaultVpc = "default-vpc"
+)
+
+const (
+	// @enum ArchitectureValues
+	ArchitectureValuesI386 = "i386"
+	// @enum ArchitectureValues
+	ArchitectureValuesX8664 = "x86_64"
+)
+
+const (
+	// @enum AttachmentStatus
+	AttachmentStatusAttaching = "attaching"
+	// @enum AttachmentStatus
+	AttachmentStatusAttached = "attached"
+	// @enum AttachmentStatus
+	AttachmentStatusDetaching = "detaching"
+	// @enum AttachmentStatus
+	AttachmentStatusDetached = "detached"
+)
+
+const (
+	// @enum AvailabilityZoneState
+	AvailabilityZoneStateAvailable = "available"
+)
+
+const (
+	// @enum BatchState
+	BatchStateSubmitted = "submitted"
+	// @enum BatchState
+	BatchStateActive = "active"
+	// @enum BatchState
+	BatchStateCancelled = "cancelled"
+	// @enum BatchState
+	BatchStateFailed = "failed"
+	// @enum BatchState
+	BatchStateCancelledRunning = "cancelled_running"
+	// @enum BatchState
+	BatchStateCancelledTerminating = "cancelled_terminating"
+)
+
+const (
+	// @enum BundleTaskState
+	BundleTaskStatePending = "pending"
+	// @enum BundleTaskState
+	BundleTaskStateWaitingForShutdown = "waiting-for-shutdown"
+	// @enum BundleTaskState
+	BundleTaskStateBundling = "bundling"
+	// @enum BundleTaskState
+	BundleTaskStateStoring = "storing"
+	// @enum BundleTaskState
+	BundleTaskStateCancelling = "cancelling"
+	// @enum BundleTaskState
+	BundleTaskStateComplete = "complete"
+	// @enum BundleTaskState
+	BundleTaskStateFailed = "failed"
+)
+
+const (
+	// @enum CancelBatchErrorCode
+	CancelBatchErrorCodeFleetRequestIdDoesNotExist = "fleetRequestIdDoesNotExist"
+	// @enum CancelBatchErrorCode
+	CancelBatchErrorCodeFleetRequestIdMalformed = "fleetRequestIdMalformed"
+	// @enum CancelBatchErrorCode
+	CancelBatchErrorCodeFleetRequestNotInCancellableState = "fleetRequestNotInCancellableState"
+	// @enum CancelBatchErrorCode
+	CancelBatchErrorCodeUnexpectedError = "unexpectedError"
+)
+
+const (
+	// @enum CancelSpotInstanceRequestState
+	CancelSpotInstanceRequestStateActive = "active"
+	// @enum CancelSpotInstanceRequestState
+	CancelSpotInstanceRequestStateOpen = "open"
+	// @enum CancelSpotInstanceRequestState
+	CancelSpotInstanceRequestStateClosed = "closed"
+	// @enum CancelSpotInstanceRequestState
+	CancelSpotInstanceRequestStateCancelled = "cancelled"
+	// @enum CancelSpotInstanceRequestState
+	CancelSpotInstanceRequestStateCompleted = "completed"
+)
+
+const (
+	// @enum ContainerFormat
+	ContainerFormatOva = "ova"
+)
+
+const (
+	// @enum ConversionTaskState
+	ConversionTaskStateActive = "active"
+	// @enum ConversionTaskState
+	ConversionTaskStateCancelling = "cancelling"
+	// @enum ConversionTaskState
+	ConversionTaskStateCancelled = "cancelled"
+	// @enum ConversionTaskState
+	ConversionTaskStateCompleted = "completed"
+)
+
+const (
+	// @enum CurrencyCodeValues
+	CurrencyCodeValuesUsd = "USD"
+)
+
+const (
+	// @enum DatafeedSubscriptionState
+	DatafeedSubscriptionStateActive = "Active"
+	// @enum DatafeedSubscriptionState
+	DatafeedSubscriptionStateInactive = "Inactive"
+)
+
+const (
+	// @enum DeviceType
+	DeviceTypeEbs = "ebs"
+	// @enum DeviceType
+	DeviceTypeInstanceStore = "instance-store"
+)
+
+const (
+	// @enum DiskImageFormat
+	DiskImageFormatVmdk = "VMDK"
+	// @enum DiskImageFormat
+	DiskImageFormatRaw = "RAW"
+	// @enum DiskImageFormat
+	DiskImageFormatVhd = "VHD"
+)
+
+const (
+	// @enum DomainType
+	DomainTypeVpc = "vpc"
+	// @enum DomainType
+	DomainTypeStandard = "standard"
+)
+
+const (
+	// @enum EventCode
+	EventCodeInstanceReboot = "instance-reboot"
+	// @enum EventCode
+	EventCodeSystemReboot = "system-reboot"
+	// @enum EventCode
+	EventCodeSystemMaintenance = "system-maintenance"
+	// @enum EventCode
+	EventCodeInstanceRetirement = "instance-retirement"
+	// @enum EventCode
+	EventCodeInstanceStop = "instance-stop"
+)
+
+const (
+	// @enum EventType
+	EventTypeInstanceChange = "instanceChange"
+	// @enum EventType
+	EventTypeFleetRequestChange = "fleetRequestChange"
+	// @enum EventType
+	EventTypeError = "error"
+)
+
+const (
+	// @enum ExportEnvironment
+	ExportEnvironmentCitrix = "citrix"
+	// @enum ExportEnvironment
+	ExportEnvironmentVmware = "vmware"
+	// @enum ExportEnvironment
+	ExportEnvironmentMicrosoft = "microsoft"
+)
+
+const (
+	// @enum ExportTaskState
+	ExportTaskStateActive = "active"
+	// @enum ExportTaskState
+	ExportTaskStateCancelling = "cancelling"
+	// @enum ExportTaskState
+	ExportTaskStateCancelled = "cancelled"
+	// @enum ExportTaskState
+	ExportTaskStateCompleted = "completed"
+)
+
+const (
+	// @enum FlowLogsResourceType
+	FlowLogsResourceTypeVpc = "VPC"
+	// @enum FlowLogsResourceType
+	FlowLogsResourceTypeSubnet = "Subnet"
+	// @enum FlowLogsResourceType
+	FlowLogsResourceTypeNetworkInterface = "NetworkInterface"
+)
+
+const (
+	// @enum GatewayType
+	GatewayTypeIpsec1 = "ipsec.1"
+)
+
+const (
+	// @enum HypervisorType
+	HypervisorTypeOvm = "ovm"
+	// @enum HypervisorType
+	HypervisorTypeXen = "xen"
+)
+
+const (
+	// @enum ImageAttributeName
+	ImageAttributeNameDescription = "description"
+	// @enum ImageAttributeName
+	ImageAttributeNameKernel = "kernel"
+	// @enum ImageAttributeName
+	ImageAttributeNameRamdisk = "ramdisk"
+	// @enum ImageAttributeName
+	ImageAttributeNameLaunchPermission = "launchPermission"
+	// @enum ImageAttributeName
+	ImageAttributeNameProductCodes = "productCodes"
+	// @enum ImageAttributeName
+	ImageAttributeNameBlockDeviceMapping = "blockDeviceMapping"
+	// @enum ImageAttributeName
+	ImageAttributeNameSriovNetSupport = "sriovNetSupport"
+)
+
+const (
+	// @enum ImageState
+	ImageStatePending = "pending"
+	// @enum ImageState
+	ImageStateAvailable = "available"
+	// @enum ImageState
+	ImageStateInvalid = "invalid"
+	// @enum ImageState
+	ImageStateDeregistered = "deregistered"
+	// @enum ImageState
+	ImageStateTransient = "transient"
+	// @enum ImageState
+	ImageStateFailed = "failed"
+	// @enum ImageState
+	ImageStateError = "error"
+)
+
+const (
+	// @enum ImageTypeValues
+	ImageTypeValuesMachine = "machine"
+	// @enum ImageTypeValues
+	ImageTypeValuesKernel = "kernel"
+	// @enum ImageTypeValues
+	ImageTypeValuesRamdisk = "ramdisk"
+)
+
+const (
+	// @enum InstanceAttributeName
+	InstanceAttributeNameInstanceType = "instanceType"
+	// @enum InstanceAttributeName
+	InstanceAttributeNameKernel = "kernel"
+	// @enum InstanceAttributeName
+	InstanceAttributeNameRamdisk = "ramdisk"
+	// @enum InstanceAttributeName
+	InstanceAttributeNameUserData = "userData"
+	// @enum InstanceAttributeName
+	InstanceAttributeNameDisableApiTermination = "disableApiTermination"
+	// @enum InstanceAttributeName
+	InstanceAttributeNameInstanceInitiatedShutdownBehavior = "instanceInitiatedShutdownBehavior"
+	// @enum InstanceAttributeName
+	InstanceAttributeNameRootDeviceName = "rootDeviceName"
+	// @enum InstanceAttributeName
+	InstanceAttributeNameBlockDeviceMapping = "blockDeviceMapping"
+	// @enum InstanceAttributeName
+	InstanceAttributeNameProductCodes = "productCodes"
+	// @enum InstanceAttributeName
+	InstanceAttributeNameSourceDestCheck = "sourceDestCheck"
+	// @enum InstanceAttributeName
+	InstanceAttributeNameGroupSet = "groupSet"
+	// @enum InstanceAttributeName
+	InstanceAttributeNameEbsOptimized = "ebsOptimized"
+	// @enum InstanceAttributeName
+	InstanceAttributeNameSriovNetSupport = "sriovNetSupport"
+)
+
+const (
+	// @enum InstanceLifecycleType
+	InstanceLifecycleTypeSpot = "spot"
+)
+
+const (
+	// @enum InstanceStateName
+	InstanceStateNamePending = "pending"
+	// @enum InstanceStateName
+	InstanceStateNameRunning = "running"
+	// @enum InstanceStateName
+	InstanceStateNameShuttingDown = "shutting-down"
+	// @enum InstanceStateName
+	InstanceStateNameTerminated = "terminated"
+	// @enum InstanceStateName
+	InstanceStateNameStopping = "stopping"
+	// @enum InstanceStateName
+	InstanceStateNameStopped = "stopped"
+)
+
+const (
+	// @enum InstanceType
+	InstanceTypeT1Micro = "t1.micro"
+	// @enum InstanceType
+	InstanceTypeM1Small = "m1.small"
+	// @enum InstanceType
+	InstanceTypeM1Medium = "m1.medium"
+	// @enum InstanceType
+	InstanceTypeM1Large = "m1.large"
+	// @enum InstanceType
+	InstanceTypeM1Xlarge = "m1.xlarge"
+	// @enum InstanceType
+	InstanceTypeM3Medium = "m3.medium"
+	// @enum InstanceType
+	InstanceTypeM3Large = "m3.large"
+	// @enum InstanceType
+	InstanceTypeM3Xlarge = "m3.xlarge"
+	// @enum InstanceType
+	InstanceTypeM32xlarge = "m3.2xlarge"
+	// @enum InstanceType
+	InstanceTypeM4Large = "m4.large"
+	// @enum InstanceType
+	InstanceTypeM4Xlarge = "m4.xlarge"
+	// @enum InstanceType
+	InstanceTypeM42xlarge = "m4.2xlarge"
+	// @enum InstanceType
+	InstanceTypeM44xlarge = "m4.4xlarge"
+	// @enum InstanceType
+	InstanceTypeM410xlarge = "m4.10xlarge"
+	// @enum InstanceType
+	InstanceTypeT2Micro = "t2.micro"
+	// @enum InstanceType
+	InstanceTypeT2Small = "t2.small"
+	// @enum InstanceType
+	InstanceTypeT2Medium = "t2.medium"
+	// @enum InstanceType
+	InstanceTypeT2Large = "t2.large"
+	// @enum InstanceType
+	InstanceTypeM2Xlarge = "m2.xlarge"
+	// @enum InstanceType
+	InstanceTypeM22xlarge = "m2.2xlarge"
+	// @enum InstanceType
+	InstanceTypeM24xlarge = "m2.4xlarge"
+	// @enum InstanceType
+	InstanceTypeCr18xlarge = "cr1.8xlarge"
+	// @enum InstanceType
+	InstanceTypeI2Xlarge = "i2.xlarge"
+	// @enum InstanceType
+	InstanceTypeI22xlarge = "i2.2xlarge"
+	// @enum InstanceType
+	InstanceTypeI24xlarge = "i2.4xlarge"
+	// @enum InstanceType
+	InstanceTypeI28xlarge = "i2.8xlarge"
+	// @enum InstanceType
+	InstanceTypeHi14xlarge = "hi1.4xlarge"
+	// @enum InstanceType
+	InstanceTypeHs18xlarge = "hs1.8xlarge"
+	// @enum InstanceType
+	InstanceTypeC1Medium = "c1.medium"
+	// @enum InstanceType
+	InstanceTypeC1Xlarge = "c1.xlarge"
+	// @enum InstanceType
+	InstanceTypeC3Large = "c3.large"
+	// @enum InstanceType
+	InstanceTypeC3Xlarge = "c3.xlarge"
+	// @enum InstanceType
+	InstanceTypeC32xlarge = "c3.2xlarge"
+	// @enum InstanceType
+	InstanceTypeC34xlarge = "c3.4xlarge"
+	// @enum InstanceType
+	InstanceTypeC38xlarge = "c3.8xlarge"
+	// @enum InstanceType
+	InstanceTypeC4Large = "c4.large"
+	// @enum InstanceType
+	InstanceTypeC4Xlarge = "c4.xlarge"
+	// @enum InstanceType
+	InstanceTypeC42xlarge = "c4.2xlarge"
+	// @enum InstanceType
+	InstanceTypeC44xlarge = "c4.4xlarge"
+	// @enum InstanceType
+	InstanceTypeC48xlarge = "c4.8xlarge"
+	// @enum InstanceType
+	InstanceTypeCc14xlarge = "cc1.4xlarge"
+	// @enum InstanceType
+	InstanceTypeCc28xlarge = "cc2.8xlarge"
+	// @enum InstanceType
+	InstanceTypeG22xlarge = "g2.2xlarge"
+	// @enum InstanceType
+	InstanceTypeCg14xlarge = "cg1.4xlarge"
+	// @enum InstanceType
+	InstanceTypeR3Large = "r3.large"
+	// @enum InstanceType
+	InstanceTypeR3Xlarge = "r3.xlarge"
+	// @enum InstanceType
+	InstanceTypeR32xlarge = "r3.2xlarge"
+	// @enum InstanceType
+	InstanceTypeR34xlarge = "r3.4xlarge"
+	// @enum InstanceType
+	InstanceTypeR38xlarge = "r3.8xlarge"
+	// @enum InstanceType
+	InstanceTypeD2Xlarge = "d2.xlarge"
+	// @enum InstanceType
+	InstanceTypeD22xlarge = "d2.2xlarge"
+	// @enum InstanceType
+	InstanceTypeD24xlarge = "d2.4xlarge"
+	// @enum InstanceType
+	InstanceTypeD28xlarge = "d2.8xlarge"
+)
+
+const (
+	// @enum ListingState
+	ListingStateAvailable = "available"
+	// @enum ListingState
+	ListingStateSold = "sold"
+	// @enum ListingState
+	ListingStateCancelled = "cancelled"
+	// @enum ListingState
+	ListingStatePending = "pending"
+)
+
+const (
+	// @enum ListingStatus
+	ListingStatusActive = "active"
+	// @enum ListingStatus
+	ListingStatusPending = "pending"
+	// @enum ListingStatus
+	ListingStatusCancelled = "cancelled"
+	// @enum ListingStatus
+	ListingStatusClosed = "closed"
+)
+
+const (
+	// @enum MonitoringState
+	MonitoringStateDisabled = "disabled"
+	// @enum MonitoringState
+	MonitoringStateDisabling = "disabling"
+	// @enum MonitoringState
+	MonitoringStateEnabled = "enabled"
+	// @enum MonitoringState
+	MonitoringStatePending = "pending"
+)
+
+const (
+	// @enum MoveStatus
+	MoveStatusMovingToVpc = "movingToVpc"
+	// @enum MoveStatus
+	MoveStatusRestoringToClassic = "restoringToClassic"
+)
+
+const (
+	// @enum NetworkInterfaceAttribute
+	NetworkInterfaceAttributeDescription = "description"
+	// @enum NetworkInterfaceAttribute
+	NetworkInterfaceAttributeGroupSet = "groupSet"
+	// @enum NetworkInterfaceAttribute
+	NetworkInterfaceAttributeSourceDestCheck = "sourceDestCheck"
+	// @enum NetworkInterfaceAttribute
+	NetworkInterfaceAttributeAttachment = "attachment"
+)
+
+const (
+	// @enum NetworkInterfaceStatus
+	NetworkInterfaceStatusAvailable = "available"
+	// @enum NetworkInterfaceStatus
+	NetworkInterfaceStatusAttaching = "attaching"
+	// @enum NetworkInterfaceStatus
+	NetworkInterfaceStatusInUse = "in-use"
+	// @enum NetworkInterfaceStatus
+	NetworkInterfaceStatusDetaching = "detaching"
+)
+
+const (
+	// @enum OfferingTypeValues
+	OfferingTypeValuesHeavyUtilization = "Heavy Utilization"
+	// @enum OfferingTypeValues
+	OfferingTypeValuesMediumUtilization = "Medium Utilization"
+	// @enum OfferingTypeValues
+	OfferingTypeValuesLightUtilization = "Light Utilization"
+	// @enum OfferingTypeValues
+	OfferingTypeValuesNoUpfront = "No Upfront"
+	// @enum OfferingTypeValues
+	OfferingTypeValuesPartialUpfront = "Partial Upfront"
+	// @enum OfferingTypeValues
+	OfferingTypeValuesAllUpfront = "All Upfront"
+)
+
+const (
+	// @enum PermissionGroup
+	PermissionGroupAll = "all"
+)
+
+const (
+	// @enum PlacementGroupState
+	PlacementGroupStatePending = "pending"
+	// @enum PlacementGroupState
+	PlacementGroupStateAvailable = "available"
+	// @enum PlacementGroupState
+	PlacementGroupStateDeleting = "deleting"
+	// @enum PlacementGroupState
+	PlacementGroupStateDeleted = "deleted"
+)
+
+const (
+	// @enum PlacementStrategy
+	PlacementStrategyCluster = "cluster"
+)
+
+const (
+	// @enum PlatformValues
+	PlatformValuesWindows = "Windows"
+)
+
+const (
+	// @enum ProductCodeValues
+	ProductCodeValuesDevpay = "devpay"
+	// @enum ProductCodeValues
+	ProductCodeValuesMarketplace = "marketplace"
+)
+
+const (
+	// @enum RIProductDescription
+	RIProductDescriptionLinuxUnix = "Linux/UNIX"
+	// @enum RIProductDescription
+	RIProductDescriptionLinuxUnixamazonVpc = "Linux/UNIX (Amazon VPC)"
+	// @enum RIProductDescription
+	RIProductDescriptionWindows = "Windows"
+	// @enum RIProductDescription
+	RIProductDescriptionWindowsAmazonVpc = "Windows (Amazon VPC)"
+)
+
+const (
+	// @enum RecurringChargeFrequency
+	RecurringChargeFrequencyHourly = "Hourly"
+)
+
+const (
+	// @enum ReportInstanceReasonCodes
+	ReportInstanceReasonCodesInstanceStuckInState = "instance-stuck-in-state"
+	// @enum ReportInstanceReasonCodes
+	ReportInstanceReasonCodesUnresponsive = "unresponsive"
+	// @enum ReportInstanceReasonCodes
+	ReportInstanceReasonCodesNotAcceptingCredentials = "not-accepting-credentials"
+	// @enum ReportInstanceReasonCodes
+	ReportInstanceReasonCodesPasswordNotAvailable = "password-not-available"
+	// @enum ReportInstanceReasonCodes
+	ReportInstanceReasonCodesPerformanceNetwork = "performance-network"
+	// @enum ReportInstanceReasonCodes
+	ReportInstanceReasonCodesPerformanceInstanceStore = "performance-instance-store"
+	// @enum ReportInstanceReasonCodes
+	ReportInstanceReasonCodesPerformanceEbsVolume = "performance-ebs-volume"
+	// @enum ReportInstanceReasonCodes
+	ReportInstanceReasonCodesPerformanceOther = "performance-other"
+	// @enum ReportInstanceReasonCodes
+	ReportInstanceReasonCodesOther = "other"
+)
+
+const (
+	// @enum ReportStatusType
+	ReportStatusTypeOk = "ok"
+	// @enum ReportStatusType
+	ReportStatusTypeImpaired = "impaired"
+)
+
+const (
+	// @enum ReservedInstanceState
+	ReservedInstanceStatePaymentPending = "payment-pending"
+	// @enum ReservedInstanceState
+	ReservedInstanceStateActive = "active"
+	// @enum ReservedInstanceState
+	ReservedInstanceStatePaymentFailed = "payment-failed"
+	// @enum ReservedInstanceState
+	ReservedInstanceStateRetired = "retired"
+)
+
+const (
+	// @enum ResetImageAttributeName
+	ResetImageAttributeNameLaunchPermission = "launchPermission"
+)
+
+const (
+	// @enum ResourceType
+	ResourceTypeCustomerGateway = "customer-gateway"
+	// @enum ResourceType
+	ResourceTypeDhcpOptions = "dhcp-options"
+	// @enum ResourceType
+	ResourceTypeImage = "image"
+	// @enum ResourceType
+	ResourceTypeInstance = "instance"
+	// @enum ResourceType
+	ResourceTypeInternetGateway = "internet-gateway"
+	// @enum ResourceType
+	ResourceTypeNetworkAcl = "network-acl"
+	// @enum ResourceType
+	ResourceTypeNetworkInterface = "network-interface"
+	// @enum ResourceType
+	ResourceTypeReservedInstances = "reserved-instances"
+	// @enum ResourceType
+	ResourceTypeRouteTable = "route-table"
+	// @enum ResourceType
+	ResourceTypeSnapshot = "snapshot"
+	// @enum ResourceType
+	ResourceTypeSpotInstancesRequest = "spot-instances-request"
+	// @enum ResourceType
+	ResourceTypeSubnet = "subnet"
+	// @enum ResourceType
+	ResourceTypeSecurityGroup = "security-group"
+	// @enum ResourceType
+	ResourceTypeVolume = "volume"
+	// @enum ResourceType
+	ResourceTypeVpc = "vpc"
+	// @enum ResourceType
+	ResourceTypeVpnConnection = "vpn-connection"
+	// @enum ResourceType
+	ResourceTypeVpnGateway = "vpn-gateway"
+)
+
+const (
+	// @enum RouteOrigin
+	RouteOriginCreateRouteTable = "CreateRouteTable"
+	// @enum RouteOrigin
+	RouteOriginCreateRoute = "CreateRoute"
+	// @enum RouteOrigin
+	RouteOriginEnableVgwRoutePropagation = "EnableVgwRoutePropagation"
+)
+
+const (
+	// @enum RouteState
+	RouteStateActive = "active"
+	// @enum RouteState
+	RouteStateBlackhole = "blackhole"
+)
+
+const (
+	// @enum RuleAction
+	RuleActionAllow = "allow"
+	// @enum RuleAction
+	RuleActionDeny = "deny"
+)
+
+const (
+	// @enum ShutdownBehavior
+	ShutdownBehaviorStop = "stop"
+	// @enum ShutdownBehavior
+	ShutdownBehaviorTerminate = "terminate"
+)
+
+const (
+	// @enum SnapshotAttributeName
+	SnapshotAttributeNameProductCodes = "productCodes"
+	// @enum SnapshotAttributeName
+	SnapshotAttributeNameCreateVolumePermission = "createVolumePermission"
+)
+
+const (
+	// @enum SnapshotState
+	SnapshotStatePending = "pending"
+	// @enum SnapshotState
+	SnapshotStateCompleted = "completed"
+	// @enum SnapshotState
+	SnapshotStateError = "error"
+)
+
+const (
+	// @enum SpotInstanceState
+	SpotInstanceStateOpen = "open"
+	// @enum SpotInstanceState
+	SpotInstanceStateActive = "active"
+	// @enum SpotInstanceState
+	SpotInstanceStateClosed = "closed"
+	// @enum SpotInstanceState
+	SpotInstanceStateCancelled = "cancelled"
+	// @enum SpotInstanceState
+	SpotInstanceStateFailed = "failed"
+)
+
+const (
+	// @enum SpotInstanceType
+	SpotInstanceTypeOneTime = "one-time"
+	// @enum SpotInstanceType
+	SpotInstanceTypePersistent = "persistent"
+)
+
+const (
+	// @enum State
+	StatePending = "Pending"
+	// @enum State
+	StateAvailable = "Available"
+	// @enum State
+	StateDeleting = "Deleting"
+	// @enum State
+	StateDeleted = "Deleted"
+)
+
+const (
+	// @enum Status
+	StatusMoveInProgress = "MoveInProgress"
+	// @enum Status
+	StatusInVpc = "InVpc"
+	// @enum Status
+	StatusInClassic = "InClassic"
+)
+
+const (
+	// @enum StatusName
+	StatusNameReachability = "reachability"
+)
+
+const (
+	// @enum StatusType
+	StatusTypePassed = "passed"
+	// @enum StatusType
+	StatusTypeFailed = "failed"
+	// @enum StatusType
+	StatusTypeInsufficientData = "insufficient-data"
+	// @enum StatusType
+	StatusTypeInitializing = "initializing"
+)
+
+const (
+	// @enum SubnetState
+	SubnetStatePending = "pending"
+	// @enum SubnetState
+	SubnetStateAvailable = "available"
+)
+
+const (
+	// @enum SummaryStatus
+	SummaryStatusOk = "ok"
+	// @enum SummaryStatus
+	SummaryStatusImpaired = "impaired"
+	// @enum SummaryStatus
+	SummaryStatusInsufficientData = "insufficient-data"
+	// @enum SummaryStatus
+	SummaryStatusNotApplicable = "not-applicable"
+	// @enum SummaryStatus
+	SummaryStatusInitializing = "initializing"
+)
+
+const (
+	// @enum TelemetryStatus
+	TelemetryStatusUp = "UP"
+	// @enum TelemetryStatus
+	TelemetryStatusDown = "DOWN"
+)
+
+const (
+	// @enum Tenancy
+	TenancyDefault = "default"
+	// @enum Tenancy
+	TenancyDedicated = "dedicated"
+)
+
+const (
+	// @enum TrafficType
+	TrafficTypeAccept = "ACCEPT"
+	// @enum TrafficType
+	TrafficTypeReject = "REJECT"
+	// @enum TrafficType
+	TrafficTypeAll = "ALL"
+)
+
+const (
+	// @enum VirtualizationType
+	VirtualizationTypeHvm = "hvm"
+	// @enum VirtualizationType
+	VirtualizationTypeParavirtual = "paravirtual"
+)
+
+const (
+	// @enum VolumeAttachmentState
+	VolumeAttachmentStateAttaching = "attaching"
+	// @enum VolumeAttachmentState
+	VolumeAttachmentStateAttached = "attached"
+	// @enum VolumeAttachmentState
+	VolumeAttachmentStateDetaching = "detaching"
+	// @enum VolumeAttachmentState
+	VolumeAttachmentStateDetached = "detached"
+)
+
+const (
+	// @enum VolumeAttributeName
+	VolumeAttributeNameAutoEnableIo = "autoEnableIO"
+	// @enum VolumeAttributeName
+	VolumeAttributeNameProductCodes = "productCodes"
+)
+
+const (
+	// @enum VolumeState
+	VolumeStateCreating = "creating"
+	// @enum VolumeState
+	VolumeStateAvailable = "available"
+	// @enum VolumeState
+	VolumeStateInUse = "in-use"
+	// @enum VolumeState
+	VolumeStateDeleting = "deleting"
+	// @enum VolumeState
+	VolumeStateDeleted = "deleted"
+	// @enum VolumeState
+	VolumeStateError = "error"
+)
+
+const (
+	// @enum VolumeStatusInfoStatus
+	VolumeStatusInfoStatusOk = "ok"
+	// @enum VolumeStatusInfoStatus
+	VolumeStatusInfoStatusImpaired = "impaired"
+	// @enum VolumeStatusInfoStatus
+	VolumeStatusInfoStatusInsufficientData = "insufficient-data"
+)
+
+const (
+	// @enum VolumeStatusName
+	VolumeStatusNameIoEnabled = "io-enabled"
+	// @enum VolumeStatusName
+	VolumeStatusNameIoPerformance = "io-performance"
+)
+
+const (
+	// @enum VolumeType
+	VolumeTypeStandard = "standard"
+	// @enum VolumeType
+	VolumeTypeIo1 = "io1"
+	// @enum VolumeType
+	VolumeTypeGp2 = "gp2"
+)
+
+const (
+	// @enum VpcAttributeName
+	VpcAttributeNameEnableDnsSupport = "enableDnsSupport"
+	// @enum VpcAttributeName
+	VpcAttributeNameEnableDnsHostnames = "enableDnsHostnames"
+)
+
+const (
+	// @enum VpcPeeringConnectionStateReasonCode
+	VpcPeeringConnectionStateReasonCodeInitiatingRequest = "initiating-request"
+	// @enum VpcPeeringConnectionStateReasonCode
+	VpcPeeringConnectionStateReasonCodePendingAcceptance = "pending-acceptance"
+	// @enum VpcPeeringConnectionStateReasonCode
+	VpcPeeringConnectionStateReasonCodeActive = "active"
+	// @enum VpcPeeringConnectionStateReasonCode
+	VpcPeeringConnectionStateReasonCodeDeleted = "deleted"
+	// @enum VpcPeeringConnectionStateReasonCode
+	VpcPeeringConnectionStateReasonCodeRejected = "rejected"
+	// @enum VpcPeeringConnectionStateReasonCode
+	VpcPeeringConnectionStateReasonCodeFailed = "failed"
+	// @enum VpcPeeringConnectionStateReasonCode
+	VpcPeeringConnectionStateReasonCodeExpired = "expired"
+	// @enum VpcPeeringConnectionStateReasonCode
+	VpcPeeringConnectionStateReasonCodeProvisioning = "provisioning"
+	// @enum VpcPeeringConnectionStateReasonCode
+	VpcPeeringConnectionStateReasonCodeDeleting = "deleting"
+)
+
+const (
+	// @enum VpcState
+	VpcStatePending = "pending"
+	// @enum VpcState
+	VpcStateAvailable = "available"
+)
+
+const (
+	// @enum VpnState
+	VpnStatePending = "pending"
+	// @enum VpnState
+	VpnStateAvailable = "available"
+	// @enum VpnState
+	VpnStateDeleting = "deleting"
+	// @enum VpnState
+	VpnStateDeleted = "deleted"
+)
+
+const (
+	// @enum VpnStaticRouteSource
+	VpnStaticRouteSourceStatic = "Static"
+)

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/ec2/customizations.go

@@ -0,0 +1,57 @@
+package ec2
+
+import (
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awsutil"
+)
+
+func init() {
+	initRequest = func(r *aws.Request) {
+		if r.Operation.Name == opCopySnapshot { // fill the PresignedURL parameter
+			r.Handlers.Build.PushFront(fillPresignedURL)
+		}
+	}
+}
+
+func fillPresignedURL(r *aws.Request) {
+	if !r.ParamsFilled() {
+		return
+	}
+
+	params := r.Params.(*CopySnapshotInput)
+
+	// Stop if PresignedURL/DestinationRegion is set
+	if params.PresignedURL != nil || params.DestinationRegion != nil {
+		return
+	}
+
+	// First generate a copy of parameters
+	r.Params = awsutil.CopyOf(r.Params)
+	params = r.Params.(*CopySnapshotInput)
+
+	// Set destination region. Avoids infinite handler loop.
+	// Also needed to sign sub-request.
+	params.DestinationRegion = r.Service.Config.Region
+
+	// Create a new client pointing at source region.
+	// We will use this to presign the CopySnapshot request against
+	// the source region
+	config := r.Service.Config.Copy().
+		WithEndpoint("").
+		WithRegion(*params.SourceRegion)
+
+	client := New(config)
+
+	// Presign a CopySnapshot request with modified params
+	req, _ := client.CopySnapshotRequest(params)
+	url, err := req.Presign(300 * time.Second) // 5 minutes should be enough.
+
+	if err != nil { // bubble error back up to original request
+		r.Error = err
+	}
+
+	// We have our URL, set it on params
+	params.PresignedURL = &url
+}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/ec2/customizations_test.go

@@ -0,0 +1,36 @@
+package ec2_test
+
+import (
+	"io/ioutil"
+	"net/url"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/internal/test/unit"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/stretchr/testify/assert"
+)
+
+var _ = unit.Imported
+
+func TestCopySnapshotPresignedURL(t *testing.T) {
+	svc := ec2.New(&aws.Config{Region: aws.String("us-west-2")})
+
+	assert.NotPanics(t, func() {
+		// Doesn't panic on nil input
+		req, _ := svc.CopySnapshotRequest(nil)
+		req.Sign()
+	})
+
+	req, _ := svc.CopySnapshotRequest(&ec2.CopySnapshotInput{
+		SourceRegion:     aws.String("us-west-1"),
+		SourceSnapshotID: aws.String("snap-id"),
+	})
+	req.Sign()
+
+	b, _ := ioutil.ReadAll(req.HTTPRequest.Body)
+	q, _ := url.ParseQuery(string(b))
+	url, _ := url.QueryUnescape(q.Get("PresignedUrl"))
+	assert.Equal(t, "us-west-2", q.Get("DestinationRegion"))
+	assert.Regexp(t, `^https://ec2\.us-west-1\.amazon.+&DestinationRegion=us-west-2`, url)
+}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/ec2/ec2iface/interface.go

@@ -0,0 +1,756 @@
+// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
+
+// Package ec2iface provides an interface for the Amazon Elastic Compute Cloud.
+package ec2iface
+
+import (
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+)
+
+// EC2API is the interface type for ec2.EC2.
+type EC2API interface {
+	AcceptVPCPeeringConnectionRequest(*ec2.AcceptVPCPeeringConnectionInput) (*aws.Request, *ec2.AcceptVPCPeeringConnectionOutput)
+
+	AcceptVPCPeeringConnection(*ec2.AcceptVPCPeeringConnectionInput) (*ec2.AcceptVPCPeeringConnectionOutput, error)
+
+	AllocateAddressRequest(*ec2.AllocateAddressInput) (*aws.Request, *ec2.AllocateAddressOutput)
+
+	AllocateAddress(*ec2.AllocateAddressInput) (*ec2.AllocateAddressOutput, error)
+
+	AssignPrivateIPAddressesRequest(*ec2.AssignPrivateIPAddressesInput) (*aws.Request, *ec2.AssignPrivateIPAddressesOutput)
+
+	AssignPrivateIPAddresses(*ec2.AssignPrivateIPAddressesInput) (*ec2.AssignPrivateIPAddressesOutput, error)
+
+	AssociateAddressRequest(*ec2.AssociateAddressInput) (*aws.Request, *ec2.AssociateAddressOutput)
+
+	AssociateAddress(*ec2.AssociateAddressInput) (*ec2.AssociateAddressOutput, error)
+
+	AssociateDHCPOptionsRequest(*ec2.AssociateDHCPOptionsInput) (*aws.Request, *ec2.AssociateDHCPOptionsOutput)
+
+	AssociateDHCPOptions(*ec2.AssociateDHCPOptionsInput) (*ec2.AssociateDHCPOptionsOutput, error)
+
+	AssociateRouteTableRequest(*ec2.AssociateRouteTableInput) (*aws.Request, *ec2.AssociateRouteTableOutput)
+
+	AssociateRouteTable(*ec2.AssociateRouteTableInput) (*ec2.AssociateRouteTableOutput, error)
+
+	AttachClassicLinkVPCRequest(*ec2.AttachClassicLinkVPCInput) (*aws.Request, *ec2.AttachClassicLinkVPCOutput)
+
+	AttachClassicLinkVPC(*ec2.AttachClassicLinkVPCInput) (*ec2.AttachClassicLinkVPCOutput, error)
+
+	AttachInternetGatewayRequest(*ec2.AttachInternetGatewayInput) (*aws.Request, *ec2.AttachInternetGatewayOutput)
+
+	AttachInternetGateway(*ec2.AttachInternetGatewayInput) (*ec2.AttachInternetGatewayOutput, error)
+
+	AttachNetworkInterfaceRequest(*ec2.AttachNetworkInterfaceInput) (*aws.Request, *ec2.AttachNetworkInterfaceOutput)
+
+	AttachNetworkInterface(*ec2.AttachNetworkInterfaceInput) (*ec2.AttachNetworkInterfaceOutput, error)
+
+	AttachVPNGatewayRequest(*ec2.AttachVPNGatewayInput) (*aws.Request, *ec2.AttachVPNGatewayOutput)
+
+	AttachVPNGateway(*ec2.AttachVPNGatewayInput) (*ec2.AttachVPNGatewayOutput, error)
+
+	AttachVolumeRequest(*ec2.AttachVolumeInput) (*aws.Request, *ec2.VolumeAttachment)
+
+	AttachVolume(*ec2.AttachVolumeInput) (*ec2.VolumeAttachment, error)
+
+	AuthorizeSecurityGroupEgressRequest(*ec2.AuthorizeSecurityGroupEgressInput) (*aws.Request, *ec2.AuthorizeSecurityGroupEgressOutput)
+
+	AuthorizeSecurityGroupEgress(*ec2.AuthorizeSecurityGroupEgressInput) (*ec2.AuthorizeSecurityGroupEgressOutput, error)
+
+	AuthorizeSecurityGroupIngressRequest(*ec2.AuthorizeSecurityGroupIngressInput) (*aws.Request, *ec2.AuthorizeSecurityGroupIngressOutput)
+
+	AuthorizeSecurityGroupIngress(*ec2.AuthorizeSecurityGroupIngressInput) (*ec2.AuthorizeSecurityGroupIngressOutput, error)
+
+	BundleInstanceRequest(*ec2.BundleInstanceInput) (*aws.Request, *ec2.BundleInstanceOutput)
+
+	BundleInstance(*ec2.BundleInstanceInput) (*ec2.BundleInstanceOutput, error)
+
+	CancelBundleTaskRequest(*ec2.CancelBundleTaskInput) (*aws.Request, *ec2.CancelBundleTaskOutput)
+
+	CancelBundleTask(*ec2.CancelBundleTaskInput) (*ec2.CancelBundleTaskOutput, error)
+
+	CancelConversionTaskRequest(*ec2.CancelConversionTaskInput) (*aws.Request, *ec2.CancelConversionTaskOutput)
+
+	CancelConversionTask(*ec2.CancelConversionTaskInput) (*ec2.CancelConversionTaskOutput, error)
+
+	CancelExportTaskRequest(*ec2.CancelExportTaskInput) (*aws.Request, *ec2.CancelExportTaskOutput)
+
+	CancelExportTask(*ec2.CancelExportTaskInput) (*ec2.CancelExportTaskOutput, error)
+
+	CancelImportTaskRequest(*ec2.CancelImportTaskInput) (*aws.Request, *ec2.CancelImportTaskOutput)
+
+	CancelImportTask(*ec2.CancelImportTaskInput) (*ec2.CancelImportTaskOutput, error)
+
+	CancelReservedInstancesListingRequest(*ec2.CancelReservedInstancesListingInput) (*aws.Request, *ec2.CancelReservedInstancesListingOutput)
+
+	CancelReservedInstancesListing(*ec2.CancelReservedInstancesListingInput) (*ec2.CancelReservedInstancesListingOutput, error)
+
+	CancelSpotFleetRequestsRequest(*ec2.CancelSpotFleetRequestsInput) (*aws.Request, *ec2.CancelSpotFleetRequestsOutput)
+
+	CancelSpotFleetRequests(*ec2.CancelSpotFleetRequestsInput) (*ec2.CancelSpotFleetRequestsOutput, error)
+
+	CancelSpotInstanceRequestsRequest(*ec2.CancelSpotInstanceRequestsInput) (*aws.Request, *ec2.CancelSpotInstanceRequestsOutput)
+
+	CancelSpotInstanceRequests(*ec2.CancelSpotInstanceRequestsInput) (*ec2.CancelSpotInstanceRequestsOutput, error)
+
+	ConfirmProductInstanceRequest(*ec2.ConfirmProductInstanceInput) (*aws.Request, *ec2.ConfirmProductInstanceOutput)
+
+	ConfirmProductInstance(*ec2.ConfirmProductInstanceInput) (*ec2.ConfirmProductInstanceOutput, error)
+
+	CopyImageRequest(*ec2.CopyImageInput) (*aws.Request, *ec2.CopyImageOutput)
+
+	CopyImage(*ec2.CopyImageInput) (*ec2.CopyImageOutput, error)
+
+	CopySnapshotRequest(*ec2.CopySnapshotInput) (*aws.Request, *ec2.CopySnapshotOutput)
+
+	CopySnapshot(*ec2.CopySnapshotInput) (*ec2.CopySnapshotOutput, error)
+
+	CreateCustomerGatewayRequest(*ec2.CreateCustomerGatewayInput) (*aws.Request, *ec2.CreateCustomerGatewayOutput)
+
+	CreateCustomerGateway(*ec2.CreateCustomerGatewayInput) (*ec2.CreateCustomerGatewayOutput, error)
+
+	CreateDHCPOptionsRequest(*ec2.CreateDHCPOptionsInput) (*aws.Request, *ec2.CreateDHCPOptionsOutput)
+
+	CreateDHCPOptions(*ec2.CreateDHCPOptionsInput) (*ec2.CreateDHCPOptionsOutput, error)
+
+	CreateFlowLogsRequest(*ec2.CreateFlowLogsInput) (*aws.Request, *ec2.CreateFlowLogsOutput)
+
+	CreateFlowLogs(*ec2.CreateFlowLogsInput) (*ec2.CreateFlowLogsOutput, error)
+
+	CreateImageRequest(*ec2.CreateImageInput) (*aws.Request, *ec2.CreateImageOutput)
+
+	CreateImage(*ec2.CreateImageInput) (*ec2.CreateImageOutput, error)
+
+	CreateInstanceExportTaskRequest(*ec2.CreateInstanceExportTaskInput) (*aws.Request, *ec2.CreateInstanceExportTaskOutput)
+
+	CreateInstanceExportTask(*ec2.CreateInstanceExportTaskInput) (*ec2.CreateInstanceExportTaskOutput, error)
+
+	CreateInternetGatewayRequest(*ec2.CreateInternetGatewayInput) (*aws.Request, *ec2.CreateInternetGatewayOutput)
+
+	CreateInternetGateway(*ec2.CreateInternetGatewayInput) (*ec2.CreateInternetGatewayOutput, error)
+
+	CreateKeyPairRequest(*ec2.CreateKeyPairInput) (*aws.Request, *ec2.CreateKeyPairOutput)
+
+	CreateKeyPair(*ec2.CreateKeyPairInput) (*ec2.CreateKeyPairOutput, error)
+
+	CreateNetworkACLRequest(*ec2.CreateNetworkACLInput) (*aws.Request, *ec2.CreateNetworkACLOutput)
+
+	CreateNetworkACL(*ec2.CreateNetworkACLInput) (*ec2.CreateNetworkACLOutput, error)
+
+	CreateNetworkACLEntryRequest(*ec2.CreateNetworkACLEntryInput) (*aws.Request, *ec2.CreateNetworkACLEntryOutput)
+
+	CreateNetworkACLEntry(*ec2.CreateNetworkACLEntryInput) (*ec2.CreateNetworkACLEntryOutput, error)
+
+	CreateNetworkInterfaceRequest(*ec2.CreateNetworkInterfaceInput) (*aws.Request, *ec2.CreateNetworkInterfaceOutput)
+
+	CreateNetworkInterface(*ec2.CreateNetworkInterfaceInput) (*ec2.CreateNetworkInterfaceOutput, error)
+
+	CreatePlacementGroupRequest(*ec2.CreatePlacementGroupInput) (*aws.Request, *ec2.CreatePlacementGroupOutput)
+
+	CreatePlacementGroup(*ec2.CreatePlacementGroupInput) (*ec2.CreatePlacementGroupOutput, error)
+
+	CreateReservedInstancesListingRequest(*ec2.CreateReservedInstancesListingInput) (*aws.Request, *ec2.CreateReservedInstancesListingOutput)
+
+	CreateReservedInstancesListing(*ec2.CreateReservedInstancesListingInput) (*ec2.CreateReservedInstancesListingOutput, error)
+
+	CreateRouteRequest(*ec2.CreateRouteInput) (*aws.Request, *ec2.CreateRouteOutput)
+
+	CreateRoute(*ec2.CreateRouteInput) (*ec2.CreateRouteOutput, error)
+
+	CreateRouteTableRequest(*ec2.CreateRouteTableInput) (*aws.Request, *ec2.CreateRouteTableOutput)
+
+	CreateRouteTable(*ec2.CreateRouteTableInput) (*ec2.CreateRouteTableOutput, error)
+
+	CreateSecurityGroupRequest(*ec2.CreateSecurityGroupInput) (*aws.Request, *ec2.CreateSecurityGroupOutput)
+
+	CreateSecurityGroup(*ec2.CreateSecurityGroupInput) (*ec2.CreateSecurityGroupOutput, error)
+
+	CreateSnapshotRequest(*ec2.CreateSnapshotInput) (*aws.Request, *ec2.Snapshot)
+
+	CreateSnapshot(*ec2.CreateSnapshotInput) (*ec2.Snapshot, error)
+
+	CreateSpotDatafeedSubscriptionRequest(*ec2.CreateSpotDatafeedSubscriptionInput) (*aws.Request, *ec2.CreateSpotDatafeedSubscriptionOutput)
+
+	CreateSpotDatafeedSubscription(*ec2.CreateSpotDatafeedSubscriptionInput) (*ec2.CreateSpotDatafeedSubscriptionOutput, error)
+
+	CreateSubnetRequest(*ec2.CreateSubnetInput) (*aws.Request, *ec2.CreateSubnetOutput)
+
+	CreateSubnet(*ec2.CreateSubnetInput) (*ec2.CreateSubnetOutput, error)
+
+	CreateTagsRequest(*ec2.CreateTagsInput) (*aws.Request, *ec2.CreateTagsOutput)
+
+	CreateTags(*ec2.CreateTagsInput) (*ec2.CreateTagsOutput, error)
+
+	CreateVPCRequest(*ec2.CreateVPCInput) (*aws.Request, *ec2.CreateVPCOutput)
+
+	CreateVPC(*ec2.CreateVPCInput) (*ec2.CreateVPCOutput, error)
+
+	CreateVPCEndpointRequest(*ec2.CreateVPCEndpointInput) (*aws.Request, *ec2.CreateVPCEndpointOutput)
+
+	CreateVPCEndpoint(*ec2.CreateVPCEndpointInput) (*ec2.CreateVPCEndpointOutput, error)
+
+	CreateVPCPeeringConnectionRequest(*ec2.CreateVPCPeeringConnectionInput) (*aws.Request, *ec2.CreateVPCPeeringConnectionOutput)
+
+	CreateVPCPeeringConnection(*ec2.CreateVPCPeeringConnectionInput) (*ec2.CreateVPCPeeringConnectionOutput, error)
+
+	CreateVPNConnectionRequest(*ec2.CreateVPNConnectionInput) (*aws.Request, *ec2.CreateVPNConnectionOutput)
+
+	CreateVPNConnection(*ec2.CreateVPNConnectionInput) (*ec2.CreateVPNConnectionOutput, error)
+
+	CreateVPNConnectionRouteRequest(*ec2.CreateVPNConnectionRouteInput) (*aws.Request, *ec2.CreateVPNConnectionRouteOutput)
+
+	CreateVPNConnectionRoute(*ec2.CreateVPNConnectionRouteInput) (*ec2.CreateVPNConnectionRouteOutput, error)
+
+	CreateVPNGatewayRequest(*ec2.CreateVPNGatewayInput) (*aws.Request, *ec2.CreateVPNGatewayOutput)
+
+	CreateVPNGateway(*ec2.CreateVPNGatewayInput) (*ec2.CreateVPNGatewayOutput, error)
+
+	CreateVolumeRequest(*ec2.CreateVolumeInput) (*aws.Request, *ec2.Volume)
+
+	CreateVolume(*ec2.CreateVolumeInput) (*ec2.Volume, error)
+
+	DeleteCustomerGatewayRequest(*ec2.DeleteCustomerGatewayInput) (*aws.Request, *ec2.DeleteCustomerGatewayOutput)
+
+	DeleteCustomerGateway(*ec2.DeleteCustomerGatewayInput) (*ec2.DeleteCustomerGatewayOutput, error)
+
+	DeleteDHCPOptionsRequest(*ec2.DeleteDHCPOptionsInput) (*aws.Request, *ec2.DeleteDHCPOptionsOutput)
+
+	DeleteDHCPOptions(*ec2.DeleteDHCPOptionsInput) (*ec2.DeleteDHCPOptionsOutput, error)
+
+	DeleteFlowLogsRequest(*ec2.DeleteFlowLogsInput) (*aws.Request, *ec2.DeleteFlowLogsOutput)
+
+	DeleteFlowLogs(*ec2.DeleteFlowLogsInput) (*ec2.DeleteFlowLogsOutput, error)
+
+	DeleteInternetGatewayRequest(*ec2.DeleteInternetGatewayInput) (*aws.Request, *ec2.DeleteInternetGatewayOutput)
+
+	DeleteInternetGateway(*ec2.DeleteInternetGatewayInput) (*ec2.DeleteInternetGatewayOutput, error)
+
+	DeleteKeyPairRequest(*ec2.DeleteKeyPairInput) (*aws.Request, *ec2.DeleteKeyPairOutput)
+
+	DeleteKeyPair(*ec2.DeleteKeyPairInput) (*ec2.DeleteKeyPairOutput, error)
+
+	DeleteNetworkACLRequest(*ec2.DeleteNetworkACLInput) (*aws.Request, *ec2.DeleteNetworkACLOutput)
+
+	DeleteNetworkACL(*ec2.DeleteNetworkACLInput) (*ec2.DeleteNetworkACLOutput, error)
+
+	DeleteNetworkACLEntryRequest(*ec2.DeleteNetworkACLEntryInput) (*aws.Request, *ec2.DeleteNetworkACLEntryOutput)
+
+	DeleteNetworkACLEntry(*ec2.DeleteNetworkACLEntryInput) (*ec2.DeleteNetworkACLEntryOutput, error)
+
+	DeleteNetworkInterfaceRequest(*ec2.DeleteNetworkInterfaceInput) (*aws.Request, *ec2.DeleteNetworkInterfaceOutput)
+
+	DeleteNetworkInterface(*ec2.DeleteNetworkInterfaceInput) (*ec2.DeleteNetworkInterfaceOutput, error)
+
+	DeletePlacementGroupRequest(*ec2.DeletePlacementGroupInput) (*aws.Request, *ec2.DeletePlacementGroupOutput)
+
+	DeletePlacementGroup(*ec2.DeletePlacementGroupInput) (*ec2.DeletePlacementGroupOutput, error)
+
+	DeleteRouteRequest(*ec2.DeleteRouteInput) (*aws.Request, *ec2.DeleteRouteOutput)
+
+	DeleteRoute(*ec2.DeleteRouteInput) (*ec2.DeleteRouteOutput, error)
+
+	DeleteRouteTableRequest(*ec2.DeleteRouteTableInput) (*aws.Request, *ec2.DeleteRouteTableOutput)
+
+	DeleteRouteTable(*ec2.DeleteRouteTableInput) (*ec2.DeleteRouteTableOutput, error)
+
+	DeleteSecurityGroupRequest(*ec2.DeleteSecurityGroupInput) (*aws.Request, *ec2.DeleteSecurityGroupOutput)
+
+	DeleteSecurityGroup(*ec2.DeleteSecurityGroupInput) (*ec2.DeleteSecurityGroupOutput, error)
+
+	DeleteSnapshotRequest(*ec2.DeleteSnapshotInput) (*aws.Request, *ec2.DeleteSnapshotOutput)
+
+	DeleteSnapshot(*ec2.DeleteSnapshotInput) (*ec2.DeleteSnapshotOutput, error)
+
+	DeleteSpotDatafeedSubscriptionRequest(*ec2.DeleteSpotDatafeedSubscriptionInput) (*aws.Request, *ec2.DeleteSpotDatafeedSubscriptionOutput)
+
+	DeleteSpotDatafeedSubscription(*ec2.DeleteSpotDatafeedSubscriptionInput) (*ec2.DeleteSpotDatafeedSubscriptionOutput, error)
+
+	DeleteSubnetRequest(*ec2.DeleteSubnetInput) (*aws.Request, *ec2.DeleteSubnetOutput)
+
+	DeleteSubnet(*ec2.DeleteSubnetInput) (*ec2.DeleteSubnetOutput, error)
+
+	DeleteTagsRequest(*ec2.DeleteTagsInput) (*aws.Request, *ec2.DeleteTagsOutput)
+
+	DeleteTags(*ec2.DeleteTagsInput) (*ec2.DeleteTagsOutput, error)
+
+	DeleteVPCRequest(*ec2.DeleteVPCInput) (*aws.Request, *ec2.DeleteVPCOutput)
+
+	DeleteVPC(*ec2.DeleteVPCInput) (*ec2.DeleteVPCOutput, error)
+
+	DeleteVPCEndpointsRequest(*ec2.DeleteVPCEndpointsInput) (*aws.Request, *ec2.DeleteVPCEndpointsOutput)
+
+	DeleteVPCEndpoints(*ec2.DeleteVPCEndpointsInput) (*ec2.DeleteVPCEndpointsOutput, error)
+
+	DeleteVPCPeeringConnectionRequest(*ec2.DeleteVPCPeeringConnectionInput) (*aws.Request, *ec2.DeleteVPCPeeringConnectionOutput)
+
+	DeleteVPCPeeringConnection(*ec2.DeleteVPCPeeringConnectionInput) (*ec2.DeleteVPCPeeringConnectionOutput, error)
+
+	DeleteVPNConnectionRequest(*ec2.DeleteVPNConnectionInput) (*aws.Request, *ec2.DeleteVPNConnectionOutput)
+
+	DeleteVPNConnection(*ec2.DeleteVPNConnectionInput) (*ec2.DeleteVPNConnectionOutput, error)
+
+	DeleteVPNConnectionRouteRequest(*ec2.DeleteVPNConnectionRouteInput) (*aws.Request, *ec2.DeleteVPNConnectionRouteOutput)
+
+	DeleteVPNConnectionRoute(*ec2.DeleteVPNConnectionRouteInput) (*ec2.DeleteVPNConnectionRouteOutput, error)
+
+	DeleteVPNGatewayRequest(*ec2.DeleteVPNGatewayInput) (*aws.Request, *ec2.DeleteVPNGatewayOutput)
+
+	DeleteVPNGateway(*ec2.DeleteVPNGatewayInput) (*ec2.DeleteVPNGatewayOutput, error)
+
+	DeleteVolumeRequest(*ec2.DeleteVolumeInput) (*aws.Request, *ec2.DeleteVolumeOutput)
+
+	DeleteVolume(*ec2.DeleteVolumeInput) (*ec2.DeleteVolumeOutput, error)
+
+	DeregisterImageRequest(*ec2.DeregisterImageInput) (*aws.Request, *ec2.DeregisterImageOutput)
+
+	DeregisterImage(*ec2.DeregisterImageInput) (*ec2.DeregisterImageOutput, error)
+
+	DescribeAccountAttributesRequest(*ec2.DescribeAccountAttributesInput) (*aws.Request, *ec2.DescribeAccountAttributesOutput)
+
+	DescribeAccountAttributes(*ec2.DescribeAccountAttributesInput) (*ec2.DescribeAccountAttributesOutput, error)
+
+	DescribeAddressesRequest(*ec2.DescribeAddressesInput) (*aws.Request, *ec2.DescribeAddressesOutput)
+
+	DescribeAddresses(*ec2.DescribeAddressesInput) (*ec2.DescribeAddressesOutput, error)
+
+	DescribeAvailabilityZonesRequest(*ec2.DescribeAvailabilityZonesInput) (*aws.Request, *ec2.DescribeAvailabilityZonesOutput)
+
+	DescribeAvailabilityZones(*ec2.DescribeAvailabilityZonesInput) (*ec2.DescribeAvailabilityZonesOutput, error)
+
+	DescribeBundleTasksRequest(*ec2.DescribeBundleTasksInput) (*aws.Request, *ec2.DescribeBundleTasksOutput)
+
+	DescribeBundleTasks(*ec2.DescribeBundleTasksInput) (*ec2.DescribeBundleTasksOutput, error)
+
+	DescribeClassicLinkInstancesRequest(*ec2.DescribeClassicLinkInstancesInput) (*aws.Request, *ec2.DescribeClassicLinkInstancesOutput)
+
+	DescribeClassicLinkInstances(*ec2.DescribeClassicLinkInstancesInput) (*ec2.DescribeClassicLinkInstancesOutput, error)
+
+	DescribeConversionTasksRequest(*ec2.DescribeConversionTasksInput) (*aws.Request, *ec2.DescribeConversionTasksOutput)
+
+	DescribeConversionTasks(*ec2.DescribeConversionTasksInput) (*ec2.DescribeConversionTasksOutput, error)
+
+	DescribeCustomerGatewaysRequest(*ec2.DescribeCustomerGatewaysInput) (*aws.Request, *ec2.DescribeCustomerGatewaysOutput)
+
+	DescribeCustomerGateways(*ec2.DescribeCustomerGatewaysInput) (*ec2.DescribeCustomerGatewaysOutput, error)
+
+	DescribeDHCPOptionsRequest(*ec2.DescribeDHCPOptionsInput) (*aws.Request, *ec2.DescribeDHCPOptionsOutput)
+
+	DescribeDHCPOptions(*ec2.DescribeDHCPOptionsInput) (*ec2.DescribeDHCPOptionsOutput, error)
+
+	DescribeExportTasksRequest(*ec2.DescribeExportTasksInput) (*aws.Request, *ec2.DescribeExportTasksOutput)
+
+	DescribeExportTasks(*ec2.DescribeExportTasksInput) (*ec2.DescribeExportTasksOutput, error)
+
+	DescribeFlowLogsRequest(*ec2.DescribeFlowLogsInput) (*aws.Request, *ec2.DescribeFlowLogsOutput)
+
+	DescribeFlowLogs(*ec2.DescribeFlowLogsInput) (*ec2.DescribeFlowLogsOutput, error)
+
+	DescribeImageAttributeRequest(*ec2.DescribeImageAttributeInput) (*aws.Request, *ec2.DescribeImageAttributeOutput)
+
+	DescribeImageAttribute(*ec2.DescribeImageAttributeInput) (*ec2.DescribeImageAttributeOutput, error)
+
+	DescribeImagesRequest(*ec2.DescribeImagesInput) (*aws.Request, *ec2.DescribeImagesOutput)
+
+	DescribeImages(*ec2.DescribeImagesInput) (*ec2.DescribeImagesOutput, error)
+
+	DescribeImportImageTasksRequest(*ec2.DescribeImportImageTasksInput) (*aws.Request, *ec2.DescribeImportImageTasksOutput)
+
+	DescribeImportImageTasks(*ec2.DescribeImportImageTasksInput) (*ec2.DescribeImportImageTasksOutput, error)
+
+	DescribeImportSnapshotTasksRequest(*ec2.DescribeImportSnapshotTasksInput) (*aws.Request, *ec2.DescribeImportSnapshotTasksOutput)
+
+	DescribeImportSnapshotTasks(*ec2.DescribeImportSnapshotTasksInput) (*ec2.DescribeImportSnapshotTasksOutput, error)
+
+	DescribeInstanceAttributeRequest(*ec2.DescribeInstanceAttributeInput) (*aws.Request, *ec2.DescribeInstanceAttributeOutput)
+
+	DescribeInstanceAttribute(*ec2.DescribeInstanceAttributeInput) (*ec2.DescribeInstanceAttributeOutput, error)
+
+	DescribeInstanceStatusRequest(*ec2.DescribeInstanceStatusInput) (*aws.Request, *ec2.DescribeInstanceStatusOutput)
+
+	DescribeInstanceStatus(*ec2.DescribeInstanceStatusInput) (*ec2.DescribeInstanceStatusOutput, error)
+
+	DescribeInstanceStatusPages(*ec2.DescribeInstanceStatusInput, func(*ec2.DescribeInstanceStatusOutput, bool) bool) error
+
+	DescribeInstancesRequest(*ec2.DescribeInstancesInput) (*aws.Request, *ec2.DescribeInstancesOutput)
+
+	DescribeInstances(*ec2.DescribeInstancesInput) (*ec2.DescribeInstancesOutput, error)
+
+	DescribeInstancesPages(*ec2.DescribeInstancesInput, func(*ec2.DescribeInstancesOutput, bool) bool) error
+
+	DescribeInternetGatewaysRequest(*ec2.DescribeInternetGatewaysInput) (*aws.Request, *ec2.DescribeInternetGatewaysOutput)
+
+	DescribeInternetGateways(*ec2.DescribeInternetGatewaysInput) (*ec2.DescribeInternetGatewaysOutput, error)
+
+	DescribeKeyPairsRequest(*ec2.DescribeKeyPairsInput) (*aws.Request, *ec2.DescribeKeyPairsOutput)
+
+	DescribeKeyPairs(*ec2.DescribeKeyPairsInput) (*ec2.DescribeKeyPairsOutput, error)
+
+	DescribeMovingAddressesRequest(*ec2.DescribeMovingAddressesInput) (*aws.Request, *ec2.DescribeMovingAddressesOutput)
+
+	DescribeMovingAddresses(*ec2.DescribeMovingAddressesInput) (*ec2.DescribeMovingAddressesOutput, error)
+
+	DescribeNetworkACLsRequest(*ec2.DescribeNetworkACLsInput) (*aws.Request, *ec2.DescribeNetworkACLsOutput)
+
+	DescribeNetworkACLs(*ec2.DescribeNetworkACLsInput) (*ec2.DescribeNetworkACLsOutput, error)
+
+	DescribeNetworkInterfaceAttributeRequest(*ec2.DescribeNetworkInterfaceAttributeInput) (*aws.Request, *ec2.DescribeNetworkInterfaceAttributeOutput)
+
+	DescribeNetworkInterfaceAttribute(*ec2.DescribeNetworkInterfaceAttributeInput) (*ec2.DescribeNetworkInterfaceAttributeOutput, error)
+
+	DescribeNetworkInterfacesRequest(*ec2.DescribeNetworkInterfacesInput) (*aws.Request, *ec2.DescribeNetworkInterfacesOutput)
+
+	DescribeNetworkInterfaces(*ec2.DescribeNetworkInterfacesInput) (*ec2.DescribeNetworkInterfacesOutput, error)
+
+	DescribePlacementGroupsRequest(*ec2.DescribePlacementGroupsInput) (*aws.Request, *ec2.DescribePlacementGroupsOutput)
+
+	DescribePlacementGroups(*ec2.DescribePlacementGroupsInput) (*ec2.DescribePlacementGroupsOutput, error)
+
+	DescribePrefixListsRequest(*ec2.DescribePrefixListsInput) (*aws.Request, *ec2.DescribePrefixListsOutput)
+
+	DescribePrefixLists(*ec2.DescribePrefixListsInput) (*ec2.DescribePrefixListsOutput, error)
+
+	DescribeRegionsRequest(*ec2.DescribeRegionsInput) (*aws.Request, *ec2.DescribeRegionsOutput)
+
+	DescribeRegions(*ec2.DescribeRegionsInput) (*ec2.DescribeRegionsOutput, error)
+
+	DescribeReservedInstancesRequest(*ec2.DescribeReservedInstancesInput) (*aws.Request, *ec2.DescribeReservedInstancesOutput)
+
+	DescribeReservedInstances(*ec2.DescribeReservedInstancesInput) (*ec2.DescribeReservedInstancesOutput, error)
+
+	DescribeReservedInstancesListingsRequest(*ec2.DescribeReservedInstancesListingsInput) (*aws.Request, *ec2.DescribeReservedInstancesListingsOutput)
+
+	DescribeReservedInstancesListings(*ec2.DescribeReservedInstancesListingsInput) (*ec2.DescribeReservedInstancesListingsOutput, error)
+
+	DescribeReservedInstancesModificationsRequest(*ec2.DescribeReservedInstancesModificationsInput) (*aws.Request, *ec2.DescribeReservedInstancesModificationsOutput)
+
+	DescribeReservedInstancesModifications(*ec2.DescribeReservedInstancesModificationsInput) (*ec2.DescribeReservedInstancesModificationsOutput, error)
+
+	DescribeReservedInstancesModificationsPages(*ec2.DescribeReservedInstancesModificationsInput, func(*ec2.DescribeReservedInstancesModificationsOutput, bool) bool) error
+
+	DescribeReservedInstancesOfferingsRequest(*ec2.DescribeReservedInstancesOfferingsInput) (*aws.Request, *ec2.DescribeReservedInstancesOfferingsOutput)
+
+	DescribeReservedInstancesOfferings(*ec2.DescribeReservedInstancesOfferingsInput) (*ec2.DescribeReservedInstancesOfferingsOutput, error)
+
+	DescribeReservedInstancesOfferingsPages(*ec2.DescribeReservedInstancesOfferingsInput, func(*ec2.DescribeReservedInstancesOfferingsOutput, bool) bool) error
+
+	DescribeRouteTablesRequest(*ec2.DescribeRouteTablesInput) (*aws.Request, *ec2.DescribeRouteTablesOutput)
+
+	DescribeRouteTables(*ec2.DescribeRouteTablesInput) (*ec2.DescribeRouteTablesOutput, error)
+
+	DescribeSecurityGroupsRequest(*ec2.DescribeSecurityGroupsInput) (*aws.Request, *ec2.DescribeSecurityGroupsOutput)
+
+	DescribeSecurityGroups(*ec2.DescribeSecurityGroupsInput) (*ec2.DescribeSecurityGroupsOutput, error)
+
+	DescribeSnapshotAttributeRequest(*ec2.DescribeSnapshotAttributeInput) (*aws.Request, *ec2.DescribeSnapshotAttributeOutput)
+
+	DescribeSnapshotAttribute(*ec2.DescribeSnapshotAttributeInput) (*ec2.DescribeSnapshotAttributeOutput, error)
+
+	DescribeSnapshotsRequest(*ec2.DescribeSnapshotsInput) (*aws.Request, *ec2.DescribeSnapshotsOutput)
+
+	DescribeSnapshots(*ec2.DescribeSnapshotsInput) (*ec2.DescribeSnapshotsOutput, error)
+
+	DescribeSnapshotsPages(*ec2.DescribeSnapshotsInput, func(*ec2.DescribeSnapshotsOutput, bool) bool) error
+
+	DescribeSpotDatafeedSubscriptionRequest(*ec2.DescribeSpotDatafeedSubscriptionInput) (*aws.Request, *ec2.DescribeSpotDatafeedSubscriptionOutput)
+
+	DescribeSpotDatafeedSubscription(*ec2.DescribeSpotDatafeedSubscriptionInput) (*ec2.DescribeSpotDatafeedSubscriptionOutput, error)
+
+	DescribeSpotFleetInstancesRequest(*ec2.DescribeSpotFleetInstancesInput) (*aws.Request, *ec2.DescribeSpotFleetInstancesOutput)
+
+	DescribeSpotFleetInstances(*ec2.DescribeSpotFleetInstancesInput) (*ec2.DescribeSpotFleetInstancesOutput, error)
+
+	DescribeSpotFleetRequestHistoryRequest(*ec2.DescribeSpotFleetRequestHistoryInput) (*aws.Request, *ec2.DescribeSpotFleetRequestHistoryOutput)
+
+	DescribeSpotFleetRequestHistory(*ec2.DescribeSpotFleetRequestHistoryInput) (*ec2.DescribeSpotFleetRequestHistoryOutput, error)
+
+	DescribeSpotFleetRequestsRequest(*ec2.DescribeSpotFleetRequestsInput) (*aws.Request, *ec2.DescribeSpotFleetRequestsOutput)
+
+	DescribeSpotFleetRequests(*ec2.DescribeSpotFleetRequestsInput) (*ec2.DescribeSpotFleetRequestsOutput, error)
+
+	DescribeSpotInstanceRequestsRequest(*ec2.DescribeSpotInstanceRequestsInput) (*aws.Request, *ec2.DescribeSpotInstanceRequestsOutput)
+
+	DescribeSpotInstanceRequests(*ec2.DescribeSpotInstanceRequestsInput) (*ec2.DescribeSpotInstanceRequestsOutput, error)
+
+	DescribeSpotPriceHistoryRequest(*ec2.DescribeSpotPriceHistoryInput) (*aws.Request, *ec2.DescribeSpotPriceHistoryOutput)
+
+	DescribeSpotPriceHistory(*ec2.DescribeSpotPriceHistoryInput) (*ec2.DescribeSpotPriceHistoryOutput, error)
+
+	DescribeSpotPriceHistoryPages(*ec2.DescribeSpotPriceHistoryInput, func(*ec2.DescribeSpotPriceHistoryOutput, bool) bool) error
+
+	DescribeSubnetsRequest(*ec2.DescribeSubnetsInput) (*aws.Request, *ec2.DescribeSubnetsOutput)
+
+	DescribeSubnets(*ec2.DescribeSubnetsInput) (*ec2.DescribeSubnetsOutput, error)
+
+	DescribeTagsRequest(*ec2.DescribeTagsInput) (*aws.Request, *ec2.DescribeTagsOutput)
+
+	DescribeTags(*ec2.DescribeTagsInput) (*ec2.DescribeTagsOutput, error)
+
+	DescribeVPCAttributeRequest(*ec2.DescribeVPCAttributeInput) (*aws.Request, *ec2.DescribeVPCAttributeOutput)
+
+	DescribeVPCAttribute(*ec2.DescribeVPCAttributeInput) (*ec2.DescribeVPCAttributeOutput, error)
+
+	DescribeVPCClassicLinkRequest(*ec2.DescribeVPCClassicLinkInput) (*aws.Request, *ec2.DescribeVPCClassicLinkOutput)
+
+	DescribeVPCClassicLink(*ec2.DescribeVPCClassicLinkInput) (*ec2.DescribeVPCClassicLinkOutput, error)
+
+	DescribeVPCEndpointServicesRequest(*ec2.DescribeVPCEndpointServicesInput) (*aws.Request, *ec2.DescribeVPCEndpointServicesOutput)
+
+	DescribeVPCEndpointServices(*ec2.DescribeVPCEndpointServicesInput) (*ec2.DescribeVPCEndpointServicesOutput, error)
+
+	DescribeVPCEndpointsRequest(*ec2.DescribeVPCEndpointsInput) (*aws.Request, *ec2.DescribeVPCEndpointsOutput)
+
+	DescribeVPCEndpoints(*ec2.DescribeVPCEndpointsInput) (*ec2.DescribeVPCEndpointsOutput, error)
+
+	DescribeVPCPeeringConnectionsRequest(*ec2.DescribeVPCPeeringConnectionsInput) (*aws.Request, *ec2.DescribeVPCPeeringConnectionsOutput)
+
+	DescribeVPCPeeringConnections(*ec2.DescribeVPCPeeringConnectionsInput) (*ec2.DescribeVPCPeeringConnectionsOutput, error)
+
+	DescribeVPCsRequest(*ec2.DescribeVPCsInput) (*aws.Request, *ec2.DescribeVPCsOutput)
+
+	DescribeVPCs(*ec2.DescribeVPCsInput) (*ec2.DescribeVPCsOutput, error)
+
+	DescribeVPNConnectionsRequest(*ec2.DescribeVPNConnectionsInput) (*aws.Request, *ec2.DescribeVPNConnectionsOutput)
+
+	DescribeVPNConnections(*ec2.DescribeVPNConnectionsInput) (*ec2.DescribeVPNConnectionsOutput, error)
+
+	DescribeVPNGatewaysRequest(*ec2.DescribeVPNGatewaysInput) (*aws.Request, *ec2.DescribeVPNGatewaysOutput)
+
+	DescribeVPNGateways(*ec2.DescribeVPNGatewaysInput) (*ec2.DescribeVPNGatewaysOutput, error)
+
+	DescribeVolumeAttributeRequest(*ec2.DescribeVolumeAttributeInput) (*aws.Request, *ec2.DescribeVolumeAttributeOutput)
+
+	DescribeVolumeAttribute(*ec2.DescribeVolumeAttributeInput) (*ec2.DescribeVolumeAttributeOutput, error)
+
+	DescribeVolumeStatusRequest(*ec2.DescribeVolumeStatusInput) (*aws.Request, *ec2.DescribeVolumeStatusOutput)
+
+	DescribeVolumeStatus(*ec2.DescribeVolumeStatusInput) (*ec2.DescribeVolumeStatusOutput, error)
+
+	DescribeVolumeStatusPages(*ec2.DescribeVolumeStatusInput, func(*ec2.DescribeVolumeStatusOutput, bool) bool) error
+
+	DescribeVolumesRequest(*ec2.DescribeVolumesInput) (*aws.Request, *ec2.DescribeVolumesOutput)
+
+	DescribeVolumes(*ec2.DescribeVolumesInput) (*ec2.DescribeVolumesOutput, error)
+
+	DescribeVolumesPages(*ec2.DescribeVolumesInput, func(*ec2.DescribeVolumesOutput, bool) bool) error
+
+	DetachClassicLinkVPCRequest(*ec2.DetachClassicLinkVPCInput) (*aws.Request, *ec2.DetachClassicLinkVPCOutput)
+
+	DetachClassicLinkVPC(*ec2.DetachClassicLinkVPCInput) (*ec2.DetachClassicLinkVPCOutput, error)
+
+	DetachInternetGatewayRequest(*ec2.DetachInternetGatewayInput) (*aws.Request, *ec2.DetachInternetGatewayOutput)
+
+	DetachInternetGateway(*ec2.DetachInternetGatewayInput) (*ec2.DetachInternetGatewayOutput, error)
+
+	DetachNetworkInterfaceRequest(*ec2.DetachNetworkInterfaceInput) (*aws.Request, *ec2.DetachNetworkInterfaceOutput)
+
+	DetachNetworkInterface(*ec2.DetachNetworkInterfaceInput) (*ec2.DetachNetworkInterfaceOutput, error)
+
+	DetachVPNGatewayRequest(*ec2.DetachVPNGatewayInput) (*aws.Request, *ec2.DetachVPNGatewayOutput)
+
+	DetachVPNGateway(*ec2.DetachVPNGatewayInput) (*ec2.DetachVPNGatewayOutput, error)
+
+	DetachVolumeRequest(*ec2.DetachVolumeInput) (*aws.Request, *ec2.VolumeAttachment)
+
+	DetachVolume(*ec2.DetachVolumeInput) (*ec2.VolumeAttachment, error)
+
+	DisableVGWRoutePropagationRequest(*ec2.DisableVGWRoutePropagationInput) (*aws.Request, *ec2.DisableVGWRoutePropagationOutput)
+
+	DisableVGWRoutePropagation(*ec2.DisableVGWRoutePropagationInput) (*ec2.DisableVGWRoutePropagationOutput, error)
+
+	DisableVPCClassicLinkRequest(*ec2.DisableVPCClassicLinkInput) (*aws.Request, *ec2.DisableVPCClassicLinkOutput)
+
+	DisableVPCClassicLink(*ec2.DisableVPCClassicLinkInput) (*ec2.DisableVPCClassicLinkOutput, error)
+
+	DisassociateAddressRequest(*ec2.DisassociateAddressInput) (*aws.Request, *ec2.DisassociateAddressOutput)
+
+	DisassociateAddress(*ec2.DisassociateAddressInput) (*ec2.DisassociateAddressOutput, error)
+
+	DisassociateRouteTableRequest(*ec2.DisassociateRouteTableInput) (*aws.Request, *ec2.DisassociateRouteTableOutput)
+
+	DisassociateRouteTable(*ec2.DisassociateRouteTableInput) (*ec2.DisassociateRouteTableOutput, error)
+
+	EnableVGWRoutePropagationRequest(*ec2.EnableVGWRoutePropagationInput) (*aws.Request, *ec2.EnableVGWRoutePropagationOutput)
+
+	EnableVGWRoutePropagation(*ec2.EnableVGWRoutePropagationInput) (*ec2.EnableVGWRoutePropagationOutput, error)
+
+	EnableVPCClassicLinkRequest(*ec2.EnableVPCClassicLinkInput) (*aws.Request, *ec2.EnableVPCClassicLinkOutput)
+
+	EnableVPCClassicLink(*ec2.EnableVPCClassicLinkInput) (*ec2.EnableVPCClassicLinkOutput, error)
+
+	EnableVolumeIORequest(*ec2.EnableVolumeIOInput) (*aws.Request, *ec2.EnableVolumeIOOutput)
+
+	EnableVolumeIO(*ec2.EnableVolumeIOInput) (*ec2.EnableVolumeIOOutput, error)
+
+	GetConsoleOutputRequest(*ec2.GetConsoleOutputInput) (*aws.Request, *ec2.GetConsoleOutputOutput)
+
+	GetConsoleOutput(*ec2.GetConsoleOutputInput) (*ec2.GetConsoleOutputOutput, error)
+
+	GetPasswordDataRequest(*ec2.GetPasswordDataInput) (*aws.Request, *ec2.GetPasswordDataOutput)
+
+	GetPasswordData(*ec2.GetPasswordDataInput) (*ec2.GetPasswordDataOutput, error)
+
+	ImportImageRequest(*ec2.ImportImageInput) (*aws.Request, *ec2.ImportImageOutput)
+
+	ImportImage(*ec2.ImportImageInput) (*ec2.ImportImageOutput, error)
+
+	ImportInstanceRequest(*ec2.ImportInstanceInput) (*aws.Request, *ec2.ImportInstanceOutput)
+
+	ImportInstance(*ec2.ImportInstanceInput) (*ec2.ImportInstanceOutput, error)
+
+	ImportKeyPairRequest(*ec2.ImportKeyPairInput) (*aws.Request, *ec2.ImportKeyPairOutput)
+
+	ImportKeyPair(*ec2.ImportKeyPairInput) (*ec2.ImportKeyPairOutput, error)
+
+	ImportSnapshotRequest(*ec2.ImportSnapshotInput) (*aws.Request, *ec2.ImportSnapshotOutput)
+
+	ImportSnapshot(*ec2.ImportSnapshotInput) (*ec2.ImportSnapshotOutput, error)
+
+	ImportVolumeRequest(*ec2.ImportVolumeInput) (*aws.Request, *ec2.ImportVolumeOutput)
+
+	ImportVolume(*ec2.ImportVolumeInput) (*ec2.ImportVolumeOutput, error)
+
+	ModifyImageAttributeRequest(*ec2.ModifyImageAttributeInput) (*aws.Request, *ec2.ModifyImageAttributeOutput)
+
+	ModifyImageAttribute(*ec2.ModifyImageAttributeInput) (*ec2.ModifyImageAttributeOutput, error)
+
+	ModifyInstanceAttributeRequest(*ec2.ModifyInstanceAttributeInput) (*aws.Request, *ec2.ModifyInstanceAttributeOutput)
+
+	ModifyInstanceAttribute(*ec2.ModifyInstanceAttributeInput) (*ec2.ModifyInstanceAttributeOutput, error)
+
+	ModifyNetworkInterfaceAttributeRequest(*ec2.ModifyNetworkInterfaceAttributeInput) (*aws.Request, *ec2.ModifyNetworkInterfaceAttributeOutput)
+
+	ModifyNetworkInterfaceAttribute(*ec2.ModifyNetworkInterfaceAttributeInput) (*ec2.ModifyNetworkInterfaceAttributeOutput, error)
+
+	ModifyReservedInstancesRequest(*ec2.ModifyReservedInstancesInput) (*aws.Request, *ec2.ModifyReservedInstancesOutput)
+
+	ModifyReservedInstances(*ec2.ModifyReservedInstancesInput) (*ec2.ModifyReservedInstancesOutput, error)
+
+	ModifySnapshotAttributeRequest(*ec2.ModifySnapshotAttributeInput) (*aws.Request, *ec2.ModifySnapshotAttributeOutput)
+
+	ModifySnapshotAttribute(*ec2.ModifySnapshotAttributeInput) (*ec2.ModifySnapshotAttributeOutput, error)
+
+	ModifySubnetAttributeRequest(*ec2.ModifySubnetAttributeInput) (*aws.Request, *ec2.ModifySubnetAttributeOutput)
+
+	ModifySubnetAttribute(*ec2.ModifySubnetAttributeInput) (*ec2.ModifySubnetAttributeOutput, error)
+
+	ModifyVPCAttributeRequest(*ec2.ModifyVPCAttributeInput) (*aws.Request, *ec2.ModifyVPCAttributeOutput)
+
+	ModifyVPCAttribute(*ec2.ModifyVPCAttributeInput) (*ec2.ModifyVPCAttributeOutput, error)
+
+	ModifyVPCEndpointRequest(*ec2.ModifyVPCEndpointInput) (*aws.Request, *ec2.ModifyVPCEndpointOutput)
+
+	ModifyVPCEndpoint(*ec2.ModifyVPCEndpointInput) (*ec2.ModifyVPCEndpointOutput, error)
+
+	ModifyVolumeAttributeRequest(*ec2.ModifyVolumeAttributeInput) (*aws.Request, *ec2.ModifyVolumeAttributeOutput)
+
+	ModifyVolumeAttribute(*ec2.ModifyVolumeAttributeInput) (*ec2.ModifyVolumeAttributeOutput, error)
+
+	MonitorInstancesRequest(*ec2.MonitorInstancesInput) (*aws.Request, *ec2.MonitorInstancesOutput)
+
+	MonitorInstances(*ec2.MonitorInstancesInput) (*ec2.MonitorInstancesOutput, error)
+
+	MoveAddressToVPCRequest(*ec2.MoveAddressToVPCInput) (*aws.Request, *ec2.MoveAddressToVPCOutput)
+
+	MoveAddressToVPC(*ec2.MoveAddressToVPCInput) (*ec2.MoveAddressToVPCOutput, error)
+
+	PurchaseReservedInstancesOfferingRequest(*ec2.PurchaseReservedInstancesOfferingInput) (*aws.Request, *ec2.PurchaseReservedInstancesOfferingOutput)
+
+	PurchaseReservedInstancesOffering(*ec2.PurchaseReservedInstancesOfferingInput) (*ec2.PurchaseReservedInstancesOfferingOutput, error)
+
+	RebootInstancesRequest(*ec2.RebootInstancesInput) (*aws.Request, *ec2.RebootInstancesOutput)
+
+	RebootInstances(*ec2.RebootInstancesInput) (*ec2.RebootInstancesOutput, error)
+
+	RegisterImageRequest(*ec2.RegisterImageInput) (*aws.Request, *ec2.RegisterImageOutput)
+
+	RegisterImage(*ec2.RegisterImageInput) (*ec2.RegisterImageOutput, error)
+
+	RejectVPCPeeringConnectionRequest(*ec2.RejectVPCPeeringConnectionInput) (*aws.Request, *ec2.RejectVPCPeeringConnectionOutput)
+
+	RejectVPCPeeringConnection(*ec2.RejectVPCPeeringConnectionInput) (*ec2.RejectVPCPeeringConnectionOutput, error)
+
+	ReleaseAddressRequest(*ec2.ReleaseAddressInput) (*aws.Request, *ec2.ReleaseAddressOutput)
+
+	ReleaseAddress(*ec2.ReleaseAddressInput) (*ec2.ReleaseAddressOutput, error)
+
+	ReplaceNetworkACLAssociationRequest(*ec2.ReplaceNetworkACLAssociationInput) (*aws.Request, *ec2.ReplaceNetworkACLAssociationOutput)
+
+	ReplaceNetworkACLAssociation(*ec2.ReplaceNetworkACLAssociationInput) (*ec2.ReplaceNetworkACLAssociationOutput, error)
+
+	ReplaceNetworkACLEntryRequest(*ec2.ReplaceNetworkACLEntryInput) (*aws.Request, *ec2.ReplaceNetworkACLEntryOutput)
+
+	ReplaceNetworkACLEntry(*ec2.ReplaceNetworkACLEntryInput) (*ec2.ReplaceNetworkACLEntryOutput, error)
+
+	ReplaceRouteRequest(*ec2.ReplaceRouteInput) (*aws.Request, *ec2.ReplaceRouteOutput)
+
+	ReplaceRoute(*ec2.ReplaceRouteInput) (*ec2.ReplaceRouteOutput, error)
+
+	ReplaceRouteTableAssociationRequest(*ec2.ReplaceRouteTableAssociationInput) (*aws.Request, *ec2.ReplaceRouteTableAssociationOutput)
+
+	ReplaceRouteTableAssociation(*ec2.ReplaceRouteTableAssociationInput) (*ec2.ReplaceRouteTableAssociationOutput, error)
+
+	ReportInstanceStatusRequest(*ec2.ReportInstanceStatusInput) (*aws.Request, *ec2.ReportInstanceStatusOutput)
+
+	ReportInstanceStatus(*ec2.ReportInstanceStatusInput) (*ec2.ReportInstanceStatusOutput, error)
+
+	RequestSpotFleetRequest(*ec2.RequestSpotFleetInput) (*aws.Request, *ec2.RequestSpotFleetOutput)
+
+	RequestSpotFleet(*ec2.RequestSpotFleetInput) (*ec2.RequestSpotFleetOutput, error)
+
+	RequestSpotInstancesRequest(*ec2.RequestSpotInstancesInput) (*aws.Request, *ec2.RequestSpotInstancesOutput)
+
+	RequestSpotInstances(*ec2.RequestSpotInstancesInput) (*ec2.RequestSpotInstancesOutput, error)
+
+	ResetImageAttributeRequest(*ec2.ResetImageAttributeInput) (*aws.Request, *ec2.ResetImageAttributeOutput)
+
+	ResetImageAttribute(*ec2.ResetImageAttributeInput) (*ec2.ResetImageAttributeOutput, error)
+
+	ResetInstanceAttributeRequest(*ec2.ResetInstanceAttributeInput) (*aws.Request, *ec2.ResetInstanceAttributeOutput)
+
+	ResetInstanceAttribute(*ec2.ResetInstanceAttributeInput) (*ec2.ResetInstanceAttributeOutput, error)
+
+	ResetNetworkInterfaceAttributeRequest(*ec2.ResetNetworkInterfaceAttributeInput) (*aws.Request, *ec2.ResetNetworkInterfaceAttributeOutput)
+
+	ResetNetworkInterfaceAttribute(*ec2.ResetNetworkInterfaceAttributeInput) (*ec2.ResetNetworkInterfaceAttributeOutput, error)
+
+	ResetSnapshotAttributeRequest(*ec2.ResetSnapshotAttributeInput) (*aws.Request, *ec2.ResetSnapshotAttributeOutput)
+
+	ResetSnapshotAttribute(*ec2.ResetSnapshotAttributeInput) (*ec2.ResetSnapshotAttributeOutput, error)
+
+	RestoreAddressToClassicRequest(*ec2.RestoreAddressToClassicInput) (*aws.Request, *ec2.RestoreAddressToClassicOutput)
+
+	RestoreAddressToClassic(*ec2.RestoreAddressToClassicInput) (*ec2.RestoreAddressToClassicOutput, error)
+
+	RevokeSecurityGroupEgressRequest(*ec2.RevokeSecurityGroupEgressInput) (*aws.Request, *ec2.RevokeSecurityGroupEgressOutput)
+
+	RevokeSecurityGroupEgress(*ec2.RevokeSecurityGroupEgressInput) (*ec2.RevokeSecurityGroupEgressOutput, error)
+
+	RevokeSecurityGroupIngressRequest(*ec2.RevokeSecurityGroupIngressInput) (*aws.Request, *ec2.RevokeSecurityGroupIngressOutput)
+
+	RevokeSecurityGroupIngress(*ec2.RevokeSecurityGroupIngressInput) (*ec2.RevokeSecurityGroupIngressOutput, error)
+
+	RunInstancesRequest(*ec2.RunInstancesInput) (*aws.Request, *ec2.Reservation)
+
+	RunInstances(*ec2.RunInstancesInput) (*ec2.Reservation, error)
+
+	StartInstancesRequest(*ec2.StartInstancesInput) (*aws.Request, *ec2.StartInstancesOutput)
+
+	StartInstances(*ec2.StartInstancesInput) (*ec2.StartInstancesOutput, error)
+
+	StopInstancesRequest(*ec2.StopInstancesInput) (*aws.Request, *ec2.StopInstancesOutput)
+
+	StopInstances(*ec2.StopInstancesInput) (*ec2.StopInstancesOutput, error)
+
+	TerminateInstancesRequest(*ec2.TerminateInstancesInput) (*aws.Request, *ec2.TerminateInstancesOutput)
+
+	TerminateInstances(*ec2.TerminateInstancesInput) (*ec2.TerminateInstancesOutput, error)
+
+	UnassignPrivateIPAddressesRequest(*ec2.UnassignPrivateIPAddressesInput) (*aws.Request, *ec2.UnassignPrivateIPAddressesOutput)
+
+	UnassignPrivateIPAddresses(*ec2.UnassignPrivateIPAddressesInput) (*ec2.UnassignPrivateIPAddressesOutput, error)
+
+	UnmonitorInstancesRequest(*ec2.UnmonitorInstancesInput) (*aws.Request, *ec2.UnmonitorInstancesOutput)
+
+	UnmonitorInstances(*ec2.UnmonitorInstancesInput) (*ec2.UnmonitorInstancesOutput, error)
+}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/ec2/ec2iface/interface_test.go

@@ -0,0 +1,15 @@
+// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
+
+package ec2iface_test
+
+import (
+	"testing"
+
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestInterface(t *testing.T) {
+	assert.Implements(t, (*ec2iface.EC2API)(nil), ec2.New(nil))
+}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/ec2/examples_test.go

@@ -0,0 +1,6619 @@
+// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
+
+package ec2_test
+
+import (
+	"bytes"
+	"fmt"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/aws/aws-sdk-go/aws/awsutil"
+	"github.com/aws/aws-sdk-go/service/ec2"
+)
+
+var _ time.Duration
+var _ bytes.Buffer
+
+func ExampleEC2_AcceptVPCPeeringConnection() {
+	svc := ec2.New(nil)
+
+	params := &ec2.AcceptVPCPeeringConnectionInput{
+		DryRun:                 aws.Bool(true),
+		VPCPeeringConnectionID: aws.String("String"),
+	}
+	resp, err := svc.AcceptVPCPeeringConnection(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_AllocateAddress() {
+	svc := ec2.New(nil)
+
+	params := &ec2.AllocateAddressInput{
+		Domain: aws.String("DomainType"),
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.AllocateAddress(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_AssignPrivateIPAddresses() {
+	svc := ec2.New(nil)
+
+	params := &ec2.AssignPrivateIPAddressesInput{
+		NetworkInterfaceID: aws.String("String"), // Required
+		AllowReassignment:  aws.Bool(true),
+		PrivateIPAddresses: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		SecondaryPrivateIPAddressCount: aws.Int64(1),
+	}
+	resp, err := svc.AssignPrivateIPAddresses(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_AssociateAddress() {
+	svc := ec2.New(nil)
+
+	params := &ec2.AssociateAddressInput{
+		AllocationID:       aws.String("String"),
+		AllowReassociation: aws.Bool(true),
+		DryRun:             aws.Bool(true),
+		InstanceID:         aws.String("String"),
+		NetworkInterfaceID: aws.String("String"),
+		PrivateIPAddress:   aws.String("String"),
+		PublicIP:           aws.String("String"),
+	}
+	resp, err := svc.AssociateAddress(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_AssociateDHCPOptions() {
+	svc := ec2.New(nil)
+
+	params := &ec2.AssociateDHCPOptionsInput{
+		DHCPOptionsID: aws.String("String"), // Required
+		VPCID:         aws.String("String"), // Required
+		DryRun:        aws.Bool(true),
+	}
+	resp, err := svc.AssociateDHCPOptions(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_AssociateRouteTable() {
+	svc := ec2.New(nil)
+
+	params := &ec2.AssociateRouteTableInput{
+		RouteTableID: aws.String("String"), // Required
+		SubnetID:     aws.String("String"), // Required
+		DryRun:       aws.Bool(true),
+	}
+	resp, err := svc.AssociateRouteTable(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_AttachClassicLinkVPC() {
+	svc := ec2.New(nil)
+
+	params := &ec2.AttachClassicLinkVPCInput{
+		Groups: []*string{ // Required
+			aws.String("String"), // Required
+			// More values...
+		},
+		InstanceID: aws.String("String"), // Required
+		VPCID:      aws.String("String"), // Required
+		DryRun:     aws.Bool(true),
+	}
+	resp, err := svc.AttachClassicLinkVPC(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_AttachInternetGateway() {
+	svc := ec2.New(nil)
+
+	params := &ec2.AttachInternetGatewayInput{
+		InternetGatewayID: aws.String("String"), // Required
+		VPCID:             aws.String("String"), // Required
+		DryRun:            aws.Bool(true),
+	}
+	resp, err := svc.AttachInternetGateway(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_AttachNetworkInterface() {
+	svc := ec2.New(nil)
+
+	params := &ec2.AttachNetworkInterfaceInput{
+		DeviceIndex:        aws.Int64(1),         // Required
+		InstanceID:         aws.String("String"), // Required
+		NetworkInterfaceID: aws.String("String"), // Required
+		DryRun:             aws.Bool(true),
+	}
+	resp, err := svc.AttachNetworkInterface(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_AttachVPNGateway() {
+	svc := ec2.New(nil)
+
+	params := &ec2.AttachVPNGatewayInput{
+		VPCID:        aws.String("String"), // Required
+		VPNGatewayID: aws.String("String"), // Required
+		DryRun:       aws.Bool(true),
+	}
+	resp, err := svc.AttachVPNGateway(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_AttachVolume() {
+	svc := ec2.New(nil)
+
+	params := &ec2.AttachVolumeInput{
+		Device:     aws.String("String"), // Required
+		InstanceID: aws.String("String"), // Required
+		VolumeID:   aws.String("String"), // Required
+		DryRun:     aws.Bool(true),
+	}
+	resp, err := svc.AttachVolume(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_AuthorizeSecurityGroupEgress() {
+	svc := ec2.New(nil)
+
+	params := &ec2.AuthorizeSecurityGroupEgressInput{
+		GroupID:  aws.String("String"), // Required
+		CIDRIP:   aws.String("String"),
+		DryRun:   aws.Bool(true),
+		FromPort: aws.Int64(1),
+		IPPermissions: []*ec2.IPPermission{
+			{ // Required
+				FromPort:   aws.Int64(1),
+				IPProtocol: aws.String("String"),
+				IPRanges: []*ec2.IPRange{
+					{ // Required
+						CIDRIP: aws.String("String"),
+					},
+					// More values...
+				},
+				PrefixListIDs: []*ec2.PrefixListID{
+					{ // Required
+						PrefixListID: aws.String("String"),
+					},
+					// More values...
+				},
+				ToPort: aws.Int64(1),
+				UserIDGroupPairs: []*ec2.UserIDGroupPair{
+					{ // Required
+						GroupID:   aws.String("String"),
+						GroupName: aws.String("String"),
+						UserID:    aws.String("String"),
+					},
+					// More values...
+				},
+			},
+			// More values...
+		},
+		IPProtocol:                 aws.String("String"),
+		SourceSecurityGroupName:    aws.String("String"),
+		SourceSecurityGroupOwnerID: aws.String("String"),
+		ToPort: aws.Int64(1),
+	}
+	resp, err := svc.AuthorizeSecurityGroupEgress(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_AuthorizeSecurityGroupIngress() {
+	svc := ec2.New(nil)
+
+	params := &ec2.AuthorizeSecurityGroupIngressInput{
+		CIDRIP:    aws.String("String"),
+		DryRun:    aws.Bool(true),
+		FromPort:  aws.Int64(1),
+		GroupID:   aws.String("String"),
+		GroupName: aws.String("String"),
+		IPPermissions: []*ec2.IPPermission{
+			{ // Required
+				FromPort:   aws.Int64(1),
+				IPProtocol: aws.String("String"),
+				IPRanges: []*ec2.IPRange{
+					{ // Required
+						CIDRIP: aws.String("String"),
+					},
+					// More values...
+				},
+				PrefixListIDs: []*ec2.PrefixListID{
+					{ // Required
+						PrefixListID: aws.String("String"),
+					},
+					// More values...
+				},
+				ToPort: aws.Int64(1),
+				UserIDGroupPairs: []*ec2.UserIDGroupPair{
+					{ // Required
+						GroupID:   aws.String("String"),
+						GroupName: aws.String("String"),
+						UserID:    aws.String("String"),
+					},
+					// More values...
+				},
+			},
+			// More values...
+		},
+		IPProtocol:                 aws.String("String"),
+		SourceSecurityGroupName:    aws.String("String"),
+		SourceSecurityGroupOwnerID: aws.String("String"),
+		ToPort: aws.Int64(1),
+	}
+	resp, err := svc.AuthorizeSecurityGroupIngress(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_BundleInstance() {
+	svc := ec2.New(nil)
+
+	params := &ec2.BundleInstanceInput{
+		InstanceID: aws.String("String"), // Required
+		Storage: &ec2.Storage{ // Required
+			S3: &ec2.S3Storage{
+				AWSAccessKeyID:        aws.String("String"),
+				Bucket:                aws.String("String"),
+				Prefix:                aws.String("String"),
+				UploadPolicy:          []byte("PAYLOAD"),
+				UploadPolicySignature: aws.String("String"),
+			},
+		},
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.BundleInstance(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CancelBundleTask() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CancelBundleTaskInput{
+		BundleID: aws.String("String"), // Required
+		DryRun:   aws.Bool(true),
+	}
+	resp, err := svc.CancelBundleTask(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CancelConversionTask() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CancelConversionTaskInput{
+		ConversionTaskID: aws.String("String"), // Required
+		DryRun:           aws.Bool(true),
+		ReasonMessage:    aws.String("String"),
+	}
+	resp, err := svc.CancelConversionTask(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CancelExportTask() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CancelExportTaskInput{
+		ExportTaskID: aws.String("String"), // Required
+	}
+	resp, err := svc.CancelExportTask(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CancelImportTask() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CancelImportTaskInput{
+		CancelReason: aws.String("String"),
+		DryRun:       aws.Bool(true),
+		ImportTaskID: aws.String("String"),
+	}
+	resp, err := svc.CancelImportTask(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CancelReservedInstancesListing() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CancelReservedInstancesListingInput{
+		ReservedInstancesListingID: aws.String("String"), // Required
+	}
+	resp, err := svc.CancelReservedInstancesListing(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CancelSpotFleetRequests() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CancelSpotFleetRequestsInput{
+		SpotFleetRequestIDs: []*string{ // Required
+			aws.String("String"), // Required
+			// More values...
+		},
+		TerminateInstances: aws.Bool(true), // Required
+		DryRun:             aws.Bool(true),
+	}
+	resp, err := svc.CancelSpotFleetRequests(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CancelSpotInstanceRequests() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CancelSpotInstanceRequestsInput{
+		SpotInstanceRequestIDs: []*string{ // Required
+			aws.String("String"), // Required
+			// More values...
+		},
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.CancelSpotInstanceRequests(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ConfirmProductInstance() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ConfirmProductInstanceInput{
+		InstanceID:  aws.String("String"), // Required
+		ProductCode: aws.String("String"), // Required
+		DryRun:      aws.Bool(true),
+	}
+	resp, err := svc.ConfirmProductInstance(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CopyImage() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CopyImageInput{
+		Name:          aws.String("String"), // Required
+		SourceImageID: aws.String("String"), // Required
+		SourceRegion:  aws.String("String"), // Required
+		ClientToken:   aws.String("String"),
+		Description:   aws.String("String"),
+		DryRun:        aws.Bool(true),
+	}
+	resp, err := svc.CopyImage(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CopySnapshot() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CopySnapshotInput{
+		SourceRegion:      aws.String("String"), // Required
+		SourceSnapshotID:  aws.String("String"), // Required
+		Description:       aws.String("String"),
+		DestinationRegion: aws.String("String"),
+		DryRun:            aws.Bool(true),
+		Encrypted:         aws.Bool(true),
+		KMSKeyID:          aws.String("String"),
+		PresignedURL:      aws.String("String"),
+	}
+	resp, err := svc.CopySnapshot(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateCustomerGateway() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateCustomerGatewayInput{
+		BGPASN:   aws.Int64(1),              // Required
+		PublicIP: aws.String("String"),      // Required
+		Type:     aws.String("GatewayType"), // Required
+		DryRun:   aws.Bool(true),
+	}
+	resp, err := svc.CreateCustomerGateway(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateDHCPOptions() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateDHCPOptionsInput{
+		DHCPConfigurations: []*ec2.NewDHCPConfiguration{ // Required
+			{ // Required
+				Key: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.CreateDHCPOptions(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateFlowLogs() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateFlowLogsInput{
+		DeliverLogsPermissionARN: aws.String("String"), // Required
+		LogGroupName:             aws.String("String"), // Required
+		ResourceIDs: []*string{ // Required
+			aws.String("String"), // Required
+			// More values...
+		},
+		ResourceType: aws.String("FlowLogsResourceType"), // Required
+		TrafficType:  aws.String("TrafficType"),          // Required
+		ClientToken:  aws.String("String"),
+	}
+	resp, err := svc.CreateFlowLogs(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateImage() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateImageInput{
+		InstanceID: aws.String("String"), // Required
+		Name:       aws.String("String"), // Required
+		BlockDeviceMappings: []*ec2.BlockDeviceMapping{
+			{ // Required
+				DeviceName: aws.String("String"),
+				EBS: &ec2.EBSBlockDevice{
+					DeleteOnTermination: aws.Bool(true),
+					Encrypted:           aws.Bool(true),
+					IOPS:                aws.Int64(1),
+					SnapshotID:          aws.String("String"),
+					VolumeSize:          aws.Int64(1),
+					VolumeType:          aws.String("VolumeType"),
+				},
+				NoDevice:    aws.String("String"),
+				VirtualName: aws.String("String"),
+			},
+			// More values...
+		},
+		Description: aws.String("String"),
+		DryRun:      aws.Bool(true),
+		NoReboot:    aws.Bool(true),
+	}
+	resp, err := svc.CreateImage(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateInstanceExportTask() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateInstanceExportTaskInput{
+		InstanceID:  aws.String("String"), // Required
+		Description: aws.String("String"),
+		ExportToS3Task: &ec2.ExportToS3TaskSpecification{
+			ContainerFormat: aws.String("ContainerFormat"),
+			DiskImageFormat: aws.String("DiskImageFormat"),
+			S3Bucket:        aws.String("String"),
+			S3Prefix:        aws.String("String"),
+		},
+		TargetEnvironment: aws.String("ExportEnvironment"),
+	}
+	resp, err := svc.CreateInstanceExportTask(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateInternetGateway() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateInternetGatewayInput{
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.CreateInternetGateway(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateKeyPair() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateKeyPairInput{
+		KeyName: aws.String("String"), // Required
+		DryRun:  aws.Bool(true),
+	}
+	resp, err := svc.CreateKeyPair(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateNetworkACL() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateNetworkACLInput{
+		VPCID:  aws.String("String"), // Required
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.CreateNetworkACL(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateNetworkACLEntry() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateNetworkACLEntryInput{
+		CIDRBlock:    aws.String("String"),     // Required
+		Egress:       aws.Bool(true),           // Required
+		NetworkACLID: aws.String("String"),     // Required
+		Protocol:     aws.String("String"),     // Required
+		RuleAction:   aws.String("RuleAction"), // Required
+		RuleNumber:   aws.Int64(1),             // Required
+		DryRun:       aws.Bool(true),
+		ICMPTypeCode: &ec2.ICMPTypeCode{
+			Code: aws.Int64(1),
+			Type: aws.Int64(1),
+		},
+		PortRange: &ec2.PortRange{
+			From: aws.Int64(1),
+			To:   aws.Int64(1),
+		},
+	}
+	resp, err := svc.CreateNetworkACLEntry(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateNetworkInterface() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateNetworkInterfaceInput{
+		SubnetID:    aws.String("String"), // Required
+		Description: aws.String("String"),
+		DryRun:      aws.Bool(true),
+		Groups: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		PrivateIPAddress: aws.String("String"),
+		PrivateIPAddresses: []*ec2.PrivateIPAddressSpecification{
+			{ // Required
+				PrivateIPAddress: aws.String("String"), // Required
+				Primary:          aws.Bool(true),
+			},
+			// More values...
+		},
+		SecondaryPrivateIPAddressCount: aws.Int64(1),
+	}
+	resp, err := svc.CreateNetworkInterface(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreatePlacementGroup() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreatePlacementGroupInput{
+		GroupName: aws.String("String"),            // Required
+		Strategy:  aws.String("PlacementStrategy"), // Required
+		DryRun:    aws.Bool(true),
+	}
+	resp, err := svc.CreatePlacementGroup(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateReservedInstancesListing() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateReservedInstancesListingInput{
+		ClientToken:   aws.String("String"), // Required
+		InstanceCount: aws.Int64(1),         // Required
+		PriceSchedules: []*ec2.PriceScheduleSpecification{ // Required
+			{ // Required
+				CurrencyCode: aws.String("CurrencyCodeValues"),
+				Price:        aws.Float64(1.0),
+				Term:         aws.Int64(1),
+			},
+			// More values...
+		},
+		ReservedInstancesID: aws.String("String"), // Required
+	}
+	resp, err := svc.CreateReservedInstancesListing(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateRoute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateRouteInput{
+		DestinationCIDRBlock:   aws.String("String"), // Required
+		RouteTableID:           aws.String("String"), // Required
+		DryRun:                 aws.Bool(true),
+		GatewayID:              aws.String("String"),
+		InstanceID:             aws.String("String"),
+		NetworkInterfaceID:     aws.String("String"),
+		VPCPeeringConnectionID: aws.String("String"),
+	}
+	resp, err := svc.CreateRoute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateRouteTable() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateRouteTableInput{
+		VPCID:  aws.String("String"), // Required
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.CreateRouteTable(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateSecurityGroup() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateSecurityGroupInput{
+		Description: aws.String("String"), // Required
+		GroupName:   aws.String("String"), // Required
+		DryRun:      aws.Bool(true),
+		VPCID:       aws.String("String"),
+	}
+	resp, err := svc.CreateSecurityGroup(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateSnapshot() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateSnapshotInput{
+		VolumeID:    aws.String("String"), // Required
+		Description: aws.String("String"),
+		DryRun:      aws.Bool(true),
+	}
+	resp, err := svc.CreateSnapshot(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateSpotDatafeedSubscription() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateSpotDatafeedSubscriptionInput{
+		Bucket: aws.String("String"), // Required
+		DryRun: aws.Bool(true),
+		Prefix: aws.String("String"),
+	}
+	resp, err := svc.CreateSpotDatafeedSubscription(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateSubnet() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateSubnetInput{
+		CIDRBlock:        aws.String("String"), // Required
+		VPCID:            aws.String("String"), // Required
+		AvailabilityZone: aws.String("String"),
+		DryRun:           aws.Bool(true),
+	}
+	resp, err := svc.CreateSubnet(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateTags() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateTagsInput{
+		Resources: []*string{ // Required
+			aws.String("String"), // Required
+			// More values...
+		},
+		Tags: []*ec2.Tag{ // Required
+			{ // Required
+				Key:   aws.String("String"),
+				Value: aws.String("String"),
+			},
+			// More values...
+		},
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.CreateTags(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateVPC() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateVPCInput{
+		CIDRBlock:       aws.String("String"), // Required
+		DryRun:          aws.Bool(true),
+		InstanceTenancy: aws.String("Tenancy"),
+	}
+	resp, err := svc.CreateVPC(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateVPCEndpoint() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateVPCEndpointInput{
+		ServiceName:    aws.String("String"), // Required
+		VPCID:          aws.String("String"), // Required
+		ClientToken:    aws.String("String"),
+		DryRun:         aws.Bool(true),
+		PolicyDocument: aws.String("String"),
+		RouteTableIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.CreateVPCEndpoint(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateVPCPeeringConnection() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateVPCPeeringConnectionInput{
+		DryRun:      aws.Bool(true),
+		PeerOwnerID: aws.String("String"),
+		PeerVPCID:   aws.String("String"),
+		VPCID:       aws.String("String"),
+	}
+	resp, err := svc.CreateVPCPeeringConnection(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateVPNConnection() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateVPNConnectionInput{
+		CustomerGatewayID: aws.String("String"), // Required
+		Type:              aws.String("String"), // Required
+		VPNGatewayID:      aws.String("String"), // Required
+		DryRun:            aws.Bool(true),
+		Options: &ec2.VPNConnectionOptionsSpecification{
+			StaticRoutesOnly: aws.Bool(true),
+		},
+	}
+	resp, err := svc.CreateVPNConnection(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateVPNConnectionRoute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateVPNConnectionRouteInput{
+		DestinationCIDRBlock: aws.String("String"), // Required
+		VPNConnectionID:      aws.String("String"), // Required
+	}
+	resp, err := svc.CreateVPNConnectionRoute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateVPNGateway() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateVPNGatewayInput{
+		Type:             aws.String("GatewayType"), // Required
+		AvailabilityZone: aws.String("String"),
+		DryRun:           aws.Bool(true),
+	}
+	resp, err := svc.CreateVPNGateway(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_CreateVolume() {
+	svc := ec2.New(nil)
+
+	params := &ec2.CreateVolumeInput{
+		AvailabilityZone: aws.String("String"), // Required
+		DryRun:           aws.Bool(true),
+		Encrypted:        aws.Bool(true),
+		IOPS:             aws.Int64(1),
+		KMSKeyID:         aws.String("String"),
+		Size:             aws.Int64(1),
+		SnapshotID:       aws.String("String"),
+		VolumeType:       aws.String("VolumeType"),
+	}
+	resp, err := svc.CreateVolume(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteCustomerGateway() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteCustomerGatewayInput{
+		CustomerGatewayID: aws.String("String"), // Required
+		DryRun:            aws.Bool(true),
+	}
+	resp, err := svc.DeleteCustomerGateway(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteDHCPOptions() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteDHCPOptionsInput{
+		DHCPOptionsID: aws.String("String"), // Required
+		DryRun:        aws.Bool(true),
+	}
+	resp, err := svc.DeleteDHCPOptions(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteFlowLogs() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteFlowLogsInput{
+		FlowLogIDs: []*string{ // Required
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DeleteFlowLogs(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteInternetGateway() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteInternetGatewayInput{
+		InternetGatewayID: aws.String("String"), // Required
+		DryRun:            aws.Bool(true),
+	}
+	resp, err := svc.DeleteInternetGateway(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteKeyPair() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteKeyPairInput{
+		KeyName: aws.String("String"), // Required
+		DryRun:  aws.Bool(true),
+	}
+	resp, err := svc.DeleteKeyPair(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteNetworkACL() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteNetworkACLInput{
+		NetworkACLID: aws.String("String"), // Required
+		DryRun:       aws.Bool(true),
+	}
+	resp, err := svc.DeleteNetworkACL(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteNetworkACLEntry() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteNetworkACLEntryInput{
+		Egress:       aws.Bool(true),       // Required
+		NetworkACLID: aws.String("String"), // Required
+		RuleNumber:   aws.Int64(1),         // Required
+		DryRun:       aws.Bool(true),
+	}
+	resp, err := svc.DeleteNetworkACLEntry(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteNetworkInterface() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteNetworkInterfaceInput{
+		NetworkInterfaceID: aws.String("String"), // Required
+		DryRun:             aws.Bool(true),
+	}
+	resp, err := svc.DeleteNetworkInterface(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeletePlacementGroup() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeletePlacementGroupInput{
+		GroupName: aws.String("String"), // Required
+		DryRun:    aws.Bool(true),
+	}
+	resp, err := svc.DeletePlacementGroup(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteRoute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteRouteInput{
+		DestinationCIDRBlock: aws.String("String"), // Required
+		RouteTableID:         aws.String("String"), // Required
+		DryRun:               aws.Bool(true),
+	}
+	resp, err := svc.DeleteRoute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteRouteTable() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteRouteTableInput{
+		RouteTableID: aws.String("String"), // Required
+		DryRun:       aws.Bool(true),
+	}
+	resp, err := svc.DeleteRouteTable(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteSecurityGroup() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteSecurityGroupInput{
+		DryRun:    aws.Bool(true),
+		GroupID:   aws.String("String"),
+		GroupName: aws.String("String"),
+	}
+	resp, err := svc.DeleteSecurityGroup(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteSnapshot() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteSnapshotInput{
+		SnapshotID: aws.String("String"), // Required
+		DryRun:     aws.Bool(true),
+	}
+	resp, err := svc.DeleteSnapshot(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteSpotDatafeedSubscription() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteSpotDatafeedSubscriptionInput{
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.DeleteSpotDatafeedSubscription(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteSubnet() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteSubnetInput{
+		SubnetID: aws.String("String"), // Required
+		DryRun:   aws.Bool(true),
+	}
+	resp, err := svc.DeleteSubnet(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteTags() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteTagsInput{
+		Resources: []*string{ // Required
+			aws.String("String"), // Required
+			// More values...
+		},
+		DryRun: aws.Bool(true),
+		Tags: []*ec2.Tag{
+			{ // Required
+				Key:   aws.String("String"),
+				Value: aws.String("String"),
+			},
+			// More values...
+		},
+	}
+	resp, err := svc.DeleteTags(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteVPC() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteVPCInput{
+		VPCID:  aws.String("String"), // Required
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.DeleteVPC(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteVPCEndpoints() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteVPCEndpointsInput{
+		VPCEndpointIDs: []*string{ // Required
+			aws.String("String"), // Required
+			// More values...
+		},
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.DeleteVPCEndpoints(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteVPCPeeringConnection() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteVPCPeeringConnectionInput{
+		VPCPeeringConnectionID: aws.String("String"), // Required
+		DryRun:                 aws.Bool(true),
+	}
+	resp, err := svc.DeleteVPCPeeringConnection(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteVPNConnection() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteVPNConnectionInput{
+		VPNConnectionID: aws.String("String"), // Required
+		DryRun:          aws.Bool(true),
+	}
+	resp, err := svc.DeleteVPNConnection(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteVPNConnectionRoute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteVPNConnectionRouteInput{
+		DestinationCIDRBlock: aws.String("String"), // Required
+		VPNConnectionID:      aws.String("String"), // Required
+	}
+	resp, err := svc.DeleteVPNConnectionRoute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteVPNGateway() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteVPNGatewayInput{
+		VPNGatewayID: aws.String("String"), // Required
+		DryRun:       aws.Bool(true),
+	}
+	resp, err := svc.DeleteVPNGateway(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeleteVolume() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeleteVolumeInput{
+		VolumeID: aws.String("String"), // Required
+		DryRun:   aws.Bool(true),
+	}
+	resp, err := svc.DeleteVolume(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DeregisterImage() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DeregisterImageInput{
+		ImageID: aws.String("String"), // Required
+		DryRun:  aws.Bool(true),
+	}
+	resp, err := svc.DeregisterImage(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeAccountAttributes() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeAccountAttributesInput{
+		AttributeNames: []*string{
+			aws.String("AccountAttributeName"), // Required
+			// More values...
+		},
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.DescribeAccountAttributes(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeAddresses() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeAddressesInput{
+		AllocationIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		PublicIPs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeAddresses(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeAvailabilityZones() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeAvailabilityZonesInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		ZoneNames: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeAvailabilityZones(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeBundleTasks() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeBundleTasksInput{
+		BundleIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeBundleTasks(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeClassicLinkInstances() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeClassicLinkInstancesInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		InstanceIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		MaxResults: aws.Int64(1),
+		NextToken:  aws.String("String"),
+	}
+	resp, err := svc.DescribeClassicLinkInstances(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeConversionTasks() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeConversionTasksInput{
+		ConversionTaskIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeConversionTasks(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeCustomerGateways() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeCustomerGatewaysInput{
+		CustomerGatewayIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeCustomerGateways(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeDHCPOptions() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeDHCPOptionsInput{
+		DHCPOptionsIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeDHCPOptions(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeExportTasks() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeExportTasksInput{
+		ExportTaskIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeExportTasks(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeFlowLogs() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeFlowLogsInput{
+		Filter: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		FlowLogIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		MaxResults: aws.Int64(1),
+		NextToken:  aws.String("String"),
+	}
+	resp, err := svc.DescribeFlowLogs(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeImageAttribute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeImageAttributeInput{
+		Attribute: aws.String("ImageAttributeName"), // Required
+		ImageID:   aws.String("String"),             // Required
+		DryRun:    aws.Bool(true),
+	}
+	resp, err := svc.DescribeImageAttribute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeImages() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeImagesInput{
+		DryRun: aws.Bool(true),
+		ExecutableUsers: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		ImageIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		Owners: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeImages(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeImportImageTasks() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeImportImageTasksInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		ImportTaskIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		MaxResults: aws.Int64(1),
+		NextToken:  aws.String("String"),
+	}
+	resp, err := svc.DescribeImportImageTasks(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeImportSnapshotTasks() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeImportSnapshotTasksInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		ImportTaskIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		MaxResults: aws.Int64(1),
+		NextToken:  aws.String("String"),
+	}
+	resp, err := svc.DescribeImportSnapshotTasks(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeInstanceAttribute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeInstanceAttributeInput{
+		Attribute:  aws.String("InstanceAttributeName"), // Required
+		InstanceID: aws.String("String"),                // Required
+		DryRun:     aws.Bool(true),
+	}
+	resp, err := svc.DescribeInstanceAttribute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeInstanceStatus() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeInstanceStatusInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		IncludeAllInstances: aws.Bool(true),
+		InstanceIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		MaxResults: aws.Int64(1),
+		NextToken:  aws.String("String"),
+	}
+	resp, err := svc.DescribeInstanceStatus(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeInstances() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeInstancesInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		InstanceIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		MaxResults: aws.Int64(1),
+		NextToken:  aws.String("String"),
+	}
+	resp, err := svc.DescribeInstances(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeInternetGateways() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeInternetGatewaysInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		InternetGatewayIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeInternetGateways(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeKeyPairs() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeKeyPairsInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		KeyNames: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeKeyPairs(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeMovingAddresses() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeMovingAddressesInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		MaxResults: aws.Int64(1),
+		NextToken:  aws.String("String"),
+		PublicIPs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeMovingAddresses(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeNetworkACLs() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeNetworkACLsInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		NetworkACLIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeNetworkACLs(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeNetworkInterfaceAttribute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeNetworkInterfaceAttributeInput{
+		NetworkInterfaceID: aws.String("String"), // Required
+		Attribute:          aws.String("NetworkInterfaceAttribute"),
+		DryRun:             aws.Bool(true),
+	}
+	resp, err := svc.DescribeNetworkInterfaceAttribute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeNetworkInterfaces() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeNetworkInterfacesInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		NetworkInterfaceIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeNetworkInterfaces(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribePlacementGroups() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribePlacementGroupsInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		GroupNames: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribePlacementGroups(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribePrefixLists() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribePrefixListsInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		MaxResults: aws.Int64(1),
+		NextToken:  aws.String("String"),
+		PrefixListIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribePrefixLists(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeRegions() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeRegionsInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		RegionNames: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeRegions(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeReservedInstances() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeReservedInstancesInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		OfferingType: aws.String("OfferingTypeValues"),
+		ReservedInstancesIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeReservedInstances(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeReservedInstancesListings() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeReservedInstancesListingsInput{
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		ReservedInstancesID:        aws.String("String"),
+		ReservedInstancesListingID: aws.String("String"),
+	}
+	resp, err := svc.DescribeReservedInstancesListings(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeReservedInstancesModifications() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeReservedInstancesModificationsInput{
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		NextToken: aws.String("String"),
+		ReservedInstancesModificationIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeReservedInstancesModifications(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeReservedInstancesOfferings() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeReservedInstancesOfferingsInput{
+		AvailabilityZone: aws.String("String"),
+		DryRun:           aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		IncludeMarketplace: aws.Bool(true),
+		InstanceTenancy:    aws.String("Tenancy"),
+		InstanceType:       aws.String("InstanceType"),
+		MaxDuration:        aws.Int64(1),
+		MaxInstanceCount:   aws.Int64(1),
+		MaxResults:         aws.Int64(1),
+		MinDuration:        aws.Int64(1),
+		NextToken:          aws.String("String"),
+		OfferingType:       aws.String("OfferingTypeValues"),
+		ProductDescription: aws.String("RIProductDescription"),
+		ReservedInstancesOfferingIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeReservedInstancesOfferings(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeRouteTables() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeRouteTablesInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		RouteTableIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeRouteTables(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeSecurityGroups() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeSecurityGroupsInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		GroupIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		GroupNames: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeSecurityGroups(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeSnapshotAttribute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeSnapshotAttributeInput{
+		Attribute:  aws.String("SnapshotAttributeName"), // Required
+		SnapshotID: aws.String("String"),                // Required
+		DryRun:     aws.Bool(true),
+	}
+	resp, err := svc.DescribeSnapshotAttribute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeSnapshots() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeSnapshotsInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		MaxResults: aws.Int64(1),
+		NextToken:  aws.String("String"),
+		OwnerIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		RestorableByUserIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		SnapshotIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeSnapshots(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeSpotDatafeedSubscription() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeSpotDatafeedSubscriptionInput{
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.DescribeSpotDatafeedSubscription(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeSpotFleetInstances() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeSpotFleetInstancesInput{
+		SpotFleetRequestID: aws.String("String"), // Required
+		DryRun:             aws.Bool(true),
+		MaxResults:         aws.Int64(1),
+		NextToken:          aws.String("String"),
+	}
+	resp, err := svc.DescribeSpotFleetInstances(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeSpotFleetRequestHistory() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeSpotFleetRequestHistoryInput{
+		SpotFleetRequestID: aws.String("String"), // Required
+		StartTime:          aws.Time(time.Now()), // Required
+		DryRun:             aws.Bool(true),
+		EventType:          aws.String("EventType"),
+		MaxResults:         aws.Int64(1),
+		NextToken:          aws.String("String"),
+	}
+	resp, err := svc.DescribeSpotFleetRequestHistory(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeSpotFleetRequests() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeSpotFleetRequestsInput{
+		DryRun:     aws.Bool(true),
+		MaxResults: aws.Int64(1),
+		NextToken:  aws.String("String"),
+		SpotFleetRequestIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeSpotFleetRequests(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeSpotInstanceRequests() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeSpotInstanceRequestsInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		SpotInstanceRequestIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeSpotInstanceRequests(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeSpotPriceHistory() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeSpotPriceHistoryInput{
+		AvailabilityZone: aws.String("String"),
+		DryRun:           aws.Bool(true),
+		EndTime:          aws.Time(time.Now()),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		InstanceTypes: []*string{
+			aws.String("InstanceType"), // Required
+			// More values...
+		},
+		MaxResults: aws.Int64(1),
+		NextToken:  aws.String("String"),
+		ProductDescriptions: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		StartTime: aws.Time(time.Now()),
+	}
+	resp, err := svc.DescribeSpotPriceHistory(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeSubnets() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeSubnetsInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		SubnetIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeSubnets(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeTags() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeTagsInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		MaxResults: aws.Int64(1),
+		NextToken:  aws.String("String"),
+	}
+	resp, err := svc.DescribeTags(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeVPCAttribute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeVPCAttributeInput{
+		VPCID:     aws.String("String"), // Required
+		Attribute: aws.String("VpcAttributeName"),
+		DryRun:    aws.Bool(true),
+	}
+	resp, err := svc.DescribeVPCAttribute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeVPCClassicLink() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeVPCClassicLinkInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		VPCIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeVPCClassicLink(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeVPCEndpointServices() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeVPCEndpointServicesInput{
+		DryRun:     aws.Bool(true),
+		MaxResults: aws.Int64(1),
+		NextToken:  aws.String("String"),
+	}
+	resp, err := svc.DescribeVPCEndpointServices(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeVPCEndpoints() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeVPCEndpointsInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		MaxResults: aws.Int64(1),
+		NextToken:  aws.String("String"),
+		VPCEndpointIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeVPCEndpoints(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeVPCPeeringConnections() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeVPCPeeringConnectionsInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		VPCPeeringConnectionIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeVPCPeeringConnections(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeVPCs() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeVPCsInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		VPCIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeVPCs(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeVPNConnections() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeVPNConnectionsInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		VPNConnectionIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeVPNConnections(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeVPNGateways() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeVPNGatewaysInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		VPNGatewayIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeVPNGateways(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeVolumeAttribute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeVolumeAttributeInput{
+		VolumeID:  aws.String("String"), // Required
+		Attribute: aws.String("VolumeAttributeName"),
+		DryRun:    aws.Bool(true),
+	}
+	resp, err := svc.DescribeVolumeAttribute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeVolumeStatus() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeVolumeStatusInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		MaxResults: aws.Int64(1),
+		NextToken:  aws.String("String"),
+		VolumeIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeVolumeStatus(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DescribeVolumes() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DescribeVolumesInput{
+		DryRun: aws.Bool(true),
+		Filters: []*ec2.Filter{
+			{ // Required
+				Name: aws.String("String"),
+				Values: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+			},
+			// More values...
+		},
+		MaxResults: aws.Int64(1),
+		NextToken:  aws.String("String"),
+		VolumeIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.DescribeVolumes(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DetachClassicLinkVPC() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DetachClassicLinkVPCInput{
+		InstanceID: aws.String("String"), // Required
+		VPCID:      aws.String("String"), // Required
+		DryRun:     aws.Bool(true),
+	}
+	resp, err := svc.DetachClassicLinkVPC(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DetachInternetGateway() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DetachInternetGatewayInput{
+		InternetGatewayID: aws.String("String"), // Required
+		VPCID:             aws.String("String"), // Required
+		DryRun:            aws.Bool(true),
+	}
+	resp, err := svc.DetachInternetGateway(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DetachNetworkInterface() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DetachNetworkInterfaceInput{
+		AttachmentID: aws.String("String"), // Required
+		DryRun:       aws.Bool(true),
+		Force:        aws.Bool(true),
+	}
+	resp, err := svc.DetachNetworkInterface(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DetachVPNGateway() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DetachVPNGatewayInput{
+		VPCID:        aws.String("String"), // Required
+		VPNGatewayID: aws.String("String"), // Required
+		DryRun:       aws.Bool(true),
+	}
+	resp, err := svc.DetachVPNGateway(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DetachVolume() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DetachVolumeInput{
+		VolumeID:   aws.String("String"), // Required
+		Device:     aws.String("String"),
+		DryRun:     aws.Bool(true),
+		Force:      aws.Bool(true),
+		InstanceID: aws.String("String"),
+	}
+	resp, err := svc.DetachVolume(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DisableVGWRoutePropagation() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DisableVGWRoutePropagationInput{
+		GatewayID:    aws.String("String"), // Required
+		RouteTableID: aws.String("String"), // Required
+	}
+	resp, err := svc.DisableVGWRoutePropagation(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DisableVPCClassicLink() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DisableVPCClassicLinkInput{
+		VPCID:  aws.String("String"), // Required
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.DisableVPCClassicLink(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DisassociateAddress() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DisassociateAddressInput{
+		AssociationID: aws.String("String"),
+		DryRun:        aws.Bool(true),
+		PublicIP:      aws.String("String"),
+	}
+	resp, err := svc.DisassociateAddress(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_DisassociateRouteTable() {
+	svc := ec2.New(nil)
+
+	params := &ec2.DisassociateRouteTableInput{
+		AssociationID: aws.String("String"), // Required
+		DryRun:        aws.Bool(true),
+	}
+	resp, err := svc.DisassociateRouteTable(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_EnableVGWRoutePropagation() {
+	svc := ec2.New(nil)
+
+	params := &ec2.EnableVGWRoutePropagationInput{
+		GatewayID:    aws.String("String"), // Required
+		RouteTableID: aws.String("String"), // Required
+	}
+	resp, err := svc.EnableVGWRoutePropagation(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_EnableVPCClassicLink() {
+	svc := ec2.New(nil)
+
+	params := &ec2.EnableVPCClassicLinkInput{
+		VPCID:  aws.String("String"), // Required
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.EnableVPCClassicLink(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_EnableVolumeIO() {
+	svc := ec2.New(nil)
+
+	params := &ec2.EnableVolumeIOInput{
+		VolumeID: aws.String("String"), // Required
+		DryRun:   aws.Bool(true),
+	}
+	resp, err := svc.EnableVolumeIO(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_GetConsoleOutput() {
+	svc := ec2.New(nil)
+
+	params := &ec2.GetConsoleOutputInput{
+		InstanceID: aws.String("String"), // Required
+		DryRun:     aws.Bool(true),
+	}
+	resp, err := svc.GetConsoleOutput(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_GetPasswordData() {
+	svc := ec2.New(nil)
+
+	params := &ec2.GetPasswordDataInput{
+		InstanceID: aws.String("String"), // Required
+		DryRun:     aws.Bool(true),
+	}
+	resp, err := svc.GetPasswordData(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ImportImage() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ImportImageInput{
+		Architecture: aws.String("String"),
+		ClientData: &ec2.ClientData{
+			Comment:     aws.String("String"),
+			UploadEnd:   aws.Time(time.Now()),
+			UploadSize:  aws.Float64(1.0),
+			UploadStart: aws.Time(time.Now()),
+		},
+		ClientToken: aws.String("String"),
+		Description: aws.String("String"),
+		DiskContainers: []*ec2.ImageDiskContainer{
+			{ // Required
+				Description: aws.String("String"),
+				DeviceName:  aws.String("String"),
+				Format:      aws.String("String"),
+				SnapshotID:  aws.String("String"),
+				URL:         aws.String("String"),
+				UserBucket: &ec2.UserBucket{
+					S3Bucket: aws.String("String"),
+					S3Key:    aws.String("String"),
+				},
+			},
+			// More values...
+		},
+		DryRun:      aws.Bool(true),
+		Hypervisor:  aws.String("String"),
+		LicenseType: aws.String("String"),
+		Platform:    aws.String("String"),
+		RoleName:    aws.String("String"),
+	}
+	resp, err := svc.ImportImage(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ImportInstance() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ImportInstanceInput{
+		Platform:    aws.String("PlatformValues"), // Required
+		Description: aws.String("String"),
+		DiskImages: []*ec2.DiskImage{
+			{ // Required
+				Description: aws.String("String"),
+				Image: &ec2.DiskImageDetail{
+					Bytes:             aws.Int64(1),                  // Required
+					Format:            aws.String("DiskImageFormat"), // Required
+					ImportManifestURL: aws.String("String"),          // Required
+				},
+				Volume: &ec2.VolumeDetail{
+					Size: aws.Int64(1), // Required
+				},
+			},
+			// More values...
+		},
+		DryRun: aws.Bool(true),
+		LaunchSpecification: &ec2.ImportInstanceLaunchSpecification{
+			AdditionalInfo: aws.String("String"),
+			Architecture:   aws.String("ArchitectureValues"),
+			GroupIDs: []*string{
+				aws.String("String"), // Required
+				// More values...
+			},
+			GroupNames: []*string{
+				aws.String("String"), // Required
+				// More values...
+			},
+			InstanceInitiatedShutdownBehavior: aws.String("ShutdownBehavior"),
+			InstanceType:                      aws.String("InstanceType"),
+			Monitoring:                        aws.Bool(true),
+			Placement: &ec2.Placement{
+				AvailabilityZone: aws.String("String"),
+				GroupName:        aws.String("String"),
+				Tenancy:          aws.String("Tenancy"),
+			},
+			PrivateIPAddress: aws.String("String"),
+			SubnetID:         aws.String("String"),
+			UserData: &ec2.UserData{
+				Data: aws.String("String"),
+			},
+		},
+	}
+	resp, err := svc.ImportInstance(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ImportKeyPair() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ImportKeyPairInput{
+		KeyName:           aws.String("String"), // Required
+		PublicKeyMaterial: []byte("PAYLOAD"),    // Required
+		DryRun:            aws.Bool(true),
+	}
+	resp, err := svc.ImportKeyPair(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ImportSnapshot() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ImportSnapshotInput{
+		ClientData: &ec2.ClientData{
+			Comment:     aws.String("String"),
+			UploadEnd:   aws.Time(time.Now()),
+			UploadSize:  aws.Float64(1.0),
+			UploadStart: aws.Time(time.Now()),
+		},
+		ClientToken: aws.String("String"),
+		Description: aws.String("String"),
+		DiskContainer: &ec2.SnapshotDiskContainer{
+			Description: aws.String("String"),
+			Format:      aws.String("String"),
+			URL:         aws.String("String"),
+			UserBucket: &ec2.UserBucket{
+				S3Bucket: aws.String("String"),
+				S3Key:    aws.String("String"),
+			},
+		},
+		DryRun:   aws.Bool(true),
+		RoleName: aws.String("String"),
+	}
+	resp, err := svc.ImportSnapshot(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ImportVolume() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ImportVolumeInput{
+		AvailabilityZone: aws.String("String"), // Required
+		Image: &ec2.DiskImageDetail{ // Required
+			Bytes:             aws.Int64(1),                  // Required
+			Format:            aws.String("DiskImageFormat"), // Required
+			ImportManifestURL: aws.String("String"),          // Required
+		},
+		Volume: &ec2.VolumeDetail{ // Required
+			Size: aws.Int64(1), // Required
+		},
+		Description: aws.String("String"),
+		DryRun:      aws.Bool(true),
+	}
+	resp, err := svc.ImportVolume(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ModifyImageAttribute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ModifyImageAttributeInput{
+		ImageID:   aws.String("String"), // Required
+		Attribute: aws.String("String"),
+		Description: &ec2.AttributeValue{
+			Value: aws.String("String"),
+		},
+		DryRun: aws.Bool(true),
+		LaunchPermission: &ec2.LaunchPermissionModifications{
+			Add: []*ec2.LaunchPermission{
+				{ // Required
+					Group:  aws.String("PermissionGroup"),
+					UserID: aws.String("String"),
+				},
+				// More values...
+			},
+			Remove: []*ec2.LaunchPermission{
+				{ // Required
+					Group:  aws.String("PermissionGroup"),
+					UserID: aws.String("String"),
+				},
+				// More values...
+			},
+		},
+		OperationType: aws.String("String"),
+		ProductCodes: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		UserGroups: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		UserIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		Value: aws.String("String"),
+	}
+	resp, err := svc.ModifyImageAttribute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ModifyInstanceAttribute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ModifyInstanceAttributeInput{
+		InstanceID: aws.String("String"), // Required
+		Attribute:  aws.String("InstanceAttributeName"),
+		BlockDeviceMappings: []*ec2.InstanceBlockDeviceMappingSpecification{
+			{ // Required
+				DeviceName: aws.String("String"),
+				EBS: &ec2.EBSInstanceBlockDeviceSpecification{
+					DeleteOnTermination: aws.Bool(true),
+					VolumeID:            aws.String("String"),
+				},
+				NoDevice:    aws.String("String"),
+				VirtualName: aws.String("String"),
+			},
+			// More values...
+		},
+		DisableAPITermination: &ec2.AttributeBooleanValue{
+			Value: aws.Bool(true),
+		},
+		DryRun: aws.Bool(true),
+		EBSOptimized: &ec2.AttributeBooleanValue{
+			Value: aws.Bool(true),
+		},
+		Groups: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		InstanceInitiatedShutdownBehavior: &ec2.AttributeValue{
+			Value: aws.String("String"),
+		},
+		InstanceType: &ec2.AttributeValue{
+			Value: aws.String("String"),
+		},
+		Kernel: &ec2.AttributeValue{
+			Value: aws.String("String"),
+		},
+		RAMDisk: &ec2.AttributeValue{
+			Value: aws.String("String"),
+		},
+		SRIOVNetSupport: &ec2.AttributeValue{
+			Value: aws.String("String"),
+		},
+		SourceDestCheck: &ec2.AttributeBooleanValue{
+			Value: aws.Bool(true),
+		},
+		UserData: &ec2.BlobAttributeValue{
+			Value: []byte("PAYLOAD"),
+		},
+		Value: aws.String("String"),
+	}
+	resp, err := svc.ModifyInstanceAttribute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ModifyNetworkInterfaceAttribute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ModifyNetworkInterfaceAttributeInput{
+		NetworkInterfaceID: aws.String("String"), // Required
+		Attachment: &ec2.NetworkInterfaceAttachmentChanges{
+			AttachmentID:        aws.String("String"),
+			DeleteOnTermination: aws.Bool(true),
+		},
+		Description: &ec2.AttributeValue{
+			Value: aws.String("String"),
+		},
+		DryRun: aws.Bool(true),
+		Groups: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		SourceDestCheck: &ec2.AttributeBooleanValue{
+			Value: aws.Bool(true),
+		},
+	}
+	resp, err := svc.ModifyNetworkInterfaceAttribute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ModifyReservedInstances() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ModifyReservedInstancesInput{
+		ReservedInstancesIDs: []*string{ // Required
+			aws.String("String"), // Required
+			// More values...
+		},
+		TargetConfigurations: []*ec2.ReservedInstancesConfiguration{ // Required
+			{ // Required
+				AvailabilityZone: aws.String("String"),
+				InstanceCount:    aws.Int64(1),
+				InstanceType:     aws.String("InstanceType"),
+				Platform:         aws.String("String"),
+			},
+			// More values...
+		},
+		ClientToken: aws.String("String"),
+	}
+	resp, err := svc.ModifyReservedInstances(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ModifySnapshotAttribute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ModifySnapshotAttributeInput{
+		SnapshotID: aws.String("String"), // Required
+		Attribute:  aws.String("SnapshotAttributeName"),
+		CreateVolumePermission: &ec2.CreateVolumePermissionModifications{
+			Add: []*ec2.CreateVolumePermission{
+				{ // Required
+					Group:  aws.String("PermissionGroup"),
+					UserID: aws.String("String"),
+				},
+				// More values...
+			},
+			Remove: []*ec2.CreateVolumePermission{
+				{ // Required
+					Group:  aws.String("PermissionGroup"),
+					UserID: aws.String("String"),
+				},
+				// More values...
+			},
+		},
+		DryRun: aws.Bool(true),
+		GroupNames: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		OperationType: aws.String("String"),
+		UserIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.ModifySnapshotAttribute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ModifySubnetAttribute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ModifySubnetAttributeInput{
+		SubnetID: aws.String("String"), // Required
+		MapPublicIPOnLaunch: &ec2.AttributeBooleanValue{
+			Value: aws.Bool(true),
+		},
+	}
+	resp, err := svc.ModifySubnetAttribute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ModifyVPCAttribute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ModifyVPCAttributeInput{
+		VPCID: aws.String("String"), // Required
+		EnableDNSHostnames: &ec2.AttributeBooleanValue{
+			Value: aws.Bool(true),
+		},
+		EnableDNSSupport: &ec2.AttributeBooleanValue{
+			Value: aws.Bool(true),
+		},
+	}
+	resp, err := svc.ModifyVPCAttribute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ModifyVPCEndpoint() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ModifyVPCEndpointInput{
+		VPCEndpointID: aws.String("String"), // Required
+		AddRouteTableIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		DryRun:         aws.Bool(true),
+		PolicyDocument: aws.String("String"),
+		RemoveRouteTableIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		ResetPolicy: aws.Bool(true),
+	}
+	resp, err := svc.ModifyVPCEndpoint(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ModifyVolumeAttribute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ModifyVolumeAttributeInput{
+		VolumeID: aws.String("String"), // Required
+		AutoEnableIO: &ec2.AttributeBooleanValue{
+			Value: aws.Bool(true),
+		},
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.ModifyVolumeAttribute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_MonitorInstances() {
+	svc := ec2.New(nil)
+
+	params := &ec2.MonitorInstancesInput{
+		InstanceIDs: []*string{ // Required
+			aws.String("String"), // Required
+			// More values...
+		},
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.MonitorInstances(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_MoveAddressToVPC() {
+	svc := ec2.New(nil)
+
+	params := &ec2.MoveAddressToVPCInput{
+		PublicIP: aws.String("String"), // Required
+		DryRun:   aws.Bool(true),
+	}
+	resp, err := svc.MoveAddressToVPC(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_PurchaseReservedInstancesOffering() {
+	svc := ec2.New(nil)
+
+	params := &ec2.PurchaseReservedInstancesOfferingInput{
+		InstanceCount:               aws.Int64(1),         // Required
+		ReservedInstancesOfferingID: aws.String("String"), // Required
+		DryRun: aws.Bool(true),
+		LimitPrice: &ec2.ReservedInstanceLimitPrice{
+			Amount:       aws.Float64(1.0),
+			CurrencyCode: aws.String("CurrencyCodeValues"),
+		},
+	}
+	resp, err := svc.PurchaseReservedInstancesOffering(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_RebootInstances() {
+	svc := ec2.New(nil)
+
+	params := &ec2.RebootInstancesInput{
+		InstanceIDs: []*string{ // Required
+			aws.String("String"), // Required
+			// More values...
+		},
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.RebootInstances(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_RegisterImage() {
+	svc := ec2.New(nil)
+
+	params := &ec2.RegisterImageInput{
+		Name:         aws.String("String"), // Required
+		Architecture: aws.String("ArchitectureValues"),
+		BlockDeviceMappings: []*ec2.BlockDeviceMapping{
+			{ // Required
+				DeviceName: aws.String("String"),
+				EBS: &ec2.EBSBlockDevice{
+					DeleteOnTermination: aws.Bool(true),
+					Encrypted:           aws.Bool(true),
+					IOPS:                aws.Int64(1),
+					SnapshotID:          aws.String("String"),
+					VolumeSize:          aws.Int64(1),
+					VolumeType:          aws.String("VolumeType"),
+				},
+				NoDevice:    aws.String("String"),
+				VirtualName: aws.String("String"),
+			},
+			// More values...
+		},
+		Description:        aws.String("String"),
+		DryRun:             aws.Bool(true),
+		ImageLocation:      aws.String("String"),
+		KernelID:           aws.String("String"),
+		RAMDiskID:          aws.String("String"),
+		RootDeviceName:     aws.String("String"),
+		SRIOVNetSupport:    aws.String("String"),
+		VirtualizationType: aws.String("String"),
+	}
+	resp, err := svc.RegisterImage(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_RejectVPCPeeringConnection() {
+	svc := ec2.New(nil)
+
+	params := &ec2.RejectVPCPeeringConnectionInput{
+		VPCPeeringConnectionID: aws.String("String"), // Required
+		DryRun:                 aws.Bool(true),
+	}
+	resp, err := svc.RejectVPCPeeringConnection(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ReleaseAddress() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ReleaseAddressInput{
+		AllocationID: aws.String("String"),
+		DryRun:       aws.Bool(true),
+		PublicIP:     aws.String("String"),
+	}
+	resp, err := svc.ReleaseAddress(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ReplaceNetworkACLAssociation() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ReplaceNetworkACLAssociationInput{
+		AssociationID: aws.String("String"), // Required
+		NetworkACLID:  aws.String("String"), // Required
+		DryRun:        aws.Bool(true),
+	}
+	resp, err := svc.ReplaceNetworkACLAssociation(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ReplaceNetworkACLEntry() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ReplaceNetworkACLEntryInput{
+		CIDRBlock:    aws.String("String"),     // Required
+		Egress:       aws.Bool(true),           // Required
+		NetworkACLID: aws.String("String"),     // Required
+		Protocol:     aws.String("String"),     // Required
+		RuleAction:   aws.String("RuleAction"), // Required
+		RuleNumber:   aws.Int64(1),             // Required
+		DryRun:       aws.Bool(true),
+		ICMPTypeCode: &ec2.ICMPTypeCode{
+			Code: aws.Int64(1),
+			Type: aws.Int64(1),
+		},
+		PortRange: &ec2.PortRange{
+			From: aws.Int64(1),
+			To:   aws.Int64(1),
+		},
+	}
+	resp, err := svc.ReplaceNetworkACLEntry(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ReplaceRoute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ReplaceRouteInput{
+		DestinationCIDRBlock:   aws.String("String"), // Required
+		RouteTableID:           aws.String("String"), // Required
+		DryRun:                 aws.Bool(true),
+		GatewayID:              aws.String("String"),
+		InstanceID:             aws.String("String"),
+		NetworkInterfaceID:     aws.String("String"),
+		VPCPeeringConnectionID: aws.String("String"),
+	}
+	resp, err := svc.ReplaceRoute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ReplaceRouteTableAssociation() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ReplaceRouteTableAssociationInput{
+		AssociationID: aws.String("String"), // Required
+		RouteTableID:  aws.String("String"), // Required
+		DryRun:        aws.Bool(true),
+	}
+	resp, err := svc.ReplaceRouteTableAssociation(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ReportInstanceStatus() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ReportInstanceStatusInput{
+		Instances: []*string{ // Required
+			aws.String("String"), // Required
+			// More values...
+		},
+		ReasonCodes: []*string{ // Required
+			aws.String("ReportInstanceReasonCodes"), // Required
+			// More values...
+		},
+		Status:      aws.String("ReportStatusType"), // Required
+		Description: aws.String("String"),
+		DryRun:      aws.Bool(true),
+		EndTime:     aws.Time(time.Now()),
+		StartTime:   aws.Time(time.Now()),
+	}
+	resp, err := svc.ReportInstanceStatus(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_RequestSpotFleet() {
+	svc := ec2.New(nil)
+
+	params := &ec2.RequestSpotFleetInput{
+		SpotFleetRequestConfig: &ec2.SpotFleetRequestConfigData{ // Required
+			IAMFleetRole: aws.String("String"), // Required
+			LaunchSpecifications: []*ec2.SpotFleetLaunchSpecification{ // Required
+				{ // Required
+					AddressingType: aws.String("String"),
+					BlockDeviceMappings: []*ec2.BlockDeviceMapping{
+						{ // Required
+							DeviceName: aws.String("String"),
+							EBS: &ec2.EBSBlockDevice{
+								DeleteOnTermination: aws.Bool(true),
+								Encrypted:           aws.Bool(true),
+								IOPS:                aws.Int64(1),
+								SnapshotID:          aws.String("String"),
+								VolumeSize:          aws.Int64(1),
+								VolumeType:          aws.String("VolumeType"),
+							},
+							NoDevice:    aws.String("String"),
+							VirtualName: aws.String("String"),
+						},
+						// More values...
+					},
+					EBSOptimized: aws.Bool(true),
+					IAMInstanceProfile: &ec2.IAMInstanceProfileSpecification{
+						ARN:  aws.String("String"),
+						Name: aws.String("String"),
+					},
+					ImageID:      aws.String("String"),
+					InstanceType: aws.String("InstanceType"),
+					KernelID:     aws.String("String"),
+					KeyName:      aws.String("String"),
+					Monitoring: &ec2.SpotFleetMonitoring{
+						Enabled: aws.Bool(true),
+					},
+					NetworkInterfaces: []*ec2.InstanceNetworkInterfaceSpecification{
+						{ // Required
+							AssociatePublicIPAddress: aws.Bool(true),
+							DeleteOnTermination:      aws.Bool(true),
+							Description:              aws.String("String"),
+							DeviceIndex:              aws.Int64(1),
+							Groups: []*string{
+								aws.String("String"), // Required
+								// More values...
+							},
+							NetworkInterfaceID: aws.String("String"),
+							PrivateIPAddress:   aws.String("String"),
+							PrivateIPAddresses: []*ec2.PrivateIPAddressSpecification{
+								{ // Required
+									PrivateIPAddress: aws.String("String"), // Required
+									Primary:          aws.Bool(true),
+								},
+								// More values...
+							},
+							SecondaryPrivateIPAddressCount: aws.Int64(1),
+							SubnetID:                       aws.String("String"),
+						},
+						// More values...
+					},
+					Placement: &ec2.SpotPlacement{
+						AvailabilityZone: aws.String("String"),
+						GroupName:        aws.String("String"),
+					},
+					RAMDiskID: aws.String("String"),
+					SecurityGroups: []*ec2.GroupIdentifier{
+						{ // Required
+							GroupID:   aws.String("String"),
+							GroupName: aws.String("String"),
+						},
+						// More values...
+					},
+					SubnetID: aws.String("String"),
+					UserData: aws.String("String"),
+				},
+				// More values...
+			},
+			SpotPrice:                        aws.String("String"), // Required
+			TargetCapacity:                   aws.Int64(1),         // Required
+			ClientToken:                      aws.String("String"),
+			TerminateInstancesWithExpiration: aws.Bool(true),
+			ValidFrom:                        aws.Time(time.Now()),
+			ValidUntil:                       aws.Time(time.Now()),
+		},
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.RequestSpotFleet(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_RequestSpotInstances() {
+	svc := ec2.New(nil)
+
+	params := &ec2.RequestSpotInstancesInput{
+		SpotPrice:             aws.String("String"), // Required
+		AvailabilityZoneGroup: aws.String("String"),
+		ClientToken:           aws.String("String"),
+		DryRun:                aws.Bool(true),
+		InstanceCount:         aws.Int64(1),
+		LaunchGroup:           aws.String("String"),
+		LaunchSpecification: &ec2.RequestSpotLaunchSpecification{
+			AddressingType: aws.String("String"),
+			BlockDeviceMappings: []*ec2.BlockDeviceMapping{
+				{ // Required
+					DeviceName: aws.String("String"),
+					EBS: &ec2.EBSBlockDevice{
+						DeleteOnTermination: aws.Bool(true),
+						Encrypted:           aws.Bool(true),
+						IOPS:                aws.Int64(1),
+						SnapshotID:          aws.String("String"),
+						VolumeSize:          aws.Int64(1),
+						VolumeType:          aws.String("VolumeType"),
+					},
+					NoDevice:    aws.String("String"),
+					VirtualName: aws.String("String"),
+				},
+				// More values...
+			},
+			EBSOptimized: aws.Bool(true),
+			IAMInstanceProfile: &ec2.IAMInstanceProfileSpecification{
+				ARN:  aws.String("String"),
+				Name: aws.String("String"),
+			},
+			ImageID:      aws.String("String"),
+			InstanceType: aws.String("InstanceType"),
+			KernelID:     aws.String("String"),
+			KeyName:      aws.String("String"),
+			Monitoring: &ec2.RunInstancesMonitoringEnabled{
+				Enabled: aws.Bool(true), // Required
+			},
+			NetworkInterfaces: []*ec2.InstanceNetworkInterfaceSpecification{
+				{ // Required
+					AssociatePublicIPAddress: aws.Bool(true),
+					DeleteOnTermination:      aws.Bool(true),
+					Description:              aws.String("String"),
+					DeviceIndex:              aws.Int64(1),
+					Groups: []*string{
+						aws.String("String"), // Required
+						// More values...
+					},
+					NetworkInterfaceID: aws.String("String"),
+					PrivateIPAddress:   aws.String("String"),
+					PrivateIPAddresses: []*ec2.PrivateIPAddressSpecification{
+						{ // Required
+							PrivateIPAddress: aws.String("String"), // Required
+							Primary:          aws.Bool(true),
+						},
+						// More values...
+					},
+					SecondaryPrivateIPAddressCount: aws.Int64(1),
+					SubnetID:                       aws.String("String"),
+				},
+				// More values...
+			},
+			Placement: &ec2.SpotPlacement{
+				AvailabilityZone: aws.String("String"),
+				GroupName:        aws.String("String"),
+			},
+			RAMDiskID: aws.String("String"),
+			SecurityGroupIDs: []*string{
+				aws.String("String"), // Required
+				// More values...
+			},
+			SecurityGroups: []*string{
+				aws.String("String"), // Required
+				// More values...
+			},
+			SubnetID: aws.String("String"),
+			UserData: aws.String("String"),
+		},
+		Type:       aws.String("SpotInstanceType"),
+		ValidFrom:  aws.Time(time.Now()),
+		ValidUntil: aws.Time(time.Now()),
+	}
+	resp, err := svc.RequestSpotInstances(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ResetImageAttribute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ResetImageAttributeInput{
+		Attribute: aws.String("ResetImageAttributeName"), // Required
+		ImageID:   aws.String("String"),                  // Required
+		DryRun:    aws.Bool(true),
+	}
+	resp, err := svc.ResetImageAttribute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ResetInstanceAttribute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ResetInstanceAttributeInput{
+		Attribute:  aws.String("InstanceAttributeName"), // Required
+		InstanceID: aws.String("String"),                // Required
+		DryRun:     aws.Bool(true),
+	}
+	resp, err := svc.ResetInstanceAttribute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ResetNetworkInterfaceAttribute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ResetNetworkInterfaceAttributeInput{
+		NetworkInterfaceID: aws.String("String"), // Required
+		DryRun:             aws.Bool(true),
+		SourceDestCheck:    aws.String("String"),
+	}
+	resp, err := svc.ResetNetworkInterfaceAttribute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_ResetSnapshotAttribute() {
+	svc := ec2.New(nil)
+
+	params := &ec2.ResetSnapshotAttributeInput{
+		Attribute:  aws.String("SnapshotAttributeName"), // Required
+		SnapshotID: aws.String("String"),                // Required
+		DryRun:     aws.Bool(true),
+	}
+	resp, err := svc.ResetSnapshotAttribute(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_RestoreAddressToClassic() {
+	svc := ec2.New(nil)
+
+	params := &ec2.RestoreAddressToClassicInput{
+		PublicIP: aws.String("String"), // Required
+		DryRun:   aws.Bool(true),
+	}
+	resp, err := svc.RestoreAddressToClassic(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_RevokeSecurityGroupEgress() {
+	svc := ec2.New(nil)
+
+	params := &ec2.RevokeSecurityGroupEgressInput{
+		GroupID:  aws.String("String"), // Required
+		CIDRIP:   aws.String("String"),
+		DryRun:   aws.Bool(true),
+		FromPort: aws.Int64(1),
+		IPPermissions: []*ec2.IPPermission{
+			{ // Required
+				FromPort:   aws.Int64(1),
+				IPProtocol: aws.String("String"),
+				IPRanges: []*ec2.IPRange{
+					{ // Required
+						CIDRIP: aws.String("String"),
+					},
+					// More values...
+				},
+				PrefixListIDs: []*ec2.PrefixListID{
+					{ // Required
+						PrefixListID: aws.String("String"),
+					},
+					// More values...
+				},
+				ToPort: aws.Int64(1),
+				UserIDGroupPairs: []*ec2.UserIDGroupPair{
+					{ // Required
+						GroupID:   aws.String("String"),
+						GroupName: aws.String("String"),
+						UserID:    aws.String("String"),
+					},
+					// More values...
+				},
+			},
+			// More values...
+		},
+		IPProtocol:                 aws.String("String"),
+		SourceSecurityGroupName:    aws.String("String"),
+		SourceSecurityGroupOwnerID: aws.String("String"),
+		ToPort: aws.Int64(1),
+	}
+	resp, err := svc.RevokeSecurityGroupEgress(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_RevokeSecurityGroupIngress() {
+	svc := ec2.New(nil)
+
+	params := &ec2.RevokeSecurityGroupIngressInput{
+		CIDRIP:    aws.String("String"),
+		DryRun:    aws.Bool(true),
+		FromPort:  aws.Int64(1),
+		GroupID:   aws.String("String"),
+		GroupName: aws.String("String"),
+		IPPermissions: []*ec2.IPPermission{
+			{ // Required
+				FromPort:   aws.Int64(1),
+				IPProtocol: aws.String("String"),
+				IPRanges: []*ec2.IPRange{
+					{ // Required
+						CIDRIP: aws.String("String"),
+					},
+					// More values...
+				},
+				PrefixListIDs: []*ec2.PrefixListID{
+					{ // Required
+						PrefixListID: aws.String("String"),
+					},
+					// More values...
+				},
+				ToPort: aws.Int64(1),
+				UserIDGroupPairs: []*ec2.UserIDGroupPair{
+					{ // Required
+						GroupID:   aws.String("String"),
+						GroupName: aws.String("String"),
+						UserID:    aws.String("String"),
+					},
+					// More values...
+				},
+			},
+			// More values...
+		},
+		IPProtocol:                 aws.String("String"),
+		SourceSecurityGroupName:    aws.String("String"),
+		SourceSecurityGroupOwnerID: aws.String("String"),
+		ToPort: aws.Int64(1),
+	}
+	resp, err := svc.RevokeSecurityGroupIngress(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_RunInstances() {
+	svc := ec2.New(nil)
+
+	params := &ec2.RunInstancesInput{
+		ImageID:        aws.String("String"), // Required
+		MaxCount:       aws.Int64(1),         // Required
+		MinCount:       aws.Int64(1),         // Required
+		AdditionalInfo: aws.String("String"),
+		BlockDeviceMappings: []*ec2.BlockDeviceMapping{
+			{ // Required
+				DeviceName: aws.String("String"),
+				EBS: &ec2.EBSBlockDevice{
+					DeleteOnTermination: aws.Bool(true),
+					Encrypted:           aws.Bool(true),
+					IOPS:                aws.Int64(1),
+					SnapshotID:          aws.String("String"),
+					VolumeSize:          aws.Int64(1),
+					VolumeType:          aws.String("VolumeType"),
+				},
+				NoDevice:    aws.String("String"),
+				VirtualName: aws.String("String"),
+			},
+			// More values...
+		},
+		ClientToken:           aws.String("String"),
+		DisableAPITermination: aws.Bool(true),
+		DryRun:                aws.Bool(true),
+		EBSOptimized:          aws.Bool(true),
+		IAMInstanceProfile: &ec2.IAMInstanceProfileSpecification{
+			ARN:  aws.String("String"),
+			Name: aws.String("String"),
+		},
+		InstanceInitiatedShutdownBehavior: aws.String("ShutdownBehavior"),
+		InstanceType:                      aws.String("InstanceType"),
+		KernelID:                          aws.String("String"),
+		KeyName:                           aws.String("String"),
+		Monitoring: &ec2.RunInstancesMonitoringEnabled{
+			Enabled: aws.Bool(true), // Required
+		},
+		NetworkInterfaces: []*ec2.InstanceNetworkInterfaceSpecification{
+			{ // Required
+				AssociatePublicIPAddress: aws.Bool(true),
+				DeleteOnTermination:      aws.Bool(true),
+				Description:              aws.String("String"),
+				DeviceIndex:              aws.Int64(1),
+				Groups: []*string{
+					aws.String("String"), // Required
+					// More values...
+				},
+				NetworkInterfaceID: aws.String("String"),
+				PrivateIPAddress:   aws.String("String"),
+				PrivateIPAddresses: []*ec2.PrivateIPAddressSpecification{
+					{ // Required
+						PrivateIPAddress: aws.String("String"), // Required
+						Primary:          aws.Bool(true),
+					},
+					// More values...
+				},
+				SecondaryPrivateIPAddressCount: aws.Int64(1),
+				SubnetID:                       aws.String("String"),
+			},
+			// More values...
+		},
+		Placement: &ec2.Placement{
+			AvailabilityZone: aws.String("String"),
+			GroupName:        aws.String("String"),
+			Tenancy:          aws.String("Tenancy"),
+		},
+		PrivateIPAddress: aws.String("String"),
+		RAMDiskID:        aws.String("String"),
+		SecurityGroupIDs: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		SecurityGroups: []*string{
+			aws.String("String"), // Required
+			// More values...
+		},
+		SubnetID: aws.String("String"),
+		UserData: aws.String("String"),
+	}
+	resp, err := svc.RunInstances(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_StartInstances() {
+	svc := ec2.New(nil)
+
+	params := &ec2.StartInstancesInput{
+		InstanceIDs: []*string{ // Required
+			aws.String("String"), // Required
+			// More values...
+		},
+		AdditionalInfo: aws.String("String"),
+		DryRun:         aws.Bool(true),
+	}
+	resp, err := svc.StartInstances(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_StopInstances() {
+	svc := ec2.New(nil)
+
+	params := &ec2.StopInstancesInput{
+		InstanceIDs: []*string{ // Required
+			aws.String("String"), // Required
+			// More values...
+		},
+		DryRun: aws.Bool(true),
+		Force:  aws.Bool(true),
+	}
+	resp, err := svc.StopInstances(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_TerminateInstances() {
+	svc := ec2.New(nil)
+
+	params := &ec2.TerminateInstancesInput{
+		InstanceIDs: []*string{ // Required
+			aws.String("String"), // Required
+			// More values...
+		},
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.TerminateInstances(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_UnassignPrivateIPAddresses() {
+	svc := ec2.New(nil)
+
+	params := &ec2.UnassignPrivateIPAddressesInput{
+		NetworkInterfaceID: aws.String("String"), // Required
+		PrivateIPAddresses: []*string{ // Required
+			aws.String("String"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.UnassignPrivateIPAddresses(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}
+
+func ExampleEC2_UnmonitorInstances() {
+	svc := ec2.New(nil)
+
+	params := &ec2.UnmonitorInstancesInput{
+		InstanceIDs: []*string{ // Required
+			aws.String("String"), // Required
+			// More values...
+		},
+		DryRun: aws.Bool(true),
+	}
+	resp, err := svc.UnmonitorInstances(params)
+
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok {
+			// Generic AWS error with Code, Message, and original error (if any)
+			fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+			if reqErr, ok := err.(awserr.RequestFailure); ok {
+				// A service error occurred
+				fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
+			}
+		} else {
+			// This case should never be hit, the SDK should always return an
+			// error which satisfies the awserr.Error interface.
+			fmt.Println(err.Error())
+		}
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.Prettify(resp))
+}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/ec2/service.go

@@ -0,0 +1,60 @@
+// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
+
+package ec2
+
+import (
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/internal/protocol/ec2query"
+	"github.com/aws/aws-sdk-go/internal/signer/v4"
+)
+
+// Amazon Elastic Compute Cloud (Amazon EC2) provides resizable computing capacity
+// in the Amazon Web Services (AWS) cloud. Using Amazon EC2 eliminates your
+// need to invest in hardware up front, so you can develop and deploy applications
+// faster.
+type EC2 struct {
+	*aws.Service
+}
+
+// Used for custom service initialization logic
+var initService func(*aws.Service)
+
+// Used for custom request initialization logic
+var initRequest func(*aws.Request)
+
+// New returns a new EC2 client.
+func New(config *aws.Config) *EC2 {
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "ec2",
+		APIVersion:  "2015-04-15",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(ec2query.Build)
+	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
+
+	// Run custom service initialization if present
+	if initService != nil {
+		initService(service)
+	}
+
+	return &EC2{service}
+}
+
+// newRequest creates a new request for a EC2 operation and runs any
+// custom request initialization.
+func (c *EC2) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+	req := aws.NewRequest(c.Service, op, params, data)
+
+	// Run custom request initialization if present
+	if initRequest != nil {
+		initRequest(req)
+	}
+
+	return req
+}

pkg/api/dataproxy_cloudwatch.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/cloudwatch"
+	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/grafana/grafana/pkg/middleware"
 )
 
@@ -22,86 +23,103 @@ func ProxyCloudWatchDataSourceRequest(c *middleware.Context) {
 	}{}
 	json.Unmarshal([]byte(body), reqInfo)
 
-	svc := cloudwatch.New(&aws.Config{Region: aws.String(reqInfo.Region)})
-
-	switch reqInfo.Action {
-	case "GetMetricStatistics":
-		reqParam := &struct {
-			Parameters struct {
-				Namespace  string              `json:"Namespace"`
-				MetricName string              `json:"MetricName"`
-				Dimensions []map[string]string `json:"Dimensions"`
-				Statistics []string            `json:"Statistics"`
-				StartTime  int64               `json:"StartTime"`
-				EndTime    int64               `json:"EndTime"`
-				Period     int64               `json:"Period"`
-			} `json:"parameters"`
-		}{}
-		json.Unmarshal([]byte(body), reqParam)
-
-		statistics := make([]*string, 0)
-		for k := range reqParam.Parameters.Statistics {
-			statistics = append(statistics, &reqParam.Parameters.Statistics[k])
-		}
-		dimensions := make([]*cloudwatch.Dimension, 0)
-		for _, d := range reqParam.Parameters.Dimensions {
-			dimensions = append(dimensions, &cloudwatch.Dimension{
-				Name:  aws.String(d["Name"]),
-				Value: aws.String(d["Value"]),
-			})
-		}
+	switch reqInfo.Service {
+	case "CloudWatch":
+		svc := cloudwatch.New(&aws.Config{Region: aws.String(reqInfo.Region)})
 
-		params := &cloudwatch.GetMetricStatisticsInput{
-			Namespace:  aws.String(reqParam.Parameters.Namespace),
-			MetricName: aws.String(reqParam.Parameters.MetricName),
-			Dimensions: dimensions,
-			Statistics: statistics,
-			StartTime:  aws.Time(time.Unix(reqParam.Parameters.StartTime, 0)),
-			EndTime:    aws.Time(time.Unix(reqParam.Parameters.EndTime, 0)),
-			Period:     aws.Int64(reqParam.Parameters.Period),
-		}
+		switch reqInfo.Action {
+		case "GetMetricStatistics":
+			reqParam := &struct {
+				Parameters struct {
+					Namespace  string                  `json:"Namespace"`
+					MetricName string                  `json:"MetricName"`
+					Dimensions []*cloudwatch.Dimension `json:"Dimensions"`
+					Statistics []*string               `json:"Statistics"`
+					StartTime  int64                   `json:"StartTime"`
+					EndTime    int64                   `json:"EndTime"`
+					Period     int64                   `json:"Period"`
+				} `json:"parameters"`
+			}{}
+			json.Unmarshal([]byte(body), reqParam)
 
-		resp, err := svc.GetMetricStatistics(params)
-		if err != nil {
-			c.JsonApiErr(500, "Unable to call AWS API", err)
-			return
-		}
+			params := &cloudwatch.GetMetricStatisticsInput{
+				Namespace:  aws.String(reqParam.Parameters.Namespace),
+				MetricName: aws.String(reqParam.Parameters.MetricName),
+				Dimensions: reqParam.Parameters.Dimensions,
+				Statistics: reqParam.Parameters.Statistics,
+				StartTime:  aws.Time(time.Unix(reqParam.Parameters.StartTime, 0)),
+				EndTime:    aws.Time(time.Unix(reqParam.Parameters.EndTime, 0)),
+				Period:     aws.Int64(reqParam.Parameters.Period),
+			}
 
-		respJson, _ := json.Marshal(resp)
-		fmt.Fprint(c.RW(), string(respJson))
-	case "ListMetrics":
-		reqParam := &struct {
-			Parameters struct {
-				Namespace  string              `json:"Namespace"`
-				MetricName string              `json:"MetricName"`
-				Dimensions []map[string]string `json:"Dimensions"`
-			} `json:"parameters"`
-		}{}
-		json.Unmarshal([]byte(body), reqParam)
-
-		dimensions := make([]*cloudwatch.DimensionFilter, 0)
-		for _, d := range reqParam.Parameters.Dimensions {
-			dimensions = append(dimensions, &cloudwatch.DimensionFilter{
-				Name:  aws.String(d["Name"]),
-				Value: aws.String(d["Value"]),
-			})
-		}
+			resp, err := svc.GetMetricStatistics(params)
+			if err != nil {
+				c.JsonApiErr(500, "Unable to call AWS API", err)
+				return
+			}
 
-		params := &cloudwatch.ListMetricsInput{
-			Namespace:  aws.String(reqParam.Parameters.Namespace),
-			MetricName: aws.String(reqParam.Parameters.MetricName),
-			Dimensions: dimensions,
-		}
+			respJson, _ := json.Marshal(resp)
+			fmt.Fprint(c.RW(), string(respJson))
+		case "ListMetrics":
+			reqParam := &struct {
+				Parameters struct {
+					Namespace  string                        `json:"Namespace"`
+					MetricName string                        `json:"MetricName"`
+					Dimensions []*cloudwatch.DimensionFilter `json:"Dimensions"`
+				} `json:"parameters"`
+			}{}
+			json.Unmarshal([]byte(body), reqParam)
 
-		resp, err := svc.ListMetrics(params)
-		if err != nil {
-			c.JsonApiErr(500, "Unable to call AWS API", err)
-			return
+			params := &cloudwatch.ListMetricsInput{
+				Namespace:  aws.String(reqParam.Parameters.Namespace),
+				MetricName: aws.String(reqParam.Parameters.MetricName),
+				Dimensions: reqParam.Parameters.Dimensions,
+			}
+
+			resp, err := svc.ListMetrics(params)
+			if err != nil {
+				c.JsonApiErr(500, "Unable to call AWS API", err)
+				return
+			}
+
+			respJson, _ := json.Marshal(resp)
+			fmt.Fprint(c.RW(), string(respJson))
+		default:
+			c.JsonApiErr(500, "Unexpected CloudWatch action", errors.New(reqInfo.Action))
 		}
+	case "EC2":
+		svc := ec2.New(&aws.Config{Region: aws.String(reqInfo.Region)})
+
+		switch reqInfo.Action {
+		case "DescribeInstances":
+			reqParam := &struct {
+				Parameters struct {
+					Filters     []*ec2.Filter `json:"Filters"`
+					InstanceIds []*string     `json:"InstanceIds"`
+				} `json:"parameters"`
+			}{}
+			json.Unmarshal([]byte(body), reqParam)
 
-		respJson, _ := json.Marshal(resp)
-		fmt.Fprint(c.RW(), string(respJson))
+			params := &ec2.DescribeInstancesInput{}
+			if len(reqParam.Parameters.Filters) > 0 {
+				params.Filters = reqParam.Parameters.Filters
+			}
+			if len(reqParam.Parameters.InstanceIds) > 0 {
+				params.InstanceIDs = reqParam.Parameters.InstanceIds
+			}
+
+			resp, err := svc.DescribeInstances(params)
+			if err != nil {
+				c.JsonApiErr(500, "Unable to call AWS API", err)
+				return
+			}
+
+			respJson, _ := json.Marshal(resp)
+			fmt.Fprint(c.RW(), string(respJson))
+		default:
+			c.JsonApiErr(500, "Unexpected EC2 action", errors.New(reqInfo.Action))
+		}
 	default:
-		c.JsonApiErr(500, "Unexpected CloudWatch action", errors.New(reqInfo.Action))
+		c.JsonApiErr(500, "Unexpected service", errors.New(reqInfo.Service))
 	}
 }

public/app/plugins/datasource/cloudwatch/datasource.js

@@ -2,13 +2,12 @@
 define([
   'angular',
   'lodash',
-  'app/core/utils/datemath',
   'moment',
   './queryCtrl',
   './directives',
   'aws-sdk',
 ],
-function (angular, _, dateMath) {
+function (angular, _) {
   'use strict';
 
   var module = angular.module('grafana.services');
@@ -275,7 +274,7 @@ function (angular, _, dateMath) {
     };
 
     CloudWatchDatasource.prototype.performTimeSeriesQuery = function(query, start, end) {
-      var cloudwatch = this.getCloudWatchClient(query.region);
+      var cloudwatch = this.getAwsClient(query.region, 'CloudWatch');
 
       var params = {
         Namespace: query.namespace,
@@ -321,7 +320,7 @@ function (angular, _, dateMath) {
       namespace = templateSrv.replace(namespace);
       metricName = templateSrv.replace(metricName);
 
-      var cloudwatch = this.getCloudWatchClient(region);
+      var cloudwatch = this.getAwsClient(region, 'CloudWatch');
 
       var params = {
         Namespace: namespace,
@@ -353,6 +352,30 @@ function (angular, _, dateMath) {
       return d.promise;
     };
 
+    CloudWatchDatasource.prototype.performEC2DescribeInstances = function(region, filters, instanceIds) {
+      var ec2 = this.getAwsClient(region, 'EC2');
+
+      var params = {};
+      if (filters.length > 0) {
+        params.Filters = filters;
+      }
+      if (instanceIds.length > 0) {
+        params.InstanceIds = instanceIds;
+      }
+
+      var d = $q.defer();
+
+      ec2.describeInstances(params, function(err, data) {
+        if (err) {
+          return d.reject(err);
+        }
+
+        return d.resolve(data);
+      });
+
+      return d.promise;
+    };
+
     CloudWatchDatasource.prototype.getTemplateVariableNames = function() {
       var variables = [];
       templateSrv.fillVariableValuesForUrl(variables);
@@ -436,6 +459,24 @@ function (angular, _, dateMath) {
         });
       }
 
+      var ebsVolumeIdsQuery = query.match(/^ebs_volume_ids\(([^,]+?),\s?([^,]+?)\)/);
+      if (ebsVolumeIdsQuery) {
+        region = templateSrv.replace(ebsVolumeIdsQuery[1]);
+        var instanceId = templateSrv.replace(ebsVolumeIdsQuery[2]);
+        var instanceIds = [
+          instanceId
+        ];
+
+        return this.performEC2DescribeInstances(region, [], instanceIds)
+        .then(function(result) {
+          var volumeIds = _.map(result.Reservations[0].Instances[0].BlockDeviceMappings, function(mapping) {
+            return mapping.EBS.VolumeID;
+          });
+
+          return transformSuggestData(volumeIds);
+        });
+      }
+
       return $q.when([]);
     };
 
@@ -451,9 +492,9 @@ function (angular, _, dateMath) {
       });
     };
 
-    CloudWatchDatasource.prototype.getCloudWatchClient = function(region) {
+    CloudWatchDatasource.prototype.getAwsClient = function(region, service) {
       if (!this.proxyMode) {
-        return new AWS.CloudWatch({
+        return new AWS[service]({
           region: region,
           accessKeyId: this.credentials.accessKeyId,
           secretAccessKey: this.credentials.secretAccessKey
@@ -483,10 +524,22 @@ function (angular, _, dateMath) {
           };
         };
 
-        return {
-          getMetricStatistics: generateRequestProxy('CloudWatch', 'GetMetricStatistics'),
-          listMetrics: generateRequestProxy('CloudWatch', 'ListMetrics')
-        };
+        var proxy;
+        switch (service) {
+        case 'CloudWatch':
+          proxy = {
+            getMetricStatistics: generateRequestProxy('CloudWatch', 'GetMetricStatistics'),
+            listMetrics: generateRequestProxy('CloudWatch', 'ListMetrics')
+          };
+          break;
+        case 'EC2':
+          proxy = {
+            describeInstances: generateRequestProxy('EC2', 'DescribeInstances')
+          };
+          break;
+        }
+
+        return proxy;
       }
     };
 
@@ -543,7 +596,7 @@ function (angular, _, dateMath) {
     }
 
     function convertToCloudWatchTime(date) {
-      return date.valueOf() / 1000;
+      return Math.round(date.valueOf() / 1000);
     }
 
     function convertDimensionFormat(dimensions) {

public/app/plugins/datasource/cloudwatch/partials/config.html

@@ -30,7 +30,7 @@
   </ul>
   <div class="clearfix"></div>
 </div>
-<div class="tight-form">
+<div class="tight-form" ng-show="current.jsonData.access === 'direct'">
   <ul class="tight-form-list">
     <li class="tight-form-item" style="width: 160px">
 			Secret Access Key