From cf7a05f80f68b5b1c8bcc0089679dd497cec2506 Mon Sep 17 00:00:00 2001
From: =Corey Hulen <corey@hulen.com>
Date: Sun, 14 Jun 2015 23:53:32 -0800
Subject: first commit

---
 .../awslabs/aws-sdk-go/aws/awsutil/path_value.go   |  142 +
 .../aws-sdk-go/aws/awsutil/path_value_test.go      |   60 +
 .../awslabs/aws-sdk-go/aws/awsutil/string_value.go |   88 +
 .../github.com/awslabs/aws-sdk-go/aws/config.go    |  101 +
 .../awslabs/aws-sdk-go/aws/credentials.go          |  288 ++
 .../awslabs/aws-sdk-go/aws/credentials_test.go     |  236 ++
 .../src/github.com/awslabs/aws-sdk-go/aws/error.go |   26 +
 .../github.com/awslabs/aws-sdk-go/aws/example.ini  |    8 +
 .../awslabs/aws-sdk-go/aws/handler_functions.go    |   78 +
 .../github.com/awslabs/aws-sdk-go/aws/handlers.go  |   65 +
 .../awslabs/aws-sdk-go/aws/handlers_test.go        |   24 +
 .../awslabs/aws-sdk-go/aws/param_validator.go      |   80 +
 .../awslabs/aws-sdk-go/aws/param_validator_test.go |   85 +
 .../github.com/awslabs/aws-sdk-go/aws/request.go   |  149 ++
 .../awslabs/aws-sdk-go/aws/request_test.go         |  118 +
 .../github.com/awslabs/aws-sdk-go/aws/service.go   |  142 +
 .../src/github.com/awslabs/aws-sdk-go/aws/types.go |   63 +
 .../github.com/awslabs/aws-sdk-go/aws/version.go   |    5 +
 .../aws-sdk-go/internal/endpoints/endpoints.go     |   24 +
 .../aws-sdk-go/internal/endpoints/endpoints.json   |   67 +
 .../aws-sdk-go/internal/endpoints/endpoints_map.go |   78 +
 .../internal/endpoints/endpoints_test.go           |   25 +
 .../aws-sdk-go/internal/protocol/query/build.go    |   30 +
 .../internal/protocol/query/build_test.go          | 1167 +++++++++
 .../internal/protocol/query/queryutil/queryutil.go |  198 ++
 .../internal/protocol/query/unmarshal.go           |   26 +
 .../internal/protocol/query/unmarshal_error.go     |   31 +
 .../internal/protocol/query/unmarshal_test.go      | 1361 ++++++++++
 .../aws-sdk-go/internal/protocol/rest/build.go     |  215 ++
 .../aws-sdk-go/internal/protocol/rest/payload.go   |   43 +
 .../aws-sdk-go/internal/protocol/rest/unmarshal.go |  174 ++
 .../internal/protocol/restxml/build_test.go        | 2571 ++++++++++++++++++
 .../internal/protocol/restxml/restxml.go           |   48 +
 .../internal/protocol/restxml/unmarshal_test.go    | 1171 +++++++++
 .../internal/protocol/xml/xmlutil/build.go         |  262 ++
 .../internal/protocol/xml/xmlutil/unmarshal.go     |  251 ++
 .../internal/protocol/xml/xmlutil/xml_to_struct.go |  100 +
 .../awslabs/aws-sdk-go/internal/signer/v4/v4.go    |  296 +++
 .../aws-sdk-go/internal/signer/v4/v4_test.go       |   89 +
 .../awslabs/aws-sdk-go/service/route53/api.go      | 2738 ++++++++++++++++++++
 .../aws-sdk-go/service/route53/customizations.go   |   20 +
 .../service/route53/customizations_test.go         |   20 +
 .../aws-sdk-go/service/route53/examples_test.go    |  714 +++++
 .../awslabs/aws-sdk-go/service/route53/service.go  |   59 +
 44 files changed, 13536 insertions(+)
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/awsutil/path_value.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/awsutil/path_value_test.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/awsutil/string_value.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/config.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/credentials.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/credentials_test.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/error.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/example.ini
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/handler_functions.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/handlers.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/handlers_test.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/param_validator.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/param_validator_test.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/request.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/request_test.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/service.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/types.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/version.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/endpoints/endpoints.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/endpoints/endpoints.json
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/endpoints/endpoints_map.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/endpoints/endpoints_test.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/build.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/build_test.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/queryutil/queryutil.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal_error.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal_test.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/rest/build.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/rest/payload.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/rest/unmarshal.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/restxml/build_test.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/restxml/restxml.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/restxml/unmarshal_test.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil/build.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil/unmarshal.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil/xml_to_struct.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/signer/v4/v4.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/signer/v4/v4_test.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/route53/api.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/route53/customizations.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/route53/customizations_test.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/route53/examples_test.go
 create mode 100644 Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/route53/service.go

(limited to 'Godeps/_workspace/src/github.com/awslabs/aws-sdk-go')

diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/awsutil/path_value.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/awsutil/path_value.go
new file mode 100644
index 000000000..ce4c5e27a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/awsutil/path_value.go
@@ -0,0 +1,142 @@
+package awsutil
+
+import (
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+var indexRe = regexp.MustCompile(`(.+)\[(-?\d+)?\]$`)
+
+func rValuesAtPath(v interface{}, path string, create bool) []reflect.Value {
+	pathparts := strings.Split(path, "||")
+	if len(pathparts) > 1 {
+		for _, pathpart := range pathparts {
+			vals := rValuesAtPath(v, pathpart, create)
+			if vals != nil && len(vals) > 0 {
+				return vals
+			}
+		}
+		return nil
+	}
+
+	values := []reflect.Value{reflect.Indirect(reflect.ValueOf(v))}
+	components := strings.Split(path, ".")
+	for len(values) > 0 && len(components) > 0 {
+		var index *int64
+		var indexStar bool
+		c := strings.TrimSpace(components[0])
+		if c == "" { // no actual component, illegal syntax
+			return nil
+		} else if c != "*" && strings.ToLower(c[0:1]) == c[0:1] {
+			// TODO normalize case for user
+			return nil // don't support unexported fields
+		}
+
+		// parse this component
+		if m := indexRe.FindStringSubmatch(c); m != nil {
+			c = m[1]
+			if m[2] == "" {
+				index = nil
+				indexStar = true
+			} else {
+				i, _ := strconv.ParseInt(m[2], 10, 32)
+				index = &i
+				indexStar = false
+			}
+		}
+
+		nextvals := []reflect.Value{}
+		for _, value := range values {
+			// pull component name out of struct member
+			if value.Kind() != reflect.Struct {
+				continue
+			}
+
+			if c == "*" { // pull all members
+				for i := 0; i < value.NumField(); i++ {
+					if f := reflect.Indirect(value.Field(i)); f.IsValid() {
+						nextvals = append(nextvals, f)
+					}
+				}
+				continue
+			}
+
+			value = value.FieldByName(c)
+			if create && value.Kind() == reflect.Ptr && value.IsNil() {
+				value.Set(reflect.New(value.Type().Elem()))
+				value = value.Elem()
+			} else {
+				value = reflect.Indirect(value)
+			}
+
+			if value.IsValid() {
+				nextvals = append(nextvals, value)
+			}
+		}
+		values = nextvals
+
+		if indexStar || index != nil {
+			nextvals = []reflect.Value{}
+			for _, value := range values {
+				value := reflect.Indirect(value)
+				if value.Kind() != reflect.Slice {
+					continue
+				}
+
+				if indexStar { // grab all indices
+					for i := 0; i < value.Len(); i++ {
+						idx := reflect.Indirect(value.Index(i))
+						if idx.IsValid() {
+							nextvals = append(nextvals, idx)
+						}
+					}
+					continue
+				}
+
+				// pull out index
+				i := int(*index)
+				if i >= value.Len() { // check out of bounds
+					if create {
+						// TODO resize slice
+					} else {
+						continue
+					}
+				} else if i < 0 { // support negative indexing
+					i = value.Len() + i
+				}
+				value = reflect.Indirect(value.Index(i))
+
+				if value.IsValid() {
+					nextvals = append(nextvals, value)
+				}
+			}
+			values = nextvals
+		}
+
+		components = components[1:]
+	}
+	return values
+}
+
+// ValuesAtPath returns a list of objects at the lexical path inside of a structure
+func ValuesAtPath(i interface{}, path string) []interface{} {
+	if rvals := rValuesAtPath(i, path, false); rvals != nil {
+		vals := make([]interface{}, len(rvals))
+		for i, rval := range rvals {
+			vals[i] = rval.Interface()
+		}
+		return vals
+	}
+	return nil
+}
+
+// SetValueAtPath sets an object at the lexical path inside of a structure
+func SetValueAtPath(i interface{}, path string, v interface{}) {
+	if rvals := rValuesAtPath(i, path, true); rvals != nil {
+		for _, rval := range rvals {
+			rval.Set(reflect.ValueOf(v))
+		}
+	}
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/awsutil/path_value_test.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/awsutil/path_value_test.go
new file mode 100644
index 000000000..881927365
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/awsutil/path_value_test.go
@@ -0,0 +1,60 @@
+package awsutil_test
+
+import (
+	"testing"
+
+	"github.com/awslabs/aws-sdk-go/aws/awsutil"
+	"github.com/stretchr/testify/assert"
+)
+
+type Struct struct {
+	A []Struct
+	a []Struct
+	B *Struct
+	D *Struct
+	C string
+}
+
+var data = Struct{
+	A: []Struct{Struct{C: "value1"}, Struct{C: "value2"}, Struct{C: "value3"}},
+	a: []Struct{Struct{C: "value1"}, Struct{C: "value2"}, Struct{C: "value3"}},
+	B: &Struct{B: &Struct{C: "terminal"}, D: &Struct{C: "terminal2"}},
+	C: "initial",
+}
+
+func TestValueAtPathSuccess(t *testing.T) {
+	assert.Equal(t, []interface{}{"initial"}, awsutil.ValuesAtPath(data, "C"))
+	assert.Equal(t, []interface{}{"value1"}, awsutil.ValuesAtPath(data, "A[0].C"))
+	assert.Equal(t, []interface{}{"value2"}, awsutil.ValuesAtPath(data, "A[1].C"))
+	assert.Equal(t, []interface{}{"value3"}, awsutil.ValuesAtPath(data, "A[2].C"))
+	assert.Equal(t, []interface{}{"value3"}, awsutil.ValuesAtPath(data, "A[-1].C"))
+	assert.Equal(t, []interface{}{"value1", "value2", "value3"}, awsutil.ValuesAtPath(data, "A[].C"))
+	assert.Equal(t, []interface{}{"terminal"}, awsutil.ValuesAtPath(data, "B . B . C"))
+	assert.Equal(t, []interface{}{"terminal", "terminal2"}, awsutil.ValuesAtPath(data, "B.*.C"))
+	assert.Equal(t, []interface{}{"initial"}, awsutil.ValuesAtPath(data, "A.D.X || C"))
+}
+
+func TestValueAtPathFailure(t *testing.T) {
+	assert.Equal(t, []interface{}(nil), awsutil.ValuesAtPath(data, "C.x"))
+	assert.Equal(t, []interface{}(nil), awsutil.ValuesAtPath(data, ".x"))
+	assert.Equal(t, []interface{}{}, awsutil.ValuesAtPath(data, "X.Y.Z"))
+	assert.Equal(t, []interface{}{}, awsutil.ValuesAtPath(data, "A[100].C"))
+	assert.Equal(t, []interface{}{}, awsutil.ValuesAtPath(data, "A[3].C"))
+	assert.Equal(t, []interface{}{}, awsutil.ValuesAtPath(data, "B.B.C.Z"))
+	assert.Equal(t, []interface{}(nil), awsutil.ValuesAtPath(data, "a[-1].C"))
+	assert.Equal(t, []interface{}{}, awsutil.ValuesAtPath(nil, "A.B.C"))
+}
+
+func TestSetValueAtPathSuccess(t *testing.T) {
+	var s Struct
+	awsutil.SetValueAtPath(&s, "C", "test1")
+	awsutil.SetValueAtPath(&s, "B.B.C", "test2")
+	awsutil.SetValueAtPath(&s, "B.D.C", "test3")
+	assert.Equal(t, "test1", s.C)
+	assert.Equal(t, "test2", s.B.B.C)
+	assert.Equal(t, "test3", s.B.D.C)
+
+	awsutil.SetValueAtPath(&s, "B.*.C", "test0")
+	assert.Equal(t, "test0", s.B.B.C)
+	assert.Equal(t, "test0", s.B.D.C)
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/awsutil/string_value.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/awsutil/string_value.go
new file mode 100644
index 000000000..2e90f8da4
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/awsutil/string_value.go
@@ -0,0 +1,88 @@
+package awsutil
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+func StringValue(i interface{}) string {
+	var buf bytes.Buffer
+	stringValue(reflect.ValueOf(i), 0, &buf)
+	return buf.String()
+}
+
+func stringValue(v reflect.Value, indent int, buf *bytes.Buffer) {
+	for v.Kind() == reflect.Ptr {
+		v = v.Elem()
+	}
+
+	switch v.Kind() {
+	case reflect.Struct:
+		buf.WriteString("{\n")
+
+		names := []string{}
+		for i := 0; i < v.Type().NumField(); i++ {
+			name := v.Type().Field(i).Name
+			f := v.Field(i)
+			if name[0:1] == strings.ToLower(name[0:1]) {
+				continue // ignore unexported fields
+			}
+			if (f.Kind() == reflect.Ptr || f.Kind() == reflect.Slice) && f.IsNil() {
+				continue // ignore unset fields
+			}
+			names = append(names, name)
+		}
+
+		for i, n := range names {
+			val := v.FieldByName(n)
+			buf.WriteString(strings.Repeat(" ", indent+2))
+			buf.WriteString(n + ": ")
+			stringValue(val, indent+2, buf)
+
+			if i < len(names)-1 {
+				buf.WriteString(",\n")
+			}
+		}
+
+		buf.WriteString("\n" + strings.Repeat(" ", indent) + "}")
+	case reflect.Slice:
+		nl, id, id2 := "", "", ""
+		if v.Len() > 3 {
+			nl, id, id2 = "\n", strings.Repeat(" ", indent), strings.Repeat(" ", indent+2)
+		}
+		buf.WriteString("[" + nl)
+		for i := 0; i < v.Len(); i++ {
+			buf.WriteString(id2)
+			stringValue(v.Index(i), indent+2, buf)
+
+			if i < v.Len()-1 {
+				buf.WriteString("," + nl)
+			}
+		}
+
+		buf.WriteString(nl + id + "]")
+	case reflect.Map:
+		buf.WriteString("{\n")
+
+		for i, k := range v.MapKeys() {
+			buf.WriteString(strings.Repeat(" ", indent+2))
+			buf.WriteString(k.String() + ": ")
+			stringValue(v.MapIndex(k), indent+2, buf)
+
+			if i < v.Len()-1 {
+				buf.WriteString(",\n")
+			}
+		}
+
+		buf.WriteString("\n" + strings.Repeat(" ", indent) + "}")
+	default:
+		format := "%v"
+		switch v.Interface().(type) {
+		case string:
+			format = "%q"
+		}
+		fmt.Fprintf(buf, format, v.Interface())
+	}
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/config.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/config.go
new file mode 100644
index 000000000..6cc6da42e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/config.go
@@ -0,0 +1,101 @@
+package aws
+
+import (
+	"io"
+	"net/http"
+	"os"
+)
+
+const DEFAULT_RETRIES = -1
+
+var DefaultConfig = &Config{
+	Credentials:            DefaultCreds(),
+	Endpoint:               "",
+	Region:                 os.Getenv("AWS_REGION"),
+	DisableSSL:             false,
+	ManualSend:             false,
+	HTTPClient:             http.DefaultClient,
+	LogLevel:               0,
+	Logger:                 os.Stdout,
+	MaxRetries:             DEFAULT_RETRIES,
+	DisableParamValidation: false,
+}
+
+type Config struct {
+	Credentials            CredentialsProvider
+	Endpoint               string
+	Region                 string
+	DisableSSL             bool
+	ManualSend             bool
+	HTTPClient             *http.Client
+	LogLevel               uint
+	Logger                 io.Writer
+	MaxRetries             int
+	DisableParamValidation bool
+}
+
+func (c Config) Merge(newcfg *Config) *Config {
+	cfg := Config{}
+
+	if newcfg != nil && newcfg.Credentials != nil {
+		cfg.Credentials = newcfg.Credentials
+	} else {
+		cfg.Credentials = c.Credentials
+	}
+
+	if newcfg != nil && newcfg.Endpoint != "" {
+		cfg.Endpoint = newcfg.Endpoint
+	} else {
+		cfg.Endpoint = c.Endpoint
+	}
+
+	if newcfg != nil && newcfg.Region != "" {
+		cfg.Region = newcfg.Region
+	} else {
+		cfg.Region = c.Region
+	}
+
+	if newcfg != nil && newcfg.DisableSSL {
+		cfg.DisableSSL = newcfg.DisableSSL
+	} else {
+		cfg.DisableSSL = c.DisableSSL
+	}
+
+	if newcfg != nil && newcfg.ManualSend {
+		cfg.ManualSend = newcfg.ManualSend
+	} else {
+		cfg.ManualSend = c.ManualSend
+	}
+
+	if newcfg != nil && newcfg.HTTPClient != nil {
+		cfg.HTTPClient = newcfg.HTTPClient
+	} else {
+		cfg.HTTPClient = c.HTTPClient
+	}
+
+	if newcfg != nil && newcfg.LogLevel != 0 {
+		cfg.LogLevel = newcfg.LogLevel
+	} else {
+		cfg.LogLevel = c.LogLevel
+	}
+
+	if newcfg != nil && newcfg.Logger != nil {
+		cfg.Logger = newcfg.Logger
+	} else {
+		cfg.Logger = c.Logger
+	}
+
+	if newcfg != nil && newcfg.MaxRetries != DEFAULT_RETRIES {
+		cfg.MaxRetries = newcfg.MaxRetries
+	} else {
+		cfg.MaxRetries = c.MaxRetries
+	}
+
+	if newcfg != nil && newcfg.DisableParamValidation {
+		cfg.DisableParamValidation = newcfg.DisableParamValidation
+	} else {
+		cfg.DisableParamValidation = c.DisableParamValidation
+	}
+
+	return &cfg
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/credentials.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/credentials.go
new file mode 100644
index 000000000..4490c674a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/credentials.go
@@ -0,0 +1,288 @@
+package aws
+
+import (
+	"bufio"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+
+	"github.com/vaughan0/go-ini"
+)
+
+var currentTime = time.Now
+
+// Credentials are used to authenticate and authorize calls that you make to
+// AWS.
+type Credentials struct {
+	AccessKeyID     string
+	SecretAccessKey string
+	SessionToken    string
+}
+
+// A CredentialsProvider is a provider of credentials.
+type CredentialsProvider interface {
+	// Credentials returns a set of credentials (or an error if no credentials
+	// could be provided).
+	Credentials() (*Credentials, error)
+}
+
+var (
+	// ErrAccessKeyIDNotFound is returned when the AWS Access Key ID can't be
+	// found in the process's environment.
+	ErrAccessKeyIDNotFound = fmt.Errorf("AWS_ACCESS_KEY_ID or AWS_ACCESS_KEY not found in environment")
+	// ErrSecretAccessKeyNotFound is returned when the AWS Secret Access Key
+	// can't be found in the process's environment.
+	ErrSecretAccessKeyNotFound = fmt.Errorf("AWS_SECRET_ACCESS_KEY or AWS_SECRET_KEY not found in environment")
+)
+
+type DefaultCredentialsProvider struct {
+}
+
+func (p *DefaultCredentialsProvider) Credentials() (*Credentials, error) {
+	env, err := EnvCreds()
+	if err == nil {
+		return env.Credentials()
+	}
+
+	profile, err := ProfileCreds("", "", 10*time.Minute)
+	if err == nil {
+		profileCreds, err := profile.Credentials()
+		if err == nil {
+			return profileCreds, nil
+		}
+	}
+
+	return IAMCreds().Credentials()
+}
+
+func DefaultCreds() CredentialsProvider {
+	return &DefaultCredentialsProvider{}
+}
+
+// DetectCreds returns a CredentialsProvider based on the available information.
+//
+// If the access key ID and secret access key are provided, it returns a basic
+// provider.
+//
+// If credentials are available via environment variables, it returns an
+// environment provider.
+//
+// If a profile configuration file is available in the default location and has
+// a default profile configured, it returns a profile provider.
+//
+// Otherwise, it returns an IAM instance provider.
+func DetectCreds(accessKeyID, secretAccessKey, sessionToken string) CredentialsProvider {
+	if accessKeyID != "" && secretAccessKey != "" {
+		return Creds(accessKeyID, secretAccessKey, sessionToken)
+	}
+
+	env, err := EnvCreds()
+	if err == nil {
+		return env
+	}
+
+	profile, err := ProfileCreds("", "", 10*time.Minute)
+	if err != nil {
+		return IAMCreds()
+	}
+
+	_, err = profile.Credentials()
+	if err != nil {
+		return IAMCreds()
+	}
+
+	return profile
+}
+
+// EnvCreds returns a static provider of AWS credentials from the process's
+// environment, or an error if none are found.
+func EnvCreds() (CredentialsProvider, error) {
+	id := os.Getenv("AWS_ACCESS_KEY_ID")
+	if id == "" {
+		id = os.Getenv("AWS_ACCESS_KEY")
+	}
+
+	secret := os.Getenv("AWS_SECRET_ACCESS_KEY")
+	if secret == "" {
+		secret = os.Getenv("AWS_SECRET_KEY")
+	}
+
+	if id == "" {
+		return nil, ErrAccessKeyIDNotFound
+	}
+
+	if secret == "" {
+		return nil, ErrSecretAccessKeyNotFound
+	}
+
+	return Creds(id, secret, os.Getenv("AWS_SESSION_TOKEN")), nil
+}
+
+// Creds returns a static provider of credentials.
+func Creds(accessKeyID, secretAccessKey, sessionToken string) CredentialsProvider {
+	return staticCredentialsProvider{
+		creds: Credentials{
+			AccessKeyID:     accessKeyID,
+			SecretAccessKey: secretAccessKey,
+			SessionToken:    sessionToken,
+		},
+	}
+}
+
+// IAMCreds returns a provider which pulls credentials from the local EC2
+// instance's IAM roles.
+func IAMCreds() CredentialsProvider {
+	return &iamProvider{}
+}
+
+// ProfileCreds returns a provider which pulls credentials from the profile
+// configuration file.
+func ProfileCreds(filename, profile string, expiry time.Duration) (CredentialsProvider, error) {
+	if filename == "" {
+		homeDir := os.Getenv("HOME") // *nix
+		if homeDir == "" {           // Windows
+			homeDir = os.Getenv("USERPROFILE")
+		}
+		if homeDir == "" {
+			return nil, errors.New("User home directory not found.")
+		}
+
+		filename = filepath.Join(homeDir, ".aws", "credentials")
+	}
+
+	if profile == "" {
+		profile = "default"
+	}
+
+	return &profileProvider{
+		filename: filename,
+		profile:  profile,
+		expiry:   expiry,
+	}, nil
+}
+
+type profileProvider struct {
+	filename string
+	profile  string
+	expiry   time.Duration
+
+	creds      Credentials
+	m          sync.Mutex
+	expiration time.Time
+}
+
+func (p *profileProvider) Credentials() (*Credentials, error) {
+	p.m.Lock()
+	defer p.m.Unlock()
+
+	if p.expiration.After(currentTime()) {
+		return &p.creds, nil
+	}
+
+	config, err := ini.LoadFile(p.filename)
+	if err != nil {
+		return nil, err
+	}
+	profile := config.Section(p.profile)
+
+	accessKeyID, ok := profile["aws_access_key_id"]
+	if !ok {
+		return nil, fmt.Errorf("profile %s in %s did not contain aws_access_key_id", p.profile, p.filename)
+	}
+
+	secretAccessKey, ok := profile["aws_secret_access_key"]
+	if !ok {
+		return nil, fmt.Errorf("profile %s in %s did not contain aws_secret_access_key", p.profile, p.filename)
+	}
+
+	sessionToken := profile["aws_session_token"]
+
+	p.creds = Credentials{
+		AccessKeyID:     accessKeyID,
+		SecretAccessKey: secretAccessKey,
+		SessionToken:    sessionToken,
+	}
+	p.expiration = currentTime().Add(p.expiry)
+
+	return &p.creds, nil
+}
+
+type iamProvider struct {
+	creds      Credentials
+	m          sync.Mutex
+	expiration time.Time
+}
+
+var metadataCredentialsEndpoint = "http://169.254.169.254/latest/meta-data/iam/security-credentials/"
+
+// IAMClient is the HTTP client used to query the metadata endpoint for IAM
+// credentials.
+var IAMClient = http.Client{
+	Timeout: 1 * time.Second,
+}
+
+func (p *iamProvider) Credentials() (*Credentials, error) {
+	p.m.Lock()
+	defer p.m.Unlock()
+
+	if p.expiration.After(currentTime()) {
+		return &p.creds, nil
+	}
+
+	var body struct {
+		Expiration      time.Time
+		AccessKeyID     string
+		SecretAccessKey string
+		Token           string
+	}
+
+	resp, err := IAMClient.Get(metadataCredentialsEndpoint)
+	if err != nil {
+		return nil, fmt.Errorf("listing IAM credentials")
+	}
+	defer func() {
+		_ = resp.Body.Close()
+	}()
+
+	// Take the first line of the body of the metadata endpoint
+	s := bufio.NewScanner(resp.Body)
+	if !s.Scan() {
+		return nil, fmt.Errorf("unable to find default IAM credentials")
+	} else if s.Err() != nil {
+		return nil, fmt.Errorf("%s listing IAM credentials", s.Err())
+	}
+
+	resp, err = IAMClient.Get(metadataCredentialsEndpoint + s.Text())
+	if err != nil {
+		return nil, fmt.Errorf("getting %s IAM credentials", s.Text())
+	}
+	defer func() {
+		_ = resp.Body.Close()
+	}()
+
+	if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
+		return nil, fmt.Errorf("decoding %s IAM credentials", s.Text())
+	}
+
+	p.creds = Credentials{
+		AccessKeyID:     body.AccessKeyID,
+		SecretAccessKey: body.SecretAccessKey,
+		SessionToken:    body.Token,
+	}
+	p.expiration = body.Expiration
+
+	return &p.creds, nil
+}
+
+type staticCredentialsProvider struct {
+	creds Credentials
+}
+
+func (p staticCredentialsProvider) Credentials() (*Credentials, error) {
+	return &p.creds, nil
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/credentials_test.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/credentials_test.go
new file mode 100644
index 000000000..3143cebd6
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/credentials_test.go
@@ -0,0 +1,236 @@
+package aws
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+	"time"
+)
+
+func TestEnvCreds(t *testing.T) {
+	os.Clearenv()
+	os.Setenv("AWS_ACCESS_KEY_ID", "access")
+	os.Setenv("AWS_SECRET_ACCESS_KEY", "secret")
+	os.Setenv("AWS_SESSION_TOKEN", "token")
+
+	prov, err := EnvCreds()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	creds, err := prov.Credentials()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if v, want := creds.AccessKeyID, "access"; v != want {
+		t.Errorf("Access key ID was %v, expected %v", v, want)
+	}
+
+	if v, want := creds.SecretAccessKey, "secret"; v != want {
+		t.Errorf("Secret access key was %v, expected %v", v, want)
+	}
+
+	if v, want := creds.SessionToken, "token"; v != want {
+		t.Errorf("Security token was %v, expected %v", v, want)
+	}
+}
+
+func TestEnvCredsNoAccessKeyID(t *testing.T) {
+	os.Clearenv()
+	os.Setenv("AWS_SECRET_ACCESS_KEY", "secret")
+
+	prov, err := EnvCreds()
+	if err != ErrAccessKeyIDNotFound {
+		t.Fatalf("ErrAccessKeyIDNotFound expected, but was %#v/%#v", prov, err)
+	}
+}
+
+func TestEnvCredsNoSecretAccessKey(t *testing.T) {
+	os.Clearenv()
+	os.Setenv("AWS_ACCESS_KEY_ID", "access")
+
+	prov, err := EnvCreds()
+	if err != ErrSecretAccessKeyNotFound {
+		t.Fatalf("ErrSecretAccessKeyNotFound expected, but was %#v/%#v", prov, err)
+	}
+}
+
+func TestEnvCredsAlternateNames(t *testing.T) {
+	os.Clearenv()
+	os.Setenv("AWS_ACCESS_KEY", "access")
+	os.Setenv("AWS_SECRET_KEY", "secret")
+
+	prov, err := EnvCreds()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	creds, err := prov.Credentials()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if v, want := creds.AccessKeyID, "access"; v != want {
+		t.Errorf("Access key ID was %v, expected %v", v, want)
+	}
+
+	if v, want := creds.SecretAccessKey, "secret"; v != want {
+		t.Errorf("Secret access key was %v, expected %v", v, want)
+	}
+}
+
+func TestIAMCreds(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.RequestURI == "/" {
+			fmt.Fprintln(w, "/creds")
+		} else {
+			fmt.Fprintln(w, `{
+  "AccessKeyId" : "accessKey",
+  "SecretAccessKey" : "secret",
+  "Token" : "token",
+  "Expiration" : "2014-12-16T01:51:37Z"
+}`)
+		}
+	}))
+	defer server.Close()
+
+	defer func(s string) {
+		metadataCredentialsEndpoint = s
+	}(metadataCredentialsEndpoint)
+	metadataCredentialsEndpoint = server.URL
+
+	defer func() {
+		currentTime = time.Now
+	}()
+	currentTime = func() time.Time {
+		return time.Date(2014, 12, 15, 21, 26, 0, 0, time.UTC)
+	}
+
+	prov := IAMCreds()
+	creds, err := prov.Credentials()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if v, want := creds.AccessKeyID, "accessKey"; v != want {
+		t.Errorf("AcccessKeyID was %v, but expected %v", v, want)
+	}
+
+	if v, want := creds.SecretAccessKey, "secret"; v != want {
+		t.Errorf("SecretAccessKey was %v, but expected %v", v, want)
+	}
+
+	if v, want := creds.SessionToken, "token"; v != want {
+		t.Errorf("SessionToken was %v, but expected %v", v, want)
+	}
+}
+
+func TestProfileCreds(t *testing.T) {
+	prov, err := ProfileCreds("example.ini", "", 10*time.Minute)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	creds, err := prov.Credentials()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if v, want := creds.AccessKeyID, "accessKey"; v != want {
+		t.Errorf("AcccessKeyID was %v, but expected %v", v, want)
+	}
+
+	if v, want := creds.SecretAccessKey, "secret"; v != want {
+		t.Errorf("SecretAccessKey was %v, but expected %v", v, want)
+	}
+
+	if v, want := creds.SessionToken, "token"; v != want {
+		t.Errorf("SessionToken was %v, but expected %v", v, want)
+	}
+}
+
+func TestProfileCredsWithoutToken(t *testing.T) {
+	prov, err := ProfileCreds("example.ini", "no_token", 10*time.Minute)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	creds, err := prov.Credentials()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if v, want := creds.AccessKeyID, "accessKey"; v != want {
+		t.Errorf("AcccessKeyID was %v, but expected %v", v, want)
+	}
+
+	if v, want := creds.SecretAccessKey, "secret"; v != want {
+		t.Errorf("SecretAccessKey was %v, but expected %v", v, want)
+	}
+
+	if v, want := creds.SessionToken, ""; v != want {
+		t.Errorf("SessionToken was %v, but expected %v", v, want)
+	}
+}
+
+func BenchmarkProfileCreds(b *testing.B) {
+	prov, err := ProfileCreds("example.ini", "", 10*time.Minute)
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	b.ResetTimer()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_, err := prov.Credentials()
+			if err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}
+
+func BenchmarkIAMCreds(b *testing.B) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.RequestURI == "/" {
+			fmt.Fprintln(w, "/creds")
+		} else {
+			fmt.Fprintln(w, `{
+  "AccessKeyId" : "accessKey",
+  "SecretAccessKey" : "secret",
+  "Token" : "token",
+  "Expiration" : "2014-12-16T01:51:37Z"
+}`)
+		}
+	}))
+	defer server.Close()
+
+	defer func(s string) {
+		metadataCredentialsEndpoint = s
+	}(metadataCredentialsEndpoint)
+	metadataCredentialsEndpoint = server.URL
+
+	defer func() {
+		currentTime = time.Now
+	}()
+	currentTime = func() time.Time {
+		return time.Date(2014, 12, 15, 21, 26, 0, 0, time.UTC)
+	}
+
+	b.ResetTimer()
+
+	prov := IAMCreds()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_, err := prov.Credentials()
+			if err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/error.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/error.go
new file mode 100644
index 000000000..6b8989911
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/error.go
@@ -0,0 +1,26 @@
+package aws
+
+import "time"
+
+// An APIError is an error returned by an AWS API.
+type APIError struct {
+	StatusCode int // HTTP status code e.g. 200
+	Code       string
+	Message    string
+	RequestID  string
+	Retryable  bool
+	RetryDelay time.Duration
+	RetryCount uint
+}
+
+func (e APIError) Error() string {
+	return e.Message
+}
+
+func Error(e error) *APIError {
+	if err, ok := e.(APIError); ok {
+		return &err
+	} else {
+		return nil
+	}
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/example.ini b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/example.ini
new file mode 100644
index 000000000..aa2dc506a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/example.ini
@@ -0,0 +1,8 @@
+[default]
+aws_access_key_id = accessKey
+aws_secret_access_key = secret
+aws_session_token = token
+
+[no_token]
+aws_access_key_id = accessKey
+aws_secret_access_key = secret
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/handler_functions.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/handler_functions.go
new file mode 100644
index 000000000..4de0f4a11
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/handler_functions.go
@@ -0,0 +1,78 @@
+package aws
+
+import (
+	"fmt"
+	"io"
+	"time"
+)
+
+var sleepDelay = func(delay time.Duration) {
+	time.Sleep(delay)
+}
+
+type lener interface {
+	Len() int
+}
+
+func BuildContentLength(r *Request) {
+	if r.HTTPRequest.Header.Get("Content-Length") != "" {
+		return
+	}
+
+	var length int64
+	switch body := r.Body.(type) {
+	case nil:
+		length = 0
+	case lener:
+		length = int64(body.Len())
+	case io.Seeker:
+		cur, _ := body.Seek(0, 1)
+		end, _ := body.Seek(0, 2)
+		body.Seek(cur, 0) // make sure to seek back to original location
+		length = end - cur
+	default:
+		panic("Cannot get length of body, must provide `ContentLength`")
+	}
+
+	r.HTTPRequest.ContentLength = length
+	r.HTTPRequest.Header.Set("Content-Length", fmt.Sprintf("%d", length))
+}
+
+func UserAgentHandler(r *Request) {
+	r.HTTPRequest.Header.Set("User-Agent", SDKName+"/"+SDKVersion)
+}
+
+func SendHandler(r *Request) {
+	r.HTTPResponse, r.Error = r.Service.Config.HTTPClient.Do(r.HTTPRequest)
+}
+
+func ValidateResponseHandler(r *Request) {
+	if r.HTTPResponse.StatusCode == 0 || r.HTTPResponse.StatusCode >= 400 {
+		err := APIError{
+			StatusCode: r.HTTPResponse.StatusCode,
+			RetryCount: r.RetryCount,
+		}
+		r.Error = err
+		err.Retryable = r.Service.ShouldRetry(r)
+		err.RetryDelay = r.Service.RetryRules(r)
+		r.Error = err
+	}
+}
+
+func AfterRetryHandler(r *Request) {
+	delay := 0 * time.Second
+	willRetry := false
+
+	if err := Error(r.Error); err != nil {
+		delay = err.RetryDelay
+		if err.Retryable && r.RetryCount < r.Service.MaxRetries() {
+			r.RetryCount++
+			willRetry = true
+		}
+	}
+
+	if willRetry {
+		r.Error = nil
+		sleepDelay(delay)
+	}
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/handlers.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/handlers.go
new file mode 100644
index 000000000..f7c135fed
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/handlers.go
@@ -0,0 +1,65 @@
+package aws
+
+import "container/list"
+
+type Handlers struct {
+	Validate         HandlerList
+	Build            HandlerList
+	Sign             HandlerList
+	Send             HandlerList
+	ValidateResponse HandlerList
+	Unmarshal        HandlerList
+	UnmarshalMeta    HandlerList
+	UnmarshalError   HandlerList
+	Retry            HandlerList
+	AfterRetry       HandlerList
+}
+
+func (h *Handlers) copy() Handlers {
+	return Handlers{
+		Validate:         h.Validate.copy(),
+		Build:            h.Build.copy(),
+		Sign:             h.Sign.copy(),
+		Send:             h.Send.copy(),
+		ValidateResponse: h.ValidateResponse.copy(),
+		Unmarshal:        h.Unmarshal.copy(),
+		UnmarshalError:   h.UnmarshalError.copy(),
+		UnmarshalMeta:    h.UnmarshalMeta.copy(),
+		Retry:            h.Retry.copy(),
+		AfterRetry:       h.AfterRetry.copy(),
+	}
+}
+
+// Clear removes callback functions for all handlers
+func (h *Handlers) Clear() {
+	h.Validate.Init()
+	h.Build.Init()
+	h.Send.Init()
+	h.Sign.Init()
+	h.Unmarshal.Init()
+	h.UnmarshalMeta.Init()
+	h.UnmarshalError.Init()
+	h.ValidateResponse.Init()
+	h.Retry.Init()
+	h.AfterRetry.Init()
+}
+
+type HandlerList struct {
+	list.List
+}
+
+func (l HandlerList) copy() HandlerList {
+	var n HandlerList
+	for e := l.Front(); e != nil; e = e.Next() {
+		h := e.Value.(func(*Request))
+		n.PushBack(h)
+	}
+	return n
+}
+
+func (l *HandlerList) Run(r *Request) {
+	for e := l.Front(); e != nil; e = e.Next() {
+		h := e.Value.(func(*Request))
+		h(r)
+	}
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/handlers_test.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/handlers_test.go
new file mode 100644
index 000000000..89e87cc49
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/handlers_test.go
@@ -0,0 +1,24 @@
+package aws
+
+import "testing"
+
+func TestHandlerList(t *testing.T) {
+	r := &Request{}
+	l := HandlerList{}
+	l.PushBack(func(r *Request) { r.Data = Boolean(true) })
+	l.Run(r)
+	if r.Data == nil {
+		t.Error("Expected handler to execute")
+	}
+}
+
+func TestMultipleHandlers(t *testing.T) {
+	r := &Request{}
+	l := HandlerList{}
+	l.PushBack(func(r *Request) { r.Data = Boolean(true) })
+	l.PushBack(func(r *Request) { r.Data = nil })
+	l.Run(r)
+	if r.Data != nil {
+		t.Error("Expected handler to execute")
+	}
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/param_validator.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/param_validator.go
new file mode 100644
index 000000000..e1cb5cea5
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/param_validator.go
@@ -0,0 +1,80 @@
+package aws
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+func ValidateParameters(r *Request) {
+	if r.ParamsFilled() {
+		v := validator{errors: []string{}}
+		v.validateAny(reflect.ValueOf(r.Params), "")
+
+		if count := len(v.errors); count > 0 {
+			format := "%d validation errors:\n- %s"
+			msg := fmt.Sprintf(format, count, strings.Join(v.errors, "\n- "))
+			r.Error = APIError{Code: "InvalidParameter", Message: msg}
+		}
+	}
+}
+
+type validator struct {
+	errors []string
+}
+
+func (v *validator) validateAny(value reflect.Value, path string) {
+	value = reflect.Indirect(value)
+	if !value.IsValid() {
+		return
+	}
+
+	switch value.Kind() {
+	case reflect.Struct:
+		v.validateStruct(value, path)
+	case reflect.Slice:
+		for i := 0; i < value.Len(); i++ {
+			v.validateAny(value.Index(i), path+fmt.Sprintf("[%d]", i))
+		}
+	case reflect.Map:
+		for _, n := range value.MapKeys() {
+			v.validateAny(value.MapIndex(n), path+fmt.Sprintf("[%q]", n.String()))
+		}
+	}
+}
+
+func (v *validator) validateStruct(value reflect.Value, path string) {
+	prefix := "."
+	if path == "" {
+		prefix = ""
+	}
+
+	for i := 0; i < value.Type().NumField(); i++ {
+		f := value.Type().Field(i)
+		if strings.ToLower(f.Name[0:1]) == f.Name[0:1] {
+			continue
+		}
+		fvalue := value.FieldByName(f.Name)
+
+		notset := false
+		if f.Tag.Get("required") != "" {
+			switch fvalue.Kind() {
+			case reflect.Ptr, reflect.Slice:
+				if fvalue.IsNil() {
+					notset = true
+				}
+			default:
+				if !fvalue.IsValid() {
+					notset = true
+				}
+			}
+		}
+
+		if notset {
+			msg := "missing required parameter: " + path + prefix + f.Name
+			v.errors = append(v.errors, msg)
+		} else {
+			v.validateAny(fvalue, path+prefix+f.Name)
+		}
+	}
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/param_validator_test.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/param_validator_test.go
new file mode 100644
index 000000000..08deca15a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/param_validator_test.go
@@ -0,0 +1,85 @@
+package aws_test
+
+import (
+	"testing"
+
+	"github.com/awslabs/aws-sdk-go/aws"
+	"github.com/stretchr/testify/assert"
+)
+
+var service = func() *aws.Service {
+	s := &aws.Service{
+		Config:      &aws.Config{},
+		ServiceName: "mock-service",
+		APIVersion:  "2015-01-01",
+	}
+	return s
+}()
+
+type StructShape struct {
+	RequiredList   []*ConditionalStructShape           `required:"true"`
+	RequiredMap    *map[string]*ConditionalStructShape `required:"true"`
+	RequiredBool   *bool                               `required:"true"`
+	OptionalStruct *ConditionalStructShape
+
+	hiddenParameter *string
+
+	metadataStructureShape
+}
+
+type metadataStructureShape struct {
+	SDKShapeTraits bool
+}
+
+type ConditionalStructShape struct {
+	Name           *string `required:"true"`
+	SDKShapeTraits bool
+}
+
+func TestNoErrors(t *testing.T) {
+	input := &StructShape{
+		RequiredList: []*ConditionalStructShape{},
+		RequiredMap: &map[string]*ConditionalStructShape{
+			"key1": &ConditionalStructShape{Name: aws.String("Name")},
+			"key2": &ConditionalStructShape{Name: aws.String("Name")},
+		},
+		RequiredBool:   aws.Boolean(true),
+		OptionalStruct: &ConditionalStructShape{Name: aws.String("Name")},
+	}
+
+	req := aws.NewRequest(service, &aws.Operation{}, input, nil)
+	aws.ValidateParameters(req)
+	assert.NoError(t, req.Error)
+}
+
+func TestMissingRequiredParameters(t *testing.T) {
+	input := &StructShape{}
+	req := aws.NewRequest(service, &aws.Operation{}, input, nil)
+	aws.ValidateParameters(req)
+	err := aws.Error(req.Error)
+
+	assert.Error(t, err)
+	assert.Equal(t, "InvalidParameter", err.Code)
+	assert.Equal(t, "3 validation errors:\n- missing required parameter: RequiredList\n- missing required parameter: RequiredMap\n- missing required parameter: RequiredBool", err.Message)
+}
+
+func TestNestedMissingRequiredParameters(t *testing.T) {
+	input := &StructShape{
+		RequiredList: []*ConditionalStructShape{&ConditionalStructShape{}},
+		RequiredMap: &map[string]*ConditionalStructShape{
+			"key1": &ConditionalStructShape{Name: aws.String("Name")},
+			"key2": &ConditionalStructShape{},
+		},
+		RequiredBool:   aws.Boolean(true),
+		OptionalStruct: &ConditionalStructShape{},
+	}
+
+	req := aws.NewRequest(service, &aws.Operation{}, input, nil)
+	aws.ValidateParameters(req)
+	err := aws.Error(req.Error)
+
+	assert.Error(t, err)
+	assert.Equal(t, "InvalidParameter", err.Code)
+	assert.Equal(t, "3 validation errors:\n- missing required parameter: RequiredList[0].Name\n- missing required parameter: RequiredMap[\"key2\"].Name\n- missing required parameter: OptionalStruct.Name", err.Message)
+
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/request.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/request.go
new file mode 100644
index 000000000..1c442b1cd
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/request.go
@@ -0,0 +1,149 @@
+package aws
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"reflect"
+	"time"
+)
+
+type Request struct {
+	*Service
+	Handlers     Handlers
+	Time         time.Time
+	ExpireTime   time.Duration
+	Operation    *Operation
+	HTTPRequest  *http.Request
+	HTTPResponse *http.Response
+	Body         io.ReadSeeker
+	Params       interface{}
+	Error        error
+	Data         interface{}
+	RequestID    string
+	RetryCount   uint
+
+	built bool
+}
+
+type Operation struct {
+	Name       string
+	HTTPMethod string
+	HTTPPath   string
+}
+
+func NewRequest(service *Service, operation *Operation, params interface{}, data interface{}) *Request {
+	method := operation.HTTPMethod
+	if method == "" {
+		method = "POST"
+	}
+	p := operation.HTTPPath
+	if p == "" {
+		p = "/"
+	}
+
+	httpReq, _ := http.NewRequest(method, "", nil)
+	httpReq.URL, _ = url.Parse(service.Endpoint + p)
+
+	r := &Request{
+		Service:     service,
+		Handlers:    service.Handlers.copy(),
+		Time:        time.Now(),
+		ExpireTime:  0,
+		Operation:   operation,
+		HTTPRequest: httpReq,
+		Body:        nil,
+		Params:      params,
+		Error:       nil,
+		Data:        data,
+	}
+	r.SetBufferBody([]byte{})
+
+	return r
+}
+
+func (r *Request) ParamsFilled() bool {
+	return r.Params != nil && reflect.ValueOf(r.Params).Elem().IsValid()
+}
+
+func (r *Request) DataFilled() bool {
+	return r.Data != nil && reflect.ValueOf(r.Data).Elem().IsValid()
+}
+
+func (r *Request) SetBufferBody(buf []byte) {
+	r.SetReaderBody(bytes.NewReader(buf))
+}
+
+func (r *Request) SetReaderBody(reader io.ReadSeeker) {
+	r.HTTPRequest.Body = ioutil.NopCloser(reader)
+	r.Body = reader
+}
+
+func (r *Request) Presign(expireTime time.Duration) (string, error) {
+	r.ExpireTime = expireTime
+	r.Sign()
+	if r.Error != nil {
+		return "", r.Error
+	} else {
+		return r.HTTPRequest.URL.String(), nil
+	}
+}
+
+func (r *Request) Build() error {
+	if !r.built {
+		r.Error = nil
+		r.Handlers.Validate.Run(r)
+		if r.Error != nil {
+			return r.Error
+		}
+		r.Handlers.Build.Run(r)
+		r.built = true
+	}
+
+	return r.Error
+}
+
+func (r *Request) Sign() error {
+	r.Build()
+	if r.Error != nil {
+		return r.Error
+	}
+
+	r.Handlers.Sign.Run(r)
+	return r.Error
+}
+
+func (r *Request) Send() error {
+	r.Sign()
+	if r.Error != nil {
+		return r.Error
+	}
+
+	for {
+		r.Handlers.Send.Run(r)
+		if r.Error != nil {
+			return r.Error
+		}
+
+		r.Handlers.UnmarshalMeta.Run(r)
+		r.Handlers.ValidateResponse.Run(r)
+		if r.Error != nil {
+			r.Handlers.Retry.Run(r)
+			r.Handlers.AfterRetry.Run(r)
+			if r.Error != nil {
+				r.Handlers.UnmarshalError.Run(r)
+				return r.Error
+			}
+			continue
+		}
+
+		r.Handlers.Unmarshal.Run(r)
+		if r.Error != nil {
+			return r.Error
+		}
+
+		return nil
+	}
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/request_test.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/request_test.go
new file mode 100644
index 000000000..b27b55067
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/request_test.go
@@ -0,0 +1,118 @@
+package aws
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type testData struct {
+	Data string
+}
+
+func body(str string) io.ReadCloser {
+	return ioutil.NopCloser(bytes.NewReader([]byte(str)))
+}
+
+func unmarshal(req *Request) {
+	defer req.HTTPResponse.Body.Close()
+	if req.Data != nil {
+		json.NewDecoder(req.HTTPResponse.Body).Decode(req.Data)
+	}
+	return
+}
+
+func unmarshalError(req *Request) {
+	bodyBytes, err := ioutil.ReadAll(req.HTTPResponse.Body)
+	if err != nil {
+		req.Error = err
+		return
+	}
+	if len(bodyBytes) == 0 {
+		req.Error = APIError{
+			StatusCode: req.HTTPResponse.StatusCode,
+			Message:    req.HTTPResponse.Status,
+		}
+		return
+	}
+	var jsonErr jsonErrorResponse
+	if err := json.Unmarshal(bodyBytes, &jsonErr); err != nil {
+		req.Error = err
+		return
+	}
+	req.Error = APIError{
+		StatusCode: req.HTTPResponse.StatusCode,
+		Code:       jsonErr.Code,
+		Message:    jsonErr.Message,
+	}
+}
+
+type jsonErrorResponse struct {
+	Code    string `json:"__type"`
+	Message string `json:"message"`
+}
+
+func TestRequestRecoverRetry(t *testing.T) {
+	reqNum := 0
+	reqs := []http.Response{
+		http.Response{StatusCode: 500, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)},
+		http.Response{StatusCode: 500, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)},
+		http.Response{StatusCode: 200, Body: body(`{"data":"valid"}`)},
+	}
+
+	s := NewService(&Config{MaxRetries: -1})
+	s.Handlers.Unmarshal.PushBack(unmarshal)
+	s.Handlers.UnmarshalError.PushBack(unmarshalError)
+	s.Handlers.Send.Init() // mock sending
+	s.Handlers.Send.PushBack(func(r *Request) {
+		r.HTTPResponse = &reqs[reqNum]
+		reqNum++
+	})
+	out := &testData{}
+	r := NewRequest(s, &Operation{Name: "Operation"}, nil, out)
+	err := r.Send()
+	assert.Nil(t, err)
+	assert.Equal(t, 2, int(r.RetryCount))
+	assert.Equal(t, "valid", out.Data)
+}
+
+func TestRequestExhaustRetries(t *testing.T) {
+	delays := []time.Duration{}
+	sleepDelay = func(delay time.Duration) {
+		delays = append(delays, delay)
+	}
+
+	reqNum := 0
+	reqs := []http.Response{
+		http.Response{StatusCode: 500, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)},
+		http.Response{StatusCode: 500, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)},
+		http.Response{StatusCode: 500, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)},
+		http.Response{StatusCode: 500, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)},
+	}
+
+	s := NewService(&Config{MaxRetries: -1})
+	s.Handlers.Unmarshal.PushBack(unmarshal)
+	s.Handlers.UnmarshalError.PushBack(unmarshalError)
+	s.Handlers.Send.Init() // mock sending
+	s.Handlers.Send.PushBack(func(r *Request) {
+		r.HTTPResponse = &reqs[reqNum]
+		reqNum++
+	})
+	r := NewRequest(s, &Operation{Name: "Operation"}, nil, nil)
+	err := r.Send()
+	apiErr := Error(err)
+	assert.NotNil(t, err)
+	assert.NotNil(t, apiErr)
+	assert.Equal(t, 500, apiErr.StatusCode)
+	assert.Equal(t, "UnknownError", apiErr.Code)
+	assert.Equal(t, "An error occurred.", apiErr.Message)
+	assert.Equal(t, 3, int(r.RetryCount))
+	assert.True(t, reflect.DeepEqual([]time.Duration{30 * time.Millisecond, 60 * time.Millisecond, 120 * time.Millisecond}, delays))
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/service.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/service.go
new file mode 100644
index 000000000..95d590b91
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/service.go
@@ -0,0 +1,142 @@
+package aws
+
+import (
+	"fmt"
+	"math"
+	"net/http"
+	"net/http/httputil"
+	"regexp"
+	"time"
+
+	"github.com/awslabs/aws-sdk-go/internal/endpoints"
+)
+
+type Service struct {
+	Config            *Config
+	Handlers          Handlers
+	ManualSend        bool
+	ServiceName       string
+	APIVersion        string
+	Endpoint          string
+	JSONVersion       string
+	TargetPrefix      string
+	RetryRules        func(*Request) time.Duration
+	ShouldRetry       func(*Request) bool
+	DefaultMaxRetries uint
+}
+
+var schemeRE = regexp.MustCompile("^([^:]+)://")
+
+func NewService(config *Config) *Service {
+	svc := &Service{Config: config}
+	svc.Initialize()
+	return svc
+}
+
+func (s *Service) Initialize() {
+	if s.Config == nil {
+		s.Config = &Config{}
+	}
+	if s.Config.HTTPClient == nil {
+		s.Config.HTTPClient = http.DefaultClient
+	}
+
+	if s.RetryRules == nil {
+		s.RetryRules = retryRules
+	}
+
+	if s.ShouldRetry == nil {
+		s.ShouldRetry = shouldRetry
+	}
+
+	s.DefaultMaxRetries = 3
+	s.Handlers.Build.PushBack(UserAgentHandler)
+	s.Handlers.Sign.PushBack(BuildContentLength)
+	s.Handlers.Send.PushBack(SendHandler)
+	s.Handlers.AfterRetry.PushBack(AfterRetryHandler)
+	s.Handlers.ValidateResponse.PushBack(ValidateResponseHandler)
+	s.AddDebugHandlers()
+	s.buildEndpoint()
+
+	if !s.Config.DisableParamValidation {
+		s.Handlers.Validate.PushBack(ValidateParameters)
+	}
+}
+
+func (s *Service) buildEndpoint() {
+	if s.Config.Endpoint != "" {
+		s.Endpoint = s.Config.Endpoint
+	} else {
+		s.Endpoint = endpoints.EndpointForRegion(s.ServiceName, s.Config.Region)
+	}
+
+	if !schemeRE.MatchString(s.Endpoint) {
+		scheme := "https"
+		if s.Config.DisableSSL {
+			scheme = "http"
+		}
+		s.Endpoint = scheme + "://" + s.Endpoint
+	}
+}
+
+func (s *Service) AddDebugHandlers() {
+	out := s.Config.Logger
+	if s.Config.LogLevel == 0 {
+		return
+	}
+
+	s.Handlers.Sign.PushBack(func(r *Request) {
+		dumpedBody, _ := httputil.DumpRequest(r.HTTPRequest, true)
+
+		fmt.Fprintf(out, "=> [%s] %s.%s(%+v)\n", r.Time,
+			r.Service.ServiceName, r.Operation.Name, r.Params)
+		fmt.Fprintf(out, "---[ REQUEST PRE-SIGN ]------------------------------\n")
+		fmt.Fprintf(out, "%s\n", string(dumpedBody))
+		fmt.Fprintf(out, "-----------------------------------------------------\n")
+	})
+	s.Handlers.Send.PushFront(func(r *Request) {
+		dumpedBody, _ := httputil.DumpRequest(r.HTTPRequest, true)
+
+		fmt.Fprintf(out, "---[ REQUEST POST-SIGN ]-----------------------------\n")
+		fmt.Fprintf(out, "%s\n", string(dumpedBody))
+		fmt.Fprintf(out, "-----------------------------------------------------\n")
+	})
+	s.Handlers.Send.PushBack(func(r *Request) {
+		fmt.Fprintf(out, "---[ RESPONSE ]--------------------------------------\n")
+		if r.HTTPResponse != nil {
+			dumpedBody, _ := httputil.DumpResponse(r.HTTPResponse, true)
+			fmt.Fprintf(out, "%s\n", string(dumpedBody))
+		} else if r.Error != nil {
+			fmt.Fprintf(out, "%s\n", r.Error)
+		}
+		fmt.Fprintf(out, "-----------------------------------------------------\n")
+	})
+}
+
+func (s *Service) MaxRetries() uint {
+	if s.Config.MaxRetries < 0 {
+		return s.DefaultMaxRetries
+	} else {
+		return uint(s.Config.MaxRetries)
+	}
+}
+
+func retryRules(r *Request) time.Duration {
+	delay := time.Duration(math.Pow(2, float64(r.RetryCount))) * 30
+	return delay * time.Millisecond
+}
+
+func shouldRetry(r *Request) bool {
+	if err := Error(r.Error); err != nil {
+		if err.StatusCode >= 500 {
+			return true
+		}
+
+		switch err.Code {
+		case "ExpiredTokenException":
+		case "ProvisionedThroughputExceededException", "Throttling":
+			return true
+		}
+	}
+	return false
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/types.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/types.go
new file mode 100644
index 000000000..5da09114c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/types.go
@@ -0,0 +1,63 @@
+package aws
+
+import (
+	"io"
+	"time"
+)
+
+// String converts a Go string into a string pointer.
+func String(v string) *string {
+	return &v
+}
+
+// Boolean converts a Go bool into a boolean pointer.
+func Boolean(v bool) *bool {
+	return &v
+}
+
+// Long converts a Go int64 into a long pointer.
+func Long(v int64) *int64 {
+	return &v
+}
+
+// Double converts a Go float64 into a double pointer.
+func Double(v float64) *float64 {
+	return &v
+}
+
+// Time converts a Go Time into a Time pointer
+func Time(t time.Time) *time.Time {
+	return &t
+}
+
+func ReadSeekCloser(r io.Reader) ReaderSeekerCloser {
+	return ReaderSeekerCloser{r}
+}
+
+type ReaderSeekerCloser struct {
+	r io.Reader
+}
+
+func (r ReaderSeekerCloser) Read(p []byte) (int, error) {
+	switch t := r.r.(type) {
+	case io.Reader:
+		return t.Read(p)
+	}
+	return 0, nil
+}
+
+func (r ReaderSeekerCloser) Seek(offset int64, whence int) (int64, error) {
+	switch t := r.r.(type) {
+	case io.Seeker:
+		return t.Seek(offset, whence)
+	}
+	return int64(0), nil
+}
+
+func (r ReaderSeekerCloser) Close() error {
+	switch t := r.r.(type) {
+	case io.Closer:
+		return t.Close()
+	}
+	return nil
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/version.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/version.go
new file mode 100644
index 000000000..f673d470a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/aws/version.go
@@ -0,0 +1,5 @@
+// Package aws provides core functionality for making requests to AWS services.
+package aws
+
+const SDKName = "aws-sdk-go"
+const SDKVersion = "0.5.0"
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/endpoints/endpoints.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/endpoints/endpoints.go
new file mode 100644
index 000000000..12e4fb529
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/endpoints/endpoints.go
@@ -0,0 +1,24 @@
+package endpoints
+
+//go:generate go run ../model/cli/gen-endpoints/main.go endpoints.json endpoints_map.go
+
+import "strings"
+
+func EndpointForRegion(svcName, region string) string {
+	derivedKeys := []string{
+		region + "/" + svcName,
+		region + "/*",
+		"*/" + svcName,
+		"*/*",
+	}
+
+	for _, key := range derivedKeys {
+		if val, ok := endpointsMap.Endpoints[key]; ok {
+			ep := val.Endpoint
+			ep = strings.Replace(ep, "{region}", region, -1)
+			ep = strings.Replace(ep, "{service}", svcName, -1)
+			return ep
+		}
+	}
+	return ""
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/endpoints/endpoints.json b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/endpoints/endpoints.json
new file mode 100644
index 000000000..6c35090c6
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/endpoints/endpoints.json
@@ -0,0 +1,67 @@
+{
+  "version": 2,
+  "endpoints": {
+    "*/*": {
+      "endpoint": "{service}.{region}.amazonaws.com"
+    },
+    "cn-north-1/*": {
+      "endpoint": "{service}.{region}.amazonaws.com.cn",
+      "signatureVersion": "v4"
+    },
+    "us-gov-west-1/iam": {
+      "endpoint": "iam.us-gov.amazonaws.com"
+    },
+    "us-gov-west-1/sts": {
+      "endpoint": "sts.us-gov-west-1.amazonaws.com"
+    },
+    "us-gov-west-1/s3": {
+      "endpoint": "s3-{region}.amazonaws.com"
+    },
+    "*/cloudfront": {
+      "endpoint": "cloudfront.amazonaws.com"
+    },
+    "*/iam": {
+      "endpoint": "iam.amazonaws.com"
+    },
+    "*/importexport": {
+      "endpoint": "importexport.amazonaws.com"
+    },
+    "*/route53": {
+      "endpoint": "route53.amazonaws.com"
+    },
+    "*/sts": {
+      "endpoint": "sts.amazonaws.com"
+    },
+    "us-east-1/sdb": {
+      "endpoint": "sdb.amazonaws.com"
+    },
+    "us-east-1/s3": {
+      "endpoint": "s3.amazonaws.com"
+    },
+    "us-west-1/s3": {
+      "endpoint": "s3-{region}.amazonaws.com"
+    },
+    "us-west-2/s3": {
+      "endpoint": "s3-{region}.amazonaws.com"
+    },
+    "eu-west-1/s3": {
+      "endpoint": "s3-{region}.amazonaws.com"
+    },
+    "ap-southeast-1/s3": {
+      "endpoint": "s3-{region}.amazonaws.com"
+    },
+    "ap-southeast-2/s3": {
+      "endpoint": "s3-{region}.amazonaws.com"
+    },
+    "ap-northeast-1/s3": {
+      "endpoint": "s3-{region}.amazonaws.com"
+    },
+    "sa-east-1/s3": {
+      "endpoint": "s3-{region}.amazonaws.com"
+    },
+    "eu-central-1/s3": {
+      "endpoint": "{service}.{region}.amazonaws.com",
+      "signatureVersion": "v4"
+    }
+  }
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/endpoints/endpoints_map.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/endpoints/endpoints_map.go
new file mode 100644
index 000000000..733d2bd28
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/endpoints/endpoints_map.go
@@ -0,0 +1,78 @@
+package endpoints
+
+// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
+
+type endpointStruct struct {
+	Version   int
+	Endpoints map[string]endpointEntry
+}
+
+type endpointEntry struct {
+	Endpoint string
+}
+
+var endpointsMap = endpointStruct{
+	Version: 2,
+	Endpoints: map[string]endpointEntry{
+		"*/*": endpointEntry{
+			Endpoint: "{service}.{region}.amazonaws.com",
+		},
+		"*/cloudfront": endpointEntry{
+			Endpoint: "cloudfront.amazonaws.com",
+		},
+		"*/iam": endpointEntry{
+			Endpoint: "iam.amazonaws.com",
+		},
+		"*/importexport": endpointEntry{
+			Endpoint: "importexport.amazonaws.com",
+		},
+		"*/route53": endpointEntry{
+			Endpoint: "route53.amazonaws.com",
+		},
+		"*/sts": endpointEntry{
+			Endpoint: "sts.amazonaws.com",
+		},
+		"ap-northeast-1/s3": endpointEntry{
+			Endpoint: "s3-{region}.amazonaws.com",
+		},
+		"ap-southeast-1/s3": endpointEntry{
+			Endpoint: "s3-{region}.amazonaws.com",
+		},
+		"ap-southeast-2/s3": endpointEntry{
+			Endpoint: "s3-{region}.amazonaws.com",
+		},
+		"cn-north-1/*": endpointEntry{
+			Endpoint: "{service}.{region}.amazonaws.com.cn",
+		},
+		"eu-central-1/s3": endpointEntry{
+			Endpoint: "{service}.{region}.amazonaws.com",
+		},
+		"eu-west-1/s3": endpointEntry{
+			Endpoint: "s3-{region}.amazonaws.com",
+		},
+		"sa-east-1/s3": endpointEntry{
+			Endpoint: "s3-{region}.amazonaws.com",
+		},
+		"us-east-1/s3": endpointEntry{
+			Endpoint: "s3.amazonaws.com",
+		},
+		"us-east-1/sdb": endpointEntry{
+			Endpoint: "sdb.amazonaws.com",
+		},
+		"us-gov-west-1/iam": endpointEntry{
+			Endpoint: "iam.us-gov.amazonaws.com",
+		},
+		"us-gov-west-1/s3": endpointEntry{
+			Endpoint: "s3-{region}.amazonaws.com",
+		},
+		"us-gov-west-1/sts": endpointEntry{
+			Endpoint: "sts.us-gov-west-1.amazonaws.com",
+		},
+		"us-west-1/s3": endpointEntry{
+			Endpoint: "s3-{region}.amazonaws.com",
+		},
+		"us-west-2/s3": endpointEntry{
+			Endpoint: "s3-{region}.amazonaws.com",
+		},
+	},
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/endpoints/endpoints_test.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/endpoints/endpoints_test.go
new file mode 100644
index 000000000..84efb893e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/endpoints/endpoints_test.go
@@ -0,0 +1,25 @@
+package endpoints
+
+import "testing"
+
+func TestGlobalEndpoints(t *testing.T) {
+	region := "mock-region-1"
+	svcs := []string{"cloudfront", "iam", "importexport", "route53", "sts"}
+
+	for _, name := range svcs {
+		if EndpointForRegion(name, region) != name+".amazonaws.com" {
+			t.Errorf("expected endpoint for %s to equal %s.amazonaws.com", name, name)
+		}
+	}
+}
+
+func TestServicesInCN(t *testing.T) {
+	region := "cn-north-1"
+	svcs := []string{"cloudfront", "iam", "importexport", "route53", "sts", "s3"}
+
+	for _, name := range svcs {
+		if EndpointForRegion(name, region) != name+"."+region+".amazonaws.com.cn" {
+			t.Errorf("expected endpoint for %s to equal %s.%s.amazonaws.com.cn", name, name, region)
+		}
+	}
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/build.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/build.go
new file mode 100644
index 000000000..74b721658
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/build.go
@@ -0,0 +1,30 @@
+package query
+
+//go:generate go run ../../fixtures/protocol/generate.go ../../fixtures/protocol/input/query.json build_test.go
+
+import (
+	"net/url"
+
+	"github.com/awslabs/aws-sdk-go/aws"
+	"github.com/awslabs/aws-sdk-go/internal/protocol/query/queryutil"
+)
+
+func Build(r *aws.Request) {
+	body := url.Values{
+		"Action":  {r.Operation.Name},
+		"Version": {r.Service.APIVersion},
+	}
+	if err := queryutil.Parse(body, r.Params, false); err != nil {
+		r.Error = err
+		return
+	}
+
+	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()
+	}
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/build_test.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/build_test.go
new file mode 100644
index 000000000..bbba7b4cd
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/build_test.go
@@ -0,0 +1,1167 @@
+package query_test
+
+import (
+	"github.com/awslabs/aws-sdk-go/aws"
+	"github.com/awslabs/aws-sdk-go/internal/protocol/query"
+	"github.com/awslabs/aws-sdk-go/internal/signer/v4"
+
+	"bytes"
+	"encoding/json"
+	"encoding/xml"
+	"github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil"
+	"github.com/awslabs/aws-sdk-go/internal/util"
+	"github.com/stretchr/testify/assert"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"testing"
+	"time"
+)
+
+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{}
+
+// InputService1ProtocolTest is a client for InputService1ProtocolTest.
+type InputService1ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService1ProtocolTest client.
+func NewInputService1ProtocolTest(config *aws.Config) *InputService1ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	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(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &InputService1ProtocolTest{service}
+}
+
+// InputService1TestCaseOperation1Request generates a request for the InputService1TestCaseOperation1 operation.
+func (c *InputService1ProtocolTest) InputService1TestCaseOperation1Request(input *InputService1TestShapeInputShape) (req *aws.Request, output *InputService1TestShapeInputService1TestCaseOperation1Output) {
+	if opInputService1TestCaseOperation1 == nil {
+		opInputService1TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService1TestCaseOperation1, input, output)
+	output = &InputService1TestShapeInputService1TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService1ProtocolTest) InputService1TestCaseOperation1(input *InputService1TestShapeInputShape) (output *InputService1TestShapeInputService1TestCaseOperation1Output, err error) {
+	req, out := c.InputService1TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService1TestCaseOperation1 *aws.Operation
+
+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"`
+}
+
+// InputService2ProtocolTest is a client for InputService2ProtocolTest.
+type InputService2ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService2ProtocolTest client.
+func NewInputService2ProtocolTest(config *aws.Config) *InputService2ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	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(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &InputService2ProtocolTest{service}
+}
+
+// InputService2TestCaseOperation1Request generates a request for the InputService2TestCaseOperation1 operation.
+func (c *InputService2ProtocolTest) InputService2TestCaseOperation1Request(input *InputService2TestShapeInputShape) (req *aws.Request, output *InputService2TestShapeInputService2TestCaseOperation1Output) {
+	if opInputService2TestCaseOperation1 == nil {
+		opInputService2TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService2TestCaseOperation1, input, output)
+	output = &InputService2TestShapeInputService2TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService2ProtocolTest) InputService2TestCaseOperation1(input *InputService2TestShapeInputShape) (output *InputService2TestShapeInputService2TestCaseOperation1Output, err error) {
+	req, out := c.InputService2TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService2TestCaseOperation1 *aws.Operation
+
+type InputService2TestShapeInputService2TestCaseOperation1Output struct {
+	metadataInputService2TestShapeInputService2TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService2TestShapeInputService2TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService2TestShapeInputShape struct {
+	StructArg *InputService2TestShapeStructType `type:"structure"`
+
+	metadataInputService2TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService2TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService2TestShapeStructType struct {
+	ScalarArg *string `type:"string"`
+
+	metadataInputService2TestShapeStructType `json:"-", xml:"-"`
+}
+
+type metadataInputService2TestShapeStructType struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// InputService3ProtocolTest is a client for InputService3ProtocolTest.
+type InputService3ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService3ProtocolTest client.
+func NewInputService3ProtocolTest(config *aws.Config) *InputService3ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	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(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &InputService3ProtocolTest{service}
+}
+
+// InputService3TestCaseOperation1Request generates a request for the InputService3TestCaseOperation1 operation.
+func (c *InputService3ProtocolTest) InputService3TestCaseOperation1Request(input *InputService3TestShapeInputShape) (req *aws.Request, output *InputService3TestShapeInputService3TestCaseOperation1Output) {
+	if opInputService3TestCaseOperation1 == nil {
+		opInputService3TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService3TestCaseOperation1, input, output)
+	output = &InputService3TestShapeInputService3TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService3ProtocolTest) InputService3TestCaseOperation1(input *InputService3TestShapeInputShape) (output *InputService3TestShapeInputService3TestCaseOperation1Output, err error) {
+	req, out := c.InputService3TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService3TestCaseOperation1 *aws.Operation
+
+type InputService3TestShapeInputService3TestCaseOperation1Output struct {
+	metadataInputService3TestShapeInputService3TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService3TestShapeInputService3TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService3TestShapeInputShape struct {
+	ListArg []*string `type:"list"`
+
+	metadataInputService3TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService3TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// InputService4ProtocolTest is a client for InputService4ProtocolTest.
+type InputService4ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService4ProtocolTest client.
+func NewInputService4ProtocolTest(config *aws.Config) *InputService4ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	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(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &InputService4ProtocolTest{service}
+}
+
+// InputService4TestCaseOperation1Request generates a request for the InputService4TestCaseOperation1 operation.
+func (c *InputService4ProtocolTest) InputService4TestCaseOperation1Request(input *InputService4TestShapeInputShape) (req *aws.Request, output *InputService4TestShapeInputService4TestCaseOperation1Output) {
+	if opInputService4TestCaseOperation1 == nil {
+		opInputService4TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService4TestCaseOperation1, input, output)
+	output = &InputService4TestShapeInputService4TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService4ProtocolTest) InputService4TestCaseOperation1(input *InputService4TestShapeInputShape) (output *InputService4TestShapeInputService4TestCaseOperation1Output, err error) {
+	req, out := c.InputService4TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService4TestCaseOperation1 *aws.Operation
+
+type InputService4TestShapeInputService4TestCaseOperation1Output struct {
+	metadataInputService4TestShapeInputService4TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService4TestShapeInputService4TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService4TestShapeInputShape struct {
+	ListArg []*string `type:"list" flattened:"true"`
+
+	ScalarArg *string `type:"string"`
+
+	metadataInputService4TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService4TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// InputService5ProtocolTest is a client for InputService5ProtocolTest.
+type InputService5ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService5ProtocolTest client.
+func NewInputService5ProtocolTest(config *aws.Config) *InputService5ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	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(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &InputService5ProtocolTest{service}
+}
+
+// InputService5TestCaseOperation1Request generates a request for the InputService5TestCaseOperation1 operation.
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation1Request(input *InputService5TestShapeInputShape) (req *aws.Request, output *InputService5TestShapeInputService5TestCaseOperation1Output) {
+	if opInputService5TestCaseOperation1 == nil {
+		opInputService5TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService5TestCaseOperation1, input, output)
+	output = &InputService5TestShapeInputService5TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation1(input *InputService5TestShapeInputShape) (output *InputService5TestShapeInputService5TestCaseOperation1Output, err error) {
+	req, out := c.InputService5TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService5TestCaseOperation1 *aws.Operation
+
+type InputService5TestShapeInputService5TestCaseOperation1Output struct {
+	metadataInputService5TestShapeInputService5TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService5TestShapeInputService5TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService5TestShapeInputShape struct {
+	MapArg *map[string]*string `type:"map"`
+
+	metadataInputService5TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService5TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// InputService6ProtocolTest is a client for InputService6ProtocolTest.
+type InputService6ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService6ProtocolTest client.
+func NewInputService6ProtocolTest(config *aws.Config) *InputService6ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	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(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &InputService6ProtocolTest{service}
+}
+
+// InputService6TestCaseOperation1Request generates a request for the InputService6TestCaseOperation1 operation.
+func (c *InputService6ProtocolTest) InputService6TestCaseOperation1Request(input *InputService6TestShapeInputShape) (req *aws.Request, output *InputService6TestShapeInputService6TestCaseOperation1Output) {
+	if opInputService6TestCaseOperation1 == nil {
+		opInputService6TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService6TestCaseOperation1, input, output)
+	output = &InputService6TestShapeInputService6TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService6ProtocolTest) InputService6TestCaseOperation1(input *InputService6TestShapeInputShape) (output *InputService6TestShapeInputService6TestCaseOperation1Output, err error) {
+	req, out := c.InputService6TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService6TestCaseOperation1 *aws.Operation
+
+type InputService6TestShapeInputService6TestCaseOperation1Output struct {
+	metadataInputService6TestShapeInputService6TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService6TestShapeInputService6TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService6TestShapeInputShape struct {
+	BlobArg []byte `type:"blob"`
+
+	metadataInputService6TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService6TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// InputService7ProtocolTest is a client for InputService7ProtocolTest.
+type InputService7ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService7ProtocolTest client.
+func NewInputService7ProtocolTest(config *aws.Config) *InputService7ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	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(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &InputService7ProtocolTest{service}
+}
+
+// InputService7TestCaseOperation1Request generates a request for the InputService7TestCaseOperation1 operation.
+func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input *InputService7TestShapeInputShape) (req *aws.Request, output *InputService7TestShapeInputService7TestCaseOperation1Output) {
+	if opInputService7TestCaseOperation1 == nil {
+		opInputService7TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService7TestCaseOperation1, input, output)
+	output = &InputService7TestShapeInputService7TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService7ProtocolTest) InputService7TestCaseOperation1(input *InputService7TestShapeInputShape) (output *InputService7TestShapeInputService7TestCaseOperation1Output, err error) {
+	req, out := c.InputService7TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService7TestCaseOperation1 *aws.Operation
+
+type InputService7TestShapeInputService7TestCaseOperation1Output struct {
+	metadataInputService7TestShapeInputService7TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService7TestShapeInputService7TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService7TestShapeInputShape struct {
+	TimeArg *time.Time `type:"timestamp" timestampFormat:"iso8601"`
+
+	metadataInputService7TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService7TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// InputService8ProtocolTest is a client for InputService8ProtocolTest.
+type InputService8ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService8ProtocolTest client.
+func NewInputService8ProtocolTest(config *aws.Config) *InputService8ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	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(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &InputService8ProtocolTest{service}
+}
+
+// InputService8TestCaseOperation1Request generates a request for the InputService8TestCaseOperation1 operation.
+func (c *InputService8ProtocolTest) InputService8TestCaseOperation1Request(input *InputService8TestShapeInputShape) (req *aws.Request, output *InputService8TestShapeInputService8TestCaseOperation1Output) {
+	if opInputService8TestCaseOperation1 == nil {
+		opInputService8TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService8TestCaseOperation1, input, output)
+	output = &InputService8TestShapeInputService8TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService8ProtocolTest) InputService8TestCaseOperation1(input *InputService8TestShapeInputShape) (output *InputService8TestShapeInputService8TestCaseOperation1Output, err error) {
+	req, out := c.InputService8TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService8TestCaseOperation1 *aws.Operation
+
+// InputService8TestCaseOperation2Request generates a request for the InputService8TestCaseOperation2 operation.
+func (c *InputService8ProtocolTest) InputService8TestCaseOperation2Request(input *InputService8TestShapeInputShape) (req *aws.Request, output *InputService8TestShapeInputService8TestCaseOperation2Output) {
+	if opInputService8TestCaseOperation2 == nil {
+		opInputService8TestCaseOperation2 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService8TestCaseOperation2, input, output)
+	output = &InputService8TestShapeInputService8TestCaseOperation2Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService8ProtocolTest) InputService8TestCaseOperation2(input *InputService8TestShapeInputShape) (output *InputService8TestShapeInputService8TestCaseOperation2Output, err error) {
+	req, out := c.InputService8TestCaseOperation2Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService8TestCaseOperation2 *aws.Operation
+
+// InputService8TestCaseOperation3Request generates a request for the InputService8TestCaseOperation3 operation.
+func (c *InputService8ProtocolTest) InputService8TestCaseOperation3Request(input *InputService8TestShapeInputShape) (req *aws.Request, output *InputService8TestShapeInputService8TestShapeInputService8TestCaseOperation3Output) {
+	if opInputService8TestCaseOperation3 == nil {
+		opInputService8TestCaseOperation3 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService8TestCaseOperation3, input, output)
+	output = &InputService8TestShapeInputService8TestShapeInputService8TestCaseOperation3Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService8ProtocolTest) InputService8TestCaseOperation3(input *InputService8TestShapeInputShape) (output *InputService8TestShapeInputService8TestShapeInputService8TestCaseOperation3Output, err error) {
+	req, out := c.InputService8TestCaseOperation3Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService8TestCaseOperation3 *aws.Operation
+
+// InputService8TestCaseOperation4Request generates a request for the InputService8TestCaseOperation4 operation.
+func (c *InputService8ProtocolTest) InputService8TestCaseOperation4Request(input *InputService8TestShapeInputShape) (req *aws.Request, output *InputService8TestShapeInputService8TestCaseOperation4Output) {
+	if opInputService8TestCaseOperation4 == nil {
+		opInputService8TestCaseOperation4 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService8TestCaseOperation4, input, output)
+	output = &InputService8TestShapeInputService8TestCaseOperation4Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService8ProtocolTest) InputService8TestCaseOperation4(input *InputService8TestShapeInputShape) (output *InputService8TestShapeInputService8TestCaseOperation4Output, err error) {
+	req, out := c.InputService8TestCaseOperation4Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService8TestCaseOperation4 *aws.Operation
+
+// InputService8TestCaseOperation5Request generates a request for the InputService8TestCaseOperation5 operation.
+func (c *InputService8ProtocolTest) InputService8TestCaseOperation5Request(input *InputService8TestShapeInputShape) (req *aws.Request, output *InputService8TestShapeInputService8TestShapeInputService8TestCaseOperation5Output) {
+	if opInputService8TestCaseOperation5 == nil {
+		opInputService8TestCaseOperation5 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService8TestCaseOperation5, input, output)
+	output = &InputService8TestShapeInputService8TestShapeInputService8TestCaseOperation5Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService8ProtocolTest) InputService8TestCaseOperation5(input *InputService8TestShapeInputShape) (output *InputService8TestShapeInputService8TestShapeInputService8TestCaseOperation5Output, err error) {
+	req, out := c.InputService8TestCaseOperation5Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService8TestCaseOperation5 *aws.Operation
+
+// InputService8TestCaseOperation6Request generates a request for the InputService8TestCaseOperation6 operation.
+func (c *InputService8ProtocolTest) InputService8TestCaseOperation6Request(input *InputService8TestShapeInputShape) (req *aws.Request, output *InputService8TestShapeInputService8TestCaseOperation6Output) {
+	if opInputService8TestCaseOperation6 == nil {
+		opInputService8TestCaseOperation6 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService8TestCaseOperation6, input, output)
+	output = &InputService8TestShapeInputService8TestCaseOperation6Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService8ProtocolTest) InputService8TestCaseOperation6(input *InputService8TestShapeInputShape) (output *InputService8TestShapeInputService8TestCaseOperation6Output, err error) {
+	req, out := c.InputService8TestCaseOperation6Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService8TestCaseOperation6 *aws.Operation
+
+type InputService8TestShapeInputService8TestCaseOperation1Output struct {
+	metadataInputService8TestShapeInputService8TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService8TestShapeInputService8TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService8TestShapeInputService8TestCaseOperation2Output struct {
+	metadataInputService8TestShapeInputService8TestCaseOperation2Output `json:"-", xml:"-"`
+}
+
+type metadataInputService8TestShapeInputService8TestCaseOperation2Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService8TestShapeInputService8TestCaseOperation4Output struct {
+	metadataInputService8TestShapeInputService8TestCaseOperation4Output `json:"-", xml:"-"`
+}
+
+type metadataInputService8TestShapeInputService8TestCaseOperation4Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService8TestShapeInputService8TestCaseOperation6Output struct {
+	metadataInputService8TestShapeInputService8TestCaseOperation6Output `json:"-", xml:"-"`
+}
+
+type metadataInputService8TestShapeInputService8TestCaseOperation6Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService8TestShapeInputService8TestShapeInputService8TestCaseOperation3Output struct {
+	metadataInputService8TestShapeInputService8TestShapeInputService8TestCaseOperation3Output `json:"-", xml:"-"`
+}
+
+type metadataInputService8TestShapeInputService8TestShapeInputService8TestCaseOperation3Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService8TestShapeInputService8TestShapeInputService8TestCaseOperation5Output struct {
+	metadataInputService8TestShapeInputService8TestShapeInputService8TestCaseOperation5Output `json:"-", xml:"-"`
+}
+
+type metadataInputService8TestShapeInputService8TestShapeInputService8TestCaseOperation5Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService8TestShapeInputService8TestShapeRecursiveStructType struct {
+	NoRecurse *string `type:"string"`
+
+	RecursiveList []*InputService8TestShapeInputService8TestShapeRecursiveStructType `type:"list"`
+
+	RecursiveMap *map[string]*InputService8TestShapeInputService8TestShapeRecursiveStructType `type:"map"`
+
+	RecursiveStruct *InputService8TestShapeInputService8TestShapeRecursiveStructType `type:"structure"`
+
+	metadataInputService8TestShapeInputService8TestShapeRecursiveStructType `json:"-", xml:"-"`
+}
+
+type metadataInputService8TestShapeInputService8TestShapeRecursiveStructType struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService8TestShapeInputShape struct {
+	RecursiveStruct *InputService8TestShapeInputService8TestShapeRecursiveStructType `type:"structure"`
+
+	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
+	query.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 TestInputService2ProtocolTestNestedStructureMembersCase1(t *testing.T) {
+	svc := NewInputService2ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService2TestShapeInputShape{
+		StructArg: &InputService2TestShapeStructType{
+			ScalarArg: aws.String("foo"),
+		},
+	}
+	req, _ := svc.InputService2TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	query.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&StructArg.ScalarArg=foo&Version=2014-01-01`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService3ProtocolTestListTypesCase1(t *testing.T) {
+	svc := NewInputService3ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService3TestShapeInputShape{
+		ListArg: []*string{
+			aws.String("foo"),
+			aws.String("bar"),
+			aws.String("baz"),
+		},
+	}
+	req, _ := svc.InputService3TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	query.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.member.1=foo&ListArg.member.2=bar&ListArg.member.3=baz&Version=2014-01-01`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService4ProtocolTestFlattenedListCase1(t *testing.T) {
+	svc := NewInputService4ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService4TestShapeInputShape{
+		ListArg: []*string{
+			aws.String("a"),
+			aws.String("b"),
+			aws.String("c"),
+		},
+		ScalarArg: aws.String("foo"),
+	}
+	req, _ := svc.InputService4TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	query.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=a&ListArg.2=b&ListArg.3=c&ScalarArg=foo&Version=2014-01-01`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService5ProtocolTestSerializeMapTypeCase1(t *testing.T) {
+	svc := NewInputService5ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService5TestShapeInputShape{
+		MapArg: &map[string]*string{
+			"key1": aws.String("val1"),
+			"key2": aws.String("val2"),
+		},
+	}
+	req, _ := svc.InputService5TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	query.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&MapArg.entry.1.key=key1&MapArg.entry.1.value=val1&MapArg.entry.2.key=key2&MapArg.entry.2.value=val2&Version=2014-01-01`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService6ProtocolTestBase64EncodedBlobsCase1(t *testing.T) {
+	svc := NewInputService6ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService6TestShapeInputShape{
+		BlobArg: []byte("foo"),
+	}
+	req, _ := svc.InputService6TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	query.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 TestInputService7ProtocolTestTimestampValuesCase1(t *testing.T) {
+	svc := NewInputService7ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService7TestShapeInputShape{
+		TimeArg: aws.Time(time.Unix(1422172800, 0)),
+	}
+	req, _ := svc.InputService7TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	query.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
+
+}
+
+func TestInputService8ProtocolTestRecursiveShapesCase1(t *testing.T) {
+	svc := NewInputService8ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService8TestShapeInputShape{
+		RecursiveStruct: &InputService8TestShapeInputService8TestShapeRecursiveStructType{
+			NoRecurse: aws.String("foo"),
+		},
+	}
+	req, _ := svc.InputService8TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	query.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&RecursiveStruct.NoRecurse=foo&Version=2014-01-01`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService8ProtocolTestRecursiveShapesCase2(t *testing.T) {
+	svc := NewInputService8ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService8TestShapeInputShape{
+		RecursiveStruct: &InputService8TestShapeInputService8TestShapeRecursiveStructType{
+			RecursiveStruct: &InputService8TestShapeInputService8TestShapeRecursiveStructType{
+				NoRecurse: aws.String("foo"),
+			},
+		},
+	}
+	req, _ := svc.InputService8TestCaseOperation2Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	query.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&RecursiveStruct.RecursiveStruct.NoRecurse=foo&Version=2014-01-01`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService8ProtocolTestRecursiveShapesCase3(t *testing.T) {
+	svc := NewInputService8ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService8TestShapeInputShape{
+		RecursiveStruct: &InputService8TestShapeInputService8TestShapeRecursiveStructType{
+			RecursiveStruct: &InputService8TestShapeInputService8TestShapeRecursiveStructType{
+				RecursiveStruct: &InputService8TestShapeInputService8TestShapeRecursiveStructType{
+					RecursiveStruct: &InputService8TestShapeInputService8TestShapeRecursiveStructType{
+						NoRecurse: aws.String("foo"),
+					},
+				},
+			},
+		},
+	}
+	req, _ := svc.InputService8TestCaseOperation3Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	query.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&RecursiveStruct.RecursiveStruct.RecursiveStruct.RecursiveStruct.NoRecurse=foo&Version=2014-01-01`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService8ProtocolTestRecursiveShapesCase4(t *testing.T) {
+	svc := NewInputService8ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService8TestShapeInputShape{
+		RecursiveStruct: &InputService8TestShapeInputService8TestShapeRecursiveStructType{
+			RecursiveList: []*InputService8TestShapeInputService8TestShapeRecursiveStructType{
+				&InputService8TestShapeInputService8TestShapeRecursiveStructType{
+					NoRecurse: aws.String("foo"),
+				},
+				&InputService8TestShapeInputService8TestShapeRecursiveStructType{
+					NoRecurse: aws.String("bar"),
+				},
+			},
+		},
+	}
+	req, _ := svc.InputService8TestCaseOperation4Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	query.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&RecursiveStruct.RecursiveList.member.1.NoRecurse=foo&RecursiveStruct.RecursiveList.member.2.NoRecurse=bar&Version=2014-01-01`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService8ProtocolTestRecursiveShapesCase5(t *testing.T) {
+	svc := NewInputService8ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService8TestShapeInputShape{
+		RecursiveStruct: &InputService8TestShapeInputService8TestShapeRecursiveStructType{
+			RecursiveList: []*InputService8TestShapeInputService8TestShapeRecursiveStructType{
+				&InputService8TestShapeInputService8TestShapeRecursiveStructType{
+					NoRecurse: aws.String("foo"),
+				},
+				&InputService8TestShapeInputService8TestShapeRecursiveStructType{
+					RecursiveStruct: &InputService8TestShapeInputService8TestShapeRecursiveStructType{
+						NoRecurse: aws.String("bar"),
+					},
+				},
+			},
+		},
+	}
+	req, _ := svc.InputService8TestCaseOperation5Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	query.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&RecursiveStruct.RecursiveList.member.1.NoRecurse=foo&RecursiveStruct.RecursiveList.member.2.RecursiveStruct.NoRecurse=bar&Version=2014-01-01`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService8ProtocolTestRecursiveShapesCase6(t *testing.T) {
+	svc := NewInputService8ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService8TestShapeInputShape{
+		RecursiveStruct: &InputService8TestShapeInputService8TestShapeRecursiveStructType{
+			RecursiveMap: &map[string]*InputService8TestShapeInputService8TestShapeRecursiveStructType{
+				"bar": &InputService8TestShapeInputService8TestShapeRecursiveStructType{
+					NoRecurse: aws.String("bar"),
+				},
+				"foo": &InputService8TestShapeInputService8TestShapeRecursiveStructType{
+					NoRecurse: aws.String("foo"),
+				},
+			},
+		},
+	}
+	req, _ := svc.InputService8TestCaseOperation6Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	query.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&RecursiveStruct.RecursiveMap.entry.1.key=bar&RecursiveStruct.RecursiveMap.entry.1.value.NoRecurse=bar&RecursiveStruct.RecursiveMap.entry.2.key=foo&RecursiveStruct.RecursiveMap.entry.2.value.NoRecurse=foo&Version=2014-01-01`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/queryutil/queryutil.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/queryutil/queryutil.go
new file mode 100644
index 000000000..fe8850902
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/queryutil/queryutil.go
@@ -0,0 +1,198 @@
+package queryutil
+
+import (
+	"encoding/base64"
+	"fmt"
+	"net/url"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+func Parse(body url.Values, i interface{}, isEC2 bool) error {
+	q := queryParser{isEC2: isEC2}
+	return q.parseValue(body, reflect.ValueOf(i), "", "")
+}
+
+func elemOf(value reflect.Value) reflect.Value {
+	for value.Kind() == reflect.Ptr {
+		value = value.Elem()
+	}
+	return value
+}
+
+type queryParser struct {
+	isEC2 bool
+}
+
+func (q *queryParser) parseValue(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error {
+	value = elemOf(value)
+
+	// no need to handle zero values
+	if !value.IsValid() {
+		return nil
+	}
+
+	t := tag.Get("type")
+	if t == "" {
+		switch value.Kind() {
+		case reflect.Struct:
+			t = "structure"
+		case reflect.Slice:
+			t = "list"
+		case reflect.Map:
+			t = "map"
+		}
+	}
+
+	switch t {
+	case "structure":
+		return q.parseStruct(v, value, prefix)
+	case "list":
+		return q.parseList(v, value, prefix, tag)
+	case "map":
+		return q.parseMap(v, value, prefix, tag)
+	default:
+		return q.parseScalar(v, value, prefix, tag)
+	}
+}
+
+func (q *queryParser) parseStruct(v url.Values, value reflect.Value, prefix string) error {
+	if !value.IsValid() {
+		return nil
+	}
+
+	t := value.Type()
+	for i := 0; i < value.NumField(); i++ {
+		if c := t.Field(i).Name[0:1]; strings.ToLower(c) == c {
+			continue // ignore unexported fields
+		}
+
+		value := elemOf(value.Field(i))
+		field := t.Field(i)
+		var name string
+
+		if q.isEC2 {
+			name = field.Tag.Get("queryName")
+		}
+		if name == "" {
+			if field.Tag.Get("flattened") != "" && field.Tag.Get("locationNameList") != "" {
+				name = field.Tag.Get("locationNameList")
+			} else if locName := field.Tag.Get("locationName"); locName != "" {
+				name = locName
+			}
+			if name != "" && q.isEC2 {
+				name = strings.ToUpper(name[0:1]) + name[1:]
+			}
+		}
+		if name == "" {
+			name = field.Name
+		}
+
+		if prefix != "" {
+			name = prefix + "." + name
+		}
+
+		if err := q.parseValue(v, value, name, field.Tag); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (q *queryParser) parseList(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error {
+	// check for unflattened list member
+	if !q.isEC2 && tag.Get("flattened") == "" {
+		prefix += ".member"
+	}
+
+	for i := 0; i < value.Len(); i++ {
+		slicePrefix := prefix
+		if slicePrefix == "" {
+			slicePrefix = strconv.Itoa(i + 1)
+		} else {
+			slicePrefix = slicePrefix + "." + strconv.Itoa(i+1)
+		}
+		if err := q.parseValue(v, value.Index(i), slicePrefix, ""); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (q *queryParser) parseMap(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error {
+	// check for unflattened list member
+	if !q.isEC2 && tag.Get("flattened") == "" {
+		prefix += ".entry"
+	}
+
+	// sort keys for improved serialization consistency.
+	// this is not strictly necessary for protocol support.
+	mapKeyValues := value.MapKeys()
+	mapKeys := map[string]reflect.Value{}
+	mapKeyNames := make([]string, len(mapKeyValues))
+	for i, mapKey := range mapKeyValues {
+		name := mapKey.String()
+		mapKeys[name] = mapKey
+		mapKeyNames[i] = name
+	}
+	sort.Strings(mapKeyNames)
+
+	for i, mapKeyName := range mapKeyNames {
+		mapKey := mapKeys[mapKeyName]
+		mapValue := value.MapIndex(mapKey)
+
+		// serialize key
+		var keyName string
+		if prefix == "" {
+			keyName = strconv.Itoa(i+1) + ".key"
+		} else {
+			keyName = prefix + "." + strconv.Itoa(i+1) + ".key"
+		}
+
+		if err := q.parseValue(v, mapKey, keyName, ""); err != nil {
+			return err
+		}
+
+		// serialize value
+		var valueName string
+		if prefix == "" {
+			valueName = strconv.Itoa(i+1) + ".value"
+		} else {
+			valueName = prefix + "." + strconv.Itoa(i+1) + ".value"
+		}
+
+		if err := q.parseValue(v, mapValue, valueName, ""); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (q *queryParser) parseScalar(v url.Values, r reflect.Value, name string, tag reflect.StructTag) error {
+	switch value := r.Interface().(type) {
+	case string:
+		v.Set(name, value)
+	case []byte:
+		v.Set(name, base64.StdEncoding.EncodeToString(value))
+	case bool:
+		v.Set(name, strconv.FormatBool(value))
+	case int64:
+		v.Set(name, strconv.FormatInt(value, 10))
+	case int:
+		v.Set(name, strconv.Itoa(value))
+	case float64:
+		v.Set(name, strconv.FormatFloat(value, 'f', -1, 64))
+	case float32:
+		v.Set(name, strconv.FormatFloat(float64(value), 'f', -1, 32))
+	case time.Time:
+		const ISO8601UTC = "2006-01-02T15:04:05Z"
+		v.Set(name, value.UTC().Format(ISO8601UTC))
+	default:
+		return fmt.Errorf("unsupported value for param %s: %v (%s)", name, r.Interface(), r.Type().Name())
+	}
+	return nil
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal.go
new file mode 100644
index 000000000..92a740dc4
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal.go
@@ -0,0 +1,26 @@
+package query
+
+//go:generate go run ../../fixtures/protocol/generate.go ../../fixtures/protocol/output/query.json unmarshal_test.go
+
+import (
+	"encoding/xml"
+
+	"github.com/awslabs/aws-sdk-go/aws"
+	"github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil"
+)
+
+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, r.Operation.Name+"Result")
+		if err != nil {
+			r.Error = err
+			return
+		}
+	}
+}
+
+func UnmarshalMeta(r *aws.Request) {
+	// TODO implement unmarshaling of request IDs
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal_error.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal_error.go
new file mode 100644
index 000000000..cf82eef93
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal_error.go
@@ -0,0 +1,31 @@
+package query
+
+import (
+	"encoding/xml"
+	"io"
+
+	"github.com/awslabs/aws-sdk-go/aws"
+)
+
+type xmlErrorResponse struct {
+	XMLName   xml.Name `xml:"ErrorResponse"`
+	Code      string   `xml:"Error>Code"`
+	Message   string   `xml:"Error>Message"`
+	RequestID string   `xml:"RequestId"`
+}
+
+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 = err
+	} else {
+		r.Error = aws.APIError{
+			StatusCode: r.HTTPResponse.StatusCode,
+			Code:       resp.Code,
+			Message:    resp.Message,
+		}
+	}
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal_test.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal_test.go
new file mode 100644
index 000000000..8d67b2dac
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal_test.go
@@ -0,0 +1,1361 @@
+package query_test
+
+import (
+	"github.com/awslabs/aws-sdk-go/aws"
+	"github.com/awslabs/aws-sdk-go/internal/protocol/query"
+	"github.com/awslabs/aws-sdk-go/internal/signer/v4"
+
+	"bytes"
+	"encoding/json"
+	"encoding/xml"
+	"github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil"
+	"github.com/awslabs/aws-sdk-go/internal/util"
+	"github.com/stretchr/testify/assert"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"testing"
+	"time"
+)
+
+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{}
+
+// OutputService1ProtocolTest is a client for OutputService1ProtocolTest.
+type OutputService1ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService1ProtocolTest client.
+func NewOutputService1ProtocolTest(config *aws.Config) *OutputService1ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice1protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &OutputService1ProtocolTest{service}
+}
+
+// OutputService1TestCaseOperation1Request generates a request for the OutputService1TestCaseOperation1 operation.
+func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1Request(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (req *aws.Request, output *OutputService1TestShapeOutputService1TestShapeOutputShape) {
+	if opOutputService1TestCaseOperation1 == nil {
+		opOutputService1TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService1TestCaseOperation1, input, output)
+	output = &OutputService1TestShapeOutputService1TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (output *OutputService1TestShapeOutputService1TestShapeOutputShape, err error) {
+	req, out := c.OutputService1TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService1TestCaseOperation1 *aws.Operation
+
+type OutputService1TestShapeOutputService1TestCaseOperation1Input struct {
+	metadataOutputService1TestShapeOutputService1TestCaseOperation1Input `json:"-", xml:"-"`
+}
+
+type metadataOutputService1TestShapeOutputService1TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService1TestShapeOutputService1TestShapeOutputShape 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"`
+
+	Timestamp *time.Time `type:"timestamp" timestampFormat:"iso8601"`
+
+	TrueBool *bool `type:"boolean"`
+
+	metadataOutputService1TestShapeOutputService1TestShapeOutputShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService1TestShapeOutputService1TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService2ProtocolTest is a client for OutputService2ProtocolTest.
+type OutputService2ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService2ProtocolTest client.
+func NewOutputService2ProtocolTest(config *aws.Config) *OutputService2ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice2protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &OutputService2ProtocolTest{service}
+}
+
+// OutputService2TestCaseOperation1Request generates a request for the OutputService2TestCaseOperation1 operation.
+func (c *OutputService2ProtocolTest) OutputService2TestCaseOperation1Request(input *OutputService2TestShapeOutputService2TestCaseOperation1Input) (req *aws.Request, output *OutputService2TestShapeOutputShape) {
+	if opOutputService2TestCaseOperation1 == nil {
+		opOutputService2TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService2TestCaseOperation1, input, output)
+	output = &OutputService2TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService2ProtocolTest) OutputService2TestCaseOperation1(input *OutputService2TestShapeOutputService2TestCaseOperation1Input) (output *OutputService2TestShapeOutputShape, err error) {
+	req, out := c.OutputService2TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService2TestCaseOperation1 *aws.Operation
+
+type OutputService2TestShapeOutputService2TestCaseOperation1Input struct {
+	metadataOutputService2TestShapeOutputService2TestCaseOperation1Input `json:"-", xml:"-"`
+}
+
+type metadataOutputService2TestShapeOutputService2TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService2TestShapeOutputShape struct {
+	Num *int64 `type:"integer"`
+
+	Str *string `type:"string"`
+
+	metadataOutputService2TestShapeOutputShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService2TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService3ProtocolTest is a client for OutputService3ProtocolTest.
+type OutputService3ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService3ProtocolTest client.
+func NewOutputService3ProtocolTest(config *aws.Config) *OutputService3ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice3protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &OutputService3ProtocolTest{service}
+}
+
+// OutputService3TestCaseOperation1Request generates a request for the OutputService3TestCaseOperation1 operation.
+func (c *OutputService3ProtocolTest) OutputService3TestCaseOperation1Request(input *OutputService3TestShapeOutputService3TestCaseOperation1Input) (req *aws.Request, output *OutputService3TestShapeOutputShape) {
+	if opOutputService3TestCaseOperation1 == nil {
+		opOutputService3TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService3TestCaseOperation1, input, output)
+	output = &OutputService3TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService3ProtocolTest) OutputService3TestCaseOperation1(input *OutputService3TestShapeOutputService3TestCaseOperation1Input) (output *OutputService3TestShapeOutputShape, err error) {
+	req, out := c.OutputService3TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService3TestCaseOperation1 *aws.Operation
+
+type OutputService3TestShapeOutputService3TestCaseOperation1Input struct {
+	metadataOutputService3TestShapeOutputService3TestCaseOperation1Input `json:"-", xml:"-"`
+}
+
+type metadataOutputService3TestShapeOutputService3TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService3TestShapeOutputShape struct {
+	Blob []byte `type:"blob"`
+
+	metadataOutputService3TestShapeOutputShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService3TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService4ProtocolTest is a client for OutputService4ProtocolTest.
+type OutputService4ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService4ProtocolTest client.
+func NewOutputService4ProtocolTest(config *aws.Config) *OutputService4ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice4protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &OutputService4ProtocolTest{service}
+}
+
+// OutputService4TestCaseOperation1Request generates a request for the OutputService4TestCaseOperation1 operation.
+func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1Request(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (req *aws.Request, output *OutputService4TestShapeOutputShape) {
+	if opOutputService4TestCaseOperation1 == nil {
+		opOutputService4TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService4TestCaseOperation1, input, output)
+	output = &OutputService4TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (output *OutputService4TestShapeOutputShape, err error) {
+	req, out := c.OutputService4TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService4TestCaseOperation1 *aws.Operation
+
+type OutputService4TestShapeOutputService4TestCaseOperation1Input struct {
+	metadataOutputService4TestShapeOutputService4TestCaseOperation1Input `json:"-", xml:"-"`
+}
+
+type metadataOutputService4TestShapeOutputService4TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService4TestShapeOutputShape struct {
+	ListMember []*string `type:"list"`
+
+	metadataOutputService4TestShapeOutputShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService4TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService5ProtocolTest is a client for OutputService5ProtocolTest.
+type OutputService5ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService5ProtocolTest client.
+func NewOutputService5ProtocolTest(config *aws.Config) *OutputService5ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice5protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &OutputService5ProtocolTest{service}
+}
+
+// OutputService5TestCaseOperation1Request generates a request for the OutputService5TestCaseOperation1 operation.
+func (c *OutputService5ProtocolTest) OutputService5TestCaseOperation1Request(input *OutputService5TestShapeOutputService5TestCaseOperation1Input) (req *aws.Request, output *OutputService5TestShapeOutputShape) {
+	if opOutputService5TestCaseOperation1 == nil {
+		opOutputService5TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService5TestCaseOperation1, input, output)
+	output = &OutputService5TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService5ProtocolTest) OutputService5TestCaseOperation1(input *OutputService5TestShapeOutputService5TestCaseOperation1Input) (output *OutputService5TestShapeOutputShape, err error) {
+	req, out := c.OutputService5TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService5TestCaseOperation1 *aws.Operation
+
+type OutputService5TestShapeOutputService5TestCaseOperation1Input struct {
+	metadataOutputService5TestShapeOutputService5TestCaseOperation1Input `json:"-", xml:"-"`
+}
+
+type metadataOutputService5TestShapeOutputService5TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService5TestShapeOutputShape struct {
+	ListMember []*string `locationNameList:"item" type:"list"`
+
+	metadataOutputService5TestShapeOutputShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService5TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService6ProtocolTest is a client for OutputService6ProtocolTest.
+type OutputService6ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService6ProtocolTest client.
+func NewOutputService6ProtocolTest(config *aws.Config) *OutputService6ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice6protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &OutputService6ProtocolTest{service}
+}
+
+// OutputService6TestCaseOperation1Request generates a request for the OutputService6TestCaseOperation1 operation.
+func (c *OutputService6ProtocolTest) OutputService6TestCaseOperation1Request(input *OutputService6TestShapeOutputService6TestCaseOperation1Input) (req *aws.Request, output *OutputService6TestShapeOutputShape) {
+	if opOutputService6TestCaseOperation1 == nil {
+		opOutputService6TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService6TestCaseOperation1, input, output)
+	output = &OutputService6TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService6ProtocolTest) OutputService6TestCaseOperation1(input *OutputService6TestShapeOutputService6TestCaseOperation1Input) (output *OutputService6TestShapeOutputShape, err error) {
+	req, out := c.OutputService6TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService6TestCaseOperation1 *aws.Operation
+
+type OutputService6TestShapeOutputService6TestCaseOperation1Input struct {
+	metadataOutputService6TestShapeOutputService6TestCaseOperation1Input `json:"-", xml:"-"`
+}
+
+type metadataOutputService6TestShapeOutputService6TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService6TestShapeOutputShape struct {
+	ListMember []*string `type:"list" flattened:"true"`
+
+	metadataOutputService6TestShapeOutputShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService6TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService7ProtocolTest is a client for OutputService7ProtocolTest.
+type OutputService7ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService7ProtocolTest client.
+func NewOutputService7ProtocolTest(config *aws.Config) *OutputService7ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice7protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &OutputService7ProtocolTest{service}
+}
+
+// OutputService7TestCaseOperation1Request generates a request for the OutputService7TestCaseOperation1 operation.
+func (c *OutputService7ProtocolTest) OutputService7TestCaseOperation1Request(input *OutputService7TestShapeOutputService7TestCaseOperation1Input) (req *aws.Request, output *OutputService7TestShapeOutputShape) {
+	if opOutputService7TestCaseOperation1 == nil {
+		opOutputService7TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService7TestCaseOperation1, input, output)
+	output = &OutputService7TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService7ProtocolTest) OutputService7TestCaseOperation1(input *OutputService7TestShapeOutputService7TestCaseOperation1Input) (output *OutputService7TestShapeOutputShape, err error) {
+	req, out := c.OutputService7TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService7TestCaseOperation1 *aws.Operation
+
+type OutputService7TestShapeOutputService7TestCaseOperation1Input struct {
+	metadataOutputService7TestShapeOutputService7TestCaseOperation1Input `json:"-", xml:"-"`
+}
+
+type metadataOutputService7TestShapeOutputService7TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService7TestShapeOutputShape struct {
+	ListMember []*string `type:"list" flattened:"true"`
+
+	metadataOutputService7TestShapeOutputShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService7TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService8ProtocolTest is a client for OutputService8ProtocolTest.
+type OutputService8ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService8ProtocolTest client.
+func NewOutputService8ProtocolTest(config *aws.Config) *OutputService8ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice8protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &OutputService8ProtocolTest{service}
+}
+
+// OutputService8TestCaseOperation1Request generates a request for the OutputService8TestCaseOperation1 operation.
+func (c *OutputService8ProtocolTest) OutputService8TestCaseOperation1Request(input *OutputService8TestShapeOutputService8TestCaseOperation1Input) (req *aws.Request, output *OutputService8TestShapeOutputShape) {
+	if opOutputService8TestCaseOperation1 == nil {
+		opOutputService8TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService8TestCaseOperation1, input, output)
+	output = &OutputService8TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService8ProtocolTest) OutputService8TestCaseOperation1(input *OutputService8TestShapeOutputService8TestCaseOperation1Input) (output *OutputService8TestShapeOutputShape, err error) {
+	req, out := c.OutputService8TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService8TestCaseOperation1 *aws.Operation
+
+type OutputService8TestShapeOutputService8TestCaseOperation1Input struct {
+	metadataOutputService8TestShapeOutputService8TestCaseOperation1Input `json:"-", xml:"-"`
+}
+
+type metadataOutputService8TestShapeOutputService8TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService8TestShapeOutputShape struct {
+	List []*OutputService8TestShapeStructureShape `type:"list"`
+
+	metadataOutputService8TestShapeOutputShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService8TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService8TestShapeStructureShape struct {
+	Bar *string `type:"string"`
+
+	Baz *string `type:"string"`
+
+	Foo *string `type:"string"`
+
+	metadataOutputService8TestShapeStructureShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService8TestShapeStructureShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService9ProtocolTest is a client for OutputService9ProtocolTest.
+type OutputService9ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService9ProtocolTest client.
+func NewOutputService9ProtocolTest(config *aws.Config) *OutputService9ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice9protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &OutputService9ProtocolTest{service}
+}
+
+// OutputService9TestCaseOperation1Request generates a request for the OutputService9TestCaseOperation1 operation.
+func (c *OutputService9ProtocolTest) OutputService9TestCaseOperation1Request(input *OutputService9TestShapeOutputService9TestCaseOperation1Input) (req *aws.Request, output *OutputService9TestShapeOutputShape) {
+	if opOutputService9TestCaseOperation1 == nil {
+		opOutputService9TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService9TestCaseOperation1, input, output)
+	output = &OutputService9TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService9ProtocolTest) OutputService9TestCaseOperation1(input *OutputService9TestShapeOutputService9TestCaseOperation1Input) (output *OutputService9TestShapeOutputShape, err error) {
+	req, out := c.OutputService9TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService9TestCaseOperation1 *aws.Operation
+
+type OutputService9TestShapeOutputService9TestCaseOperation1Input struct {
+	metadataOutputService9TestShapeOutputService9TestCaseOperation1Input `json:"-", xml:"-"`
+}
+
+type metadataOutputService9TestShapeOutputService9TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService9TestShapeOutputShape struct {
+	List []*OutputService9TestShapeStructureShape `type:"list" flattened:"true"`
+
+	metadataOutputService9TestShapeOutputShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService9TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService9TestShapeStructureShape struct {
+	Bar *string `type:"string"`
+
+	Baz *string `type:"string"`
+
+	Foo *string `type:"string"`
+
+	metadataOutputService9TestShapeStructureShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService9TestShapeStructureShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService10ProtocolTest is a client for OutputService10ProtocolTest.
+type OutputService10ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService10ProtocolTest client.
+func NewOutputService10ProtocolTest(config *aws.Config) *OutputService10ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice10protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &OutputService10ProtocolTest{service}
+}
+
+// OutputService10TestCaseOperation1Request generates a request for the OutputService10TestCaseOperation1 operation.
+func (c *OutputService10ProtocolTest) OutputService10TestCaseOperation1Request(input *OutputService10TestShapeOutputService10TestCaseOperation1Input) (req *aws.Request, output *OutputService10TestShapeOutputShape) {
+	if opOutputService10TestCaseOperation1 == nil {
+		opOutputService10TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService10TestCaseOperation1, input, output)
+	output = &OutputService10TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService10ProtocolTest) OutputService10TestCaseOperation1(input *OutputService10TestShapeOutputService10TestCaseOperation1Input) (output *OutputService10TestShapeOutputShape, err error) {
+	req, out := c.OutputService10TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService10TestCaseOperation1 *aws.Operation
+
+type OutputService10TestShapeOutputService10TestCaseOperation1Input struct {
+	metadataOutputService10TestShapeOutputService10TestCaseOperation1Input `json:"-", xml:"-"`
+}
+
+type metadataOutputService10TestShapeOutputService10TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService10TestShapeOutputShape struct {
+	List []*string `locationNameList:"NamedList" type:"list" flattened:"true"`
+
+	metadataOutputService10TestShapeOutputShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService10TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService11ProtocolTest is a client for OutputService11ProtocolTest.
+type OutputService11ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService11ProtocolTest client.
+func NewOutputService11ProtocolTest(config *aws.Config) *OutputService11ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice11protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &OutputService11ProtocolTest{service}
+}
+
+// OutputService11TestCaseOperation1Request generates a request for the OutputService11TestCaseOperation1 operation.
+func (c *OutputService11ProtocolTest) OutputService11TestCaseOperation1Request(input *OutputService11TestShapeOutputService11TestCaseOperation1Input) (req *aws.Request, output *OutputService11TestShapeOutputShape) {
+	if opOutputService11TestCaseOperation1 == nil {
+		opOutputService11TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService11TestCaseOperation1, input, output)
+	output = &OutputService11TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService11ProtocolTest) OutputService11TestCaseOperation1(input *OutputService11TestShapeOutputService11TestCaseOperation1Input) (output *OutputService11TestShapeOutputShape, err error) {
+	req, out := c.OutputService11TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService11TestCaseOperation1 *aws.Operation
+
+type OutputService11TestShapeOutputService11TestCaseOperation1Input struct {
+	metadataOutputService11TestShapeOutputService11TestCaseOperation1Input `json:"-", xml:"-"`
+}
+
+type metadataOutputService11TestShapeOutputService11TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService11TestShapeOutputShape struct {
+	Map *map[string]*OutputService11TestShapeStructType `type:"map"`
+
+	metadataOutputService11TestShapeOutputShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService11TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService11TestShapeStructType struct {
+	Foo *string `locationName:"foo" type:"string"`
+
+	metadataOutputService11TestShapeStructType `json:"-", xml:"-"`
+}
+
+type metadataOutputService11TestShapeStructType struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService12ProtocolTest is a client for OutputService12ProtocolTest.
+type OutputService12ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService12ProtocolTest client.
+func NewOutputService12ProtocolTest(config *aws.Config) *OutputService12ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice12protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &OutputService12ProtocolTest{service}
+}
+
+// OutputService12TestCaseOperation1Request generates a request for the OutputService12TestCaseOperation1 operation.
+func (c *OutputService12ProtocolTest) OutputService12TestCaseOperation1Request(input *OutputService12TestShapeOutputService12TestCaseOperation1Input) (req *aws.Request, output *OutputService12TestShapeOutputShape) {
+	if opOutputService12TestCaseOperation1 == nil {
+		opOutputService12TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService12TestCaseOperation1, input, output)
+	output = &OutputService12TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService12ProtocolTest) OutputService12TestCaseOperation1(input *OutputService12TestShapeOutputService12TestCaseOperation1Input) (output *OutputService12TestShapeOutputShape, err error) {
+	req, out := c.OutputService12TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService12TestCaseOperation1 *aws.Operation
+
+type OutputService12TestShapeOutputService12TestCaseOperation1Input struct {
+	metadataOutputService12TestShapeOutputService12TestCaseOperation1Input `json:"-", xml:"-"`
+}
+
+type metadataOutputService12TestShapeOutputService12TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService12TestShapeOutputShape struct {
+	Map *map[string]*string `type:"map" flattened:"true"`
+
+	metadataOutputService12TestShapeOutputShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService12TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService13ProtocolTest is a client for OutputService13ProtocolTest.
+type OutputService13ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService13ProtocolTest client.
+func NewOutputService13ProtocolTest(config *aws.Config) *OutputService13ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice13protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &OutputService13ProtocolTest{service}
+}
+
+// OutputService13TestCaseOperation1Request generates a request for the OutputService13TestCaseOperation1 operation.
+func (c *OutputService13ProtocolTest) OutputService13TestCaseOperation1Request(input *OutputService13TestShapeOutputService13TestCaseOperation1Input) (req *aws.Request, output *OutputService13TestShapeOutputShape) {
+	if opOutputService13TestCaseOperation1 == nil {
+		opOutputService13TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService13TestCaseOperation1, input, output)
+	output = &OutputService13TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService13ProtocolTest) OutputService13TestCaseOperation1(input *OutputService13TestShapeOutputService13TestCaseOperation1Input) (output *OutputService13TestShapeOutputShape, err error) {
+	req, out := c.OutputService13TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService13TestCaseOperation1 *aws.Operation
+
+type OutputService13TestShapeOutputService13TestCaseOperation1Input struct {
+	metadataOutputService13TestShapeOutputService13TestCaseOperation1Input `json:"-", xml:"-"`
+}
+
+type metadataOutputService13TestShapeOutputService13TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService13TestShapeOutputShape struct {
+	Map *map[string]*string `locationName:"Attribute" locationNameKey:"Name" locationNameValue:"Value" type:"map" flattened:"true"`
+
+	metadataOutputService13TestShapeOutputShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService13TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService14ProtocolTest is a client for OutputService14ProtocolTest.
+type OutputService14ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService14ProtocolTest client.
+func NewOutputService14ProtocolTest(config *aws.Config) *OutputService14ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice14protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(query.Build)
+	service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+	return &OutputService14ProtocolTest{service}
+}
+
+// OutputService14TestCaseOperation1Request generates a request for the OutputService14TestCaseOperation1 operation.
+func (c *OutputService14ProtocolTest) OutputService14TestCaseOperation1Request(input *OutputService14TestShapeOutputService14TestCaseOperation1Input) (req *aws.Request, output *OutputService14TestShapeOutputShape) {
+	if opOutputService14TestCaseOperation1 == nil {
+		opOutputService14TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService14TestCaseOperation1, input, output)
+	output = &OutputService14TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService14ProtocolTest) OutputService14TestCaseOperation1(input *OutputService14TestShapeOutputService14TestCaseOperation1Input) (output *OutputService14TestShapeOutputShape, err error) {
+	req, out := c.OutputService14TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService14TestCaseOperation1 *aws.Operation
+
+type OutputService14TestShapeOutputService14TestCaseOperation1Input struct {
+	metadataOutputService14TestShapeOutputService14TestCaseOperation1Input `json:"-", xml:"-"`
+}
+
+type metadataOutputService14TestShapeOutputService14TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService14TestShapeOutputShape struct {
+	Map *map[string]*string `locationNameKey:"foo" locationNameValue:"bar" type:"map" flattened:"true"`
+
+	metadataOutputService14TestShapeOutputShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService14TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+//
+// Tests begin here
+//
+
+func TestOutputService1ProtocolTestScalarMembersCase1(t *testing.T) {
+	svc := NewOutputService1ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse><OperationNameResult><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><Timestamp>2015-01-25T08:00:00Z</Timestamp></OperationNameResult><ResponseMetadata><RequestId>request-id</RequestId></ResponseMetadata></OperationNameResponse>"))
+	req, out := svc.OutputService1TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	query.UnmarshalMeta(req)
+	query.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, 200, *out.Long)
+	assert.Equal(t, 123, *out.Num)
+	assert.Equal(t, "myname", *out.Str)
+	assert.Equal(t, time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.String())
+	assert.Equal(t, true, *out.TrueBool)
+
+}
+
+func TestOutputService2ProtocolTestNotAllMembersInResponseCase1(t *testing.T) {
+	svc := NewOutputService2ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse><OperationNameResult><Str>myname</Str></OperationNameResult><ResponseMetadata><RequestId>request-id</RequestId></ResponseMetadata></OperationNameResponse>"))
+	req, out := svc.OutputService2TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	query.UnmarshalMeta(req)
+	query.Unmarshal(req)
+	assert.NoError(t, req.Error)
+
+	// assert response
+	assert.NotNil(t, out) // ensure out variable is used
+	assert.Equal(t, "myname", *out.Str)
+
+}
+
+func TestOutputService3ProtocolTestBlobCase1(t *testing.T) {
+	svc := NewOutputService3ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse><OperationNameResult><Blob>dmFsdWU=</Blob></OperationNameResult><ResponseMetadata><RequestId>requestid</RequestId></ResponseMetadata></OperationNameResponse>"))
+	req, out := svc.OutputService3TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	query.UnmarshalMeta(req)
+	query.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 TestOutputService4ProtocolTestListsCase1(t *testing.T) {
+	svc := NewOutputService4ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse><OperationNameResult><ListMember><member>abc</member><member>123</member></ListMember></OperationNameResult><ResponseMetadata><RequestId>requestid</RequestId></ResponseMetadata></OperationNameResponse>"))
+	req, out := svc.OutputService4TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	query.UnmarshalMeta(req)
+	query.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 TestOutputService5ProtocolTestListWithCustomMemberNameCase1(t *testing.T) {
+	svc := NewOutputService5ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse><OperationNameResult><ListMember><item>abc</item><item>123</item></ListMember></OperationNameResult><ResponseMetadata><RequestId>requestid</RequestId></ResponseMetadata></OperationNameResponse>"))
+	req, out := svc.OutputService5TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	query.UnmarshalMeta(req)
+	query.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 TestOutputService6ProtocolTestFlattenedListCase1(t *testing.T) {
+	svc := NewOutputService6ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse><OperationNameResult><ListMember>abc</ListMember><ListMember>123</ListMember></OperationNameResult><ResponseMetadata><RequestId>requestid</RequestId></ResponseMetadata></OperationNameResponse>"))
+	req, out := svc.OutputService6TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	query.UnmarshalMeta(req)
+	query.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 TestOutputService7ProtocolTestFlattenedSingleElementListCase1(t *testing.T) {
+	svc := NewOutputService7ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse><OperationNameResult><ListMember>abc</ListMember></OperationNameResult><ResponseMetadata><RequestId>requestid</RequestId></ResponseMetadata></OperationNameResponse>"))
+	req, out := svc.OutputService7TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	query.UnmarshalMeta(req)
+	query.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])
+
+}
+
+func TestOutputService8ProtocolTestListOfStructuresCase1(t *testing.T) {
+	svc := NewOutputService8ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse xmlns=\"https://service.amazonaws.com/doc/2010-05-08/\"><OperationNameResult><List><member><Foo>firstfoo</Foo><Bar>firstbar</Bar><Baz>firstbaz</Baz></member><member><Foo>secondfoo</Foo><Bar>secondbar</Bar><Baz>secondbaz</Baz></member></List></OperationNameResult><ResponseMetadata><RequestId>requestid</RequestId></ResponseMetadata></OperationNameResponse>"))
+	req, out := svc.OutputService8TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	query.UnmarshalMeta(req)
+	query.Unmarshal(req)
+	assert.NoError(t, req.Error)
+
+	// assert response
+	assert.NotNil(t, out) // ensure out variable is used
+	assert.Equal(t, "firstbar", *out.List[0].Bar)
+	assert.Equal(t, "firstbaz", *out.List[0].Baz)
+	assert.Equal(t, "firstfoo", *out.List[0].Foo)
+	assert.Equal(t, "secondbar", *out.List[1].Bar)
+	assert.Equal(t, "secondbaz", *out.List[1].Baz)
+	assert.Equal(t, "secondfoo", *out.List[1].Foo)
+
+}
+
+func TestOutputService9ProtocolTestFlattenedListOfStructuresCase1(t *testing.T) {
+	svc := NewOutputService9ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse xmlns=\"https://service.amazonaws.com/doc/2010-05-08/\"><OperationNameResult><List><Foo>firstfoo</Foo><Bar>firstbar</Bar><Baz>firstbaz</Baz></List><List><Foo>secondfoo</Foo><Bar>secondbar</Bar><Baz>secondbaz</Baz></List></OperationNameResult><ResponseMetadata><RequestId>requestid</RequestId></ResponseMetadata></OperationNameResponse>"))
+	req, out := svc.OutputService9TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	query.UnmarshalMeta(req)
+	query.Unmarshal(req)
+	assert.NoError(t, req.Error)
+
+	// assert response
+	assert.NotNil(t, out) // ensure out variable is used
+	assert.Equal(t, "firstbar", *out.List[0].Bar)
+	assert.Equal(t, "firstbaz", *out.List[0].Baz)
+	assert.Equal(t, "firstfoo", *out.List[0].Foo)
+	assert.Equal(t, "secondbar", *out.List[1].Bar)
+	assert.Equal(t, "secondbaz", *out.List[1].Baz)
+	assert.Equal(t, "secondfoo", *out.List[1].Foo)
+
+}
+
+func TestOutputService10ProtocolTestFlattenedListWithLocationNameCase1(t *testing.T) {
+	svc := NewOutputService10ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse xmlns=\"https://service.amazonaws.com/doc/2010-05-08/\"><OperationNameResult><NamedList>a</NamedList><NamedList>b</NamedList></OperationNameResult><ResponseMetadata><RequestId>requestid</RequestId></ResponseMetadata></OperationNameResponse>"))
+	req, out := svc.OutputService10TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	query.UnmarshalMeta(req)
+	query.Unmarshal(req)
+	assert.NoError(t, req.Error)
+
+	// assert response
+	assert.NotNil(t, out) // ensure out variable is used
+	assert.Equal(t, "a", *out.List[0])
+	assert.Equal(t, "b", *out.List[1])
+
+}
+
+func TestOutputService11ProtocolTestNormalMapCase1(t *testing.T) {
+	svc := NewOutputService11ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse xmlns=\"https://service.amazonaws.com/doc/2010-05-08\"><OperationNameResult><Map><entry><key>qux</key><value><foo>bar</foo></value></entry><entry><key>baz</key><value><foo>bam</foo></value></entry></Map></OperationNameResult><ResponseMetadata><RequestId>requestid</RequestId></ResponseMetadata></OperationNameResponse>"))
+	req, out := svc.OutputService11TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	query.UnmarshalMeta(req)
+	query.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 TestOutputService12ProtocolTestFlattenedMapCase1(t *testing.T) {
+	svc := NewOutputService12ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse><OperationNameResult><Map><key>qux</key><value>bar</value></Map><Map><key>baz</key><value>bam</value></Map></OperationNameResult><ResponseMetadata><RequestId>requestid</RequestId></ResponseMetadata></OperationNameResponse>"))
+	req, out := svc.OutputService12TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	query.UnmarshalMeta(req)
+	query.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 TestOutputService13ProtocolTestFlattenedMapInShapeDefinitionCase1(t *testing.T) {
+	svc := NewOutputService13ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse><OperationNameResult><Attribute><Name>qux</Name><Value>bar</Value></Attribute></OperationNameResult><ResponseMetadata><RequestId>requestid</RequestId></ResponseMetadata></OperationNameResponse>"))
+	req, out := svc.OutputService13TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	query.UnmarshalMeta(req)
+	query.Unmarshal(req)
+	assert.NoError(t, req.Error)
+
+	// assert response
+	assert.NotNil(t, out) // ensure out variable is used
+	assert.Equal(t, "bar", *(*out.Map)["qux"])
+
+}
+
+func TestOutputService14ProtocolTestNamedMapCase1(t *testing.T) {
+	svc := NewOutputService14ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse><OperationNameResult><Map><foo>qux</foo><bar>bar</bar></Map><Map><foo>baz</foo><bar>bam</bar></Map></OperationNameResult><ResponseMetadata><RequestId>requestid</RequestId></ResponseMetadata></OperationNameResponse>"))
+	req, out := svc.OutputService14TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	query.UnmarshalMeta(req)
+	query.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"])
+
+}
+
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/rest/build.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/rest/build.go
new file mode 100644
index 000000000..3ff667d94
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/rest/build.go
@@ -0,0 +1,215 @@
+package rest
+
+import (
+	"bytes"
+	"encoding/base64"
+	"fmt"
+	"io"
+	"net/url"
+	"path"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/awslabs/aws-sdk-go/aws"
+)
+
+// RFC822 returns an RFC822 formatted timestamp for AWS protocols
+const RFC822 = "Mon, 2 Jan 2006 15:04:05 GMT"
+
+func Build(r *aws.Request) {
+	if r.ParamsFilled() {
+		v := reflect.ValueOf(r.Params).Elem()
+		buildLocationElements(r, v)
+		buildBody(r, v)
+	}
+}
+
+func buildLocationElements(r *aws.Request, v reflect.Value) {
+	query := r.HTTPRequest.URL.Query()
+
+	for i := 0; i < v.NumField(); i++ {
+		m := v.Field(i)
+		if n := v.Type().Field(i).Name; n[0:1] == strings.ToLower(n[0:1]) {
+			continue
+		}
+
+		if m.IsValid() {
+			field := v.Type().Field(i)
+			name := field.Tag.Get("locationName")
+			if name == "" {
+				name = field.Name
+			}
+			if m.Kind() == reflect.Ptr {
+				m = m.Elem()
+			}
+			if !m.IsValid() {
+				continue
+			}
+
+			switch field.Tag.Get("location") {
+			case "headers": // header maps
+				buildHeaderMap(r, m, field.Tag.Get("locationName"))
+			case "header":
+				buildHeader(r, m, name)
+			case "uri":
+				buildURI(r, m, name)
+			case "querystring":
+				buildQueryString(r, m, name, query)
+			}
+		}
+		if r.Error != nil {
+			return
+		}
+	}
+
+	r.HTTPRequest.URL.RawQuery = query.Encode()
+	updatePath(r.HTTPRequest.URL, r.HTTPRequest.URL.Path)
+}
+
+func buildBody(r *aws.Request, v reflect.Value) {
+	if field, ok := v.Type().FieldByName("SDKShapeTraits"); ok {
+		if payloadName := field.Tag.Get("payload"); payloadName != "" {
+			pfield, _ := v.Type().FieldByName(payloadName)
+			if ptag := pfield.Tag.Get("type"); ptag != "" && ptag != "structure" {
+				payload := reflect.Indirect(v.FieldByName(payloadName))
+				if payload.IsValid() && payload.Interface() != nil {
+					switch reader := payload.Interface().(type) {
+					case io.ReadSeeker:
+						r.SetReaderBody(reader)
+					case []byte:
+						r.SetBufferBody(reader)
+					case string:
+						r.SetBufferBody([]byte(reader))
+					default:
+						r.Error = fmt.Errorf("unknown payload type %s", payload.Type())
+					}
+				}
+			}
+		}
+	}
+}
+
+func buildHeader(r *aws.Request, v reflect.Value, name string) {
+	str, err := convertType(v)
+	if err != nil {
+		r.Error = err
+	} else if str != nil {
+		r.HTTPRequest.Header.Add(name, *str)
+	}
+}
+
+func buildHeaderMap(r *aws.Request, v reflect.Value, prefix string) {
+	for _, key := range v.MapKeys() {
+		str, err := convertType(v.MapIndex(key))
+
+		if err != nil {
+			r.Error = err
+		} else if str != nil {
+			r.HTTPRequest.Header.Add(prefix+key.String(), *str)
+		}
+	}
+}
+
+func buildURI(r *aws.Request, v reflect.Value, name string) {
+	value, err := convertType(v)
+	if err != nil {
+		r.Error = err
+	} else if value != nil {
+		uri := r.HTTPRequest.URL.Path
+		uri = strings.Replace(uri, "{"+name+"}", escapePath(*value, true), -1)
+		uri = strings.Replace(uri, "{"+name+"+}", escapePath(*value, false), -1)
+		r.HTTPRequest.URL.Path = uri
+	}
+}
+
+func buildQueryString(r *aws.Request, v reflect.Value, name string, query url.Values) {
+	str, err := convertType(v)
+	if err != nil {
+		r.Error = err
+	} else if str != nil {
+		query.Set(name, *str)
+	}
+}
+
+func updatePath(url *url.URL, urlPath string) {
+	scheme, query := url.Scheme, url.RawQuery
+
+	// clean up path
+	urlPath = path.Clean(urlPath)
+
+	// get formatted URL minus scheme so we can build this into Opaque
+	url.Scheme, url.Path, url.RawQuery = "", "", ""
+	s := url.String()
+	url.Scheme = scheme
+	url.RawQuery = query
+
+	// build opaque URI
+	url.Opaque = s + urlPath
+}
+
+// Whether the byte value can be sent without escaping in AWS URLs
+var noEscape [256]bool
+var noEscapeInitialized = false
+
+// initialise noEscape
+func initNoEscape() {
+	for i := range noEscape {
+		// Amazon expects every character except these escaped
+		noEscape[i] = (i >= 'A' && i <= 'Z') ||
+			(i >= 'a' && i <= 'z') ||
+			(i >= '0' && i <= '9') ||
+			i == '-' ||
+			i == '.' ||
+			i == '_' ||
+			i == '~'
+	}
+}
+
+// escapePath escapes part of a URL path in Amazon style
+func escapePath(path string, encodeSep bool) string {
+	if !noEscapeInitialized {
+		initNoEscape()
+		noEscapeInitialized = true
+	}
+
+	var buf bytes.Buffer
+	for i := 0; i < len(path); i++ {
+		c := path[i]
+		if noEscape[c] || (c == '/' && !encodeSep) {
+			buf.WriteByte(c)
+		} else {
+			buf.WriteByte('%')
+			buf.WriteString(strings.ToUpper(strconv.FormatUint(uint64(c), 16)))
+		}
+	}
+	return buf.String()
+}
+
+func convertType(v reflect.Value) (*string, error) {
+	v = reflect.Indirect(v)
+	if !v.IsValid() {
+		return nil, nil
+	}
+
+	var str string
+	switch value := v.Interface().(type) {
+	case string:
+		str = value
+	case []byte:
+		str = base64.StdEncoding.EncodeToString(value)
+	case bool:
+		str = strconv.FormatBool(value)
+	case int64:
+		str = strconv.FormatInt(value, 10)
+	case float64:
+		str = strconv.FormatFloat(value, 'f', -1, 64)
+	case time.Time:
+		str = value.UTC().Format(RFC822)
+	default:
+		err := fmt.Errorf("Unsupported value for param %v (%s)", v.Interface(), v.Type())
+		return nil, err
+	}
+	return &str, nil
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/rest/payload.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/rest/payload.go
new file mode 100644
index 000000000..1e15f66f7
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/rest/payload.go
@@ -0,0 +1,43 @@
+package rest
+
+import "reflect"
+
+func PayloadMember(i interface{}) interface{} {
+	if i == nil {
+		return nil
+	}
+
+	v := reflect.ValueOf(i).Elem()
+	if !v.IsValid() {
+		return nil
+	}
+	if field, ok := v.Type().FieldByName("SDKShapeTraits"); ok {
+		if payloadName := field.Tag.Get("payload"); payloadName != "" {
+			field, _ := v.Type().FieldByName(payloadName)
+			if field.Tag.Get("type") != "structure" {
+				return nil
+			}
+
+			payload := v.FieldByName(payloadName)
+			if payload.IsValid() || (payload.Kind() == reflect.Ptr && !payload.IsNil()) {
+				return payload.Interface()
+			}
+		}
+	}
+	return nil
+}
+
+func PayloadType(i interface{}) string {
+	v := reflect.Indirect(reflect.ValueOf(i))
+	if !v.IsValid() {
+		return ""
+	}
+	if field, ok := v.Type().FieldByName("SDKShapeTraits"); ok {
+		if payloadName := field.Tag.Get("payload"); payloadName != "" {
+			if member, ok := v.Type().FieldByName(payloadName); ok {
+				return member.Tag.Get("type")
+			}
+		}
+	}
+	return ""
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/rest/unmarshal.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/rest/unmarshal.go
new file mode 100644
index 000000000..d0e216c1e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/rest/unmarshal.go
@@ -0,0 +1,174 @@
+package rest
+
+import (
+	"encoding/base64"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/awslabs/aws-sdk-go/aws"
+)
+
+func Unmarshal(r *aws.Request) {
+	if r.DataFilled() {
+		v := reflect.Indirect(reflect.ValueOf(r.Data))
+		unmarshalBody(r, v)
+		unmarshalLocationElements(r, v)
+	}
+}
+
+func unmarshalBody(r *aws.Request, v reflect.Value) {
+	if field, ok := v.Type().FieldByName("SDKShapeTraits"); ok {
+		if payloadName := field.Tag.Get("payload"); payloadName != "" {
+			pfield, _ := v.Type().FieldByName(payloadName)
+			if ptag := pfield.Tag.Get("type"); ptag != "" && ptag != "structure" {
+				payload := reflect.Indirect(v.FieldByName(payloadName))
+				if payload.IsValid() {
+					switch payload.Interface().(type) {
+					case []byte:
+						b, err := ioutil.ReadAll(r.HTTPResponse.Body)
+						if err != nil {
+							r.Error = err
+						} else {
+							payload.Set(reflect.ValueOf(b))
+						}
+					case string:
+						b, err := ioutil.ReadAll(r.HTTPResponse.Body)
+						if err != nil {
+							r.Error = err
+						} else {
+							payload.Set(reflect.ValueOf(string(b)))
+						}
+					default:
+						switch payload.Type().String() {
+						case "io.ReadSeeker":
+							payload.Set(reflect.ValueOf(aws.ReadSeekCloser(r.HTTPResponse.Body)))
+						case "aws.ReadSeekCloser", "io.ReadCloser":
+							payload.Set(reflect.ValueOf(r.HTTPResponse.Body))
+						default:
+							r.Error = fmt.Errorf("unknown payload type %s", payload.Type())
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func unmarshalLocationElements(r *aws.Request, v reflect.Value) {
+	for i := 0; i < v.NumField(); i++ {
+		m, field := v.Field(i), v.Type().Field(i)
+		if n := field.Name; n[0:1] == strings.ToLower(n[0:1]) {
+			continue
+		}
+
+		if m.IsValid() {
+			name := field.Tag.Get("locationName")
+			if name == "" {
+				name = field.Name
+			}
+
+			switch field.Tag.Get("location") {
+			case "statusCode":
+				unmarshalStatusCode(m, r.HTTPResponse.StatusCode)
+			case "header":
+				err := unmarshalHeader(m, r.HTTPResponse.Header.Get(name))
+				if err != nil {
+					r.Error = err
+					break
+				}
+			case "headers":
+				prefix := field.Tag.Get("locationName")
+				err := unmarshalHeaderMap(m, r.HTTPResponse.Header, prefix)
+				if err != nil {
+					r.Error = err
+					break
+				}
+			}
+		}
+		if r.Error != nil {
+			return
+		}
+	}
+}
+
+func unmarshalStatusCode(v reflect.Value, statusCode int) {
+	if !v.IsValid() {
+		return
+	}
+
+	switch v.Interface().(type) {
+	case *int64:
+		s := int64(statusCode)
+		v.Set(reflect.ValueOf(&s))
+	}
+}
+
+func unmarshalHeaderMap(r reflect.Value, headers http.Header, prefix string) error {
+	switch r.Interface().(type) {
+	case *map[string]*string: // we only support string map value types
+		out := map[string]*string{}
+		for k, v := range headers {
+			k = http.CanonicalHeaderKey(k)
+			if strings.HasPrefix(strings.ToLower(k), strings.ToLower(prefix)) {
+				out[k[len(prefix):]] = &v[0]
+			}
+		}
+		r.Set(reflect.ValueOf(&out))
+	}
+	return nil
+}
+
+func unmarshalHeader(v reflect.Value, header string) error {
+	if !v.IsValid() || (header == "" && v.Elem().Kind() != reflect.String) {
+		return nil
+	}
+
+	switch v.Interface().(type) {
+	case *string:
+		v.Set(reflect.ValueOf(&header))
+	case []byte:
+		b, err := base64.StdEncoding.DecodeString(header)
+		if err != nil {
+			return err
+		} else {
+			v.Set(reflect.ValueOf(&b))
+		}
+	case *bool:
+		b, err := strconv.ParseBool(header)
+		if err != nil {
+			return err
+		} else {
+			v.Set(reflect.ValueOf(&b))
+		}
+	case *int64:
+		i, err := strconv.ParseInt(header, 10, 64)
+		if err != nil {
+			return err
+		} else {
+			v.Set(reflect.ValueOf(&i))
+		}
+	case *float64:
+		f, err := strconv.ParseFloat(header, 64)
+		if err != nil {
+			return err
+		} else {
+			v.Set(reflect.ValueOf(&f))
+		}
+	case *time.Time:
+		t, err := time.Parse(RFC822, header)
+		if err != nil {
+			return err
+		} else {
+			v.Set(reflect.ValueOf(&t))
+		}
+	default:
+		err := fmt.Errorf("Unsupported value for param %v (%s)", v.Interface(), v.Type())
+		return err
+	}
+	return nil
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/restxml/build_test.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/restxml/build_test.go
new file mode 100644
index 000000000..48d72ca53
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/restxml/build_test.go
@@ -0,0 +1,2571 @@
+package restxml_test
+
+import (
+	"github.com/awslabs/aws-sdk-go/aws"
+	"github.com/awslabs/aws-sdk-go/internal/protocol/restxml"
+	"github.com/awslabs/aws-sdk-go/internal/signer/v4"
+
+	"bytes"
+	"encoding/json"
+	"encoding/xml"
+	"github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil"
+	"github.com/awslabs/aws-sdk-go/internal/util"
+	"github.com/stretchr/testify/assert"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"testing"
+	"time"
+)
+
+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{}
+
+// InputService1ProtocolTest is a client for InputService1ProtocolTest.
+type InputService1ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService1ProtocolTest client.
+func NewInputService1ProtocolTest(config *aws.Config) *InputService1ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	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(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &InputService1ProtocolTest{service}
+}
+
+// InputService1TestCaseOperation1Request generates a request for the InputService1TestCaseOperation1 operation.
+func (c *InputService1ProtocolTest) InputService1TestCaseOperation1Request(input *InputService1TestShapeInputShape) (req *aws.Request, output *InputService1TestShapeInputService1TestCaseOperation1Output) {
+	if opInputService1TestCaseOperation1 == nil {
+		opInputService1TestCaseOperation1 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/2014-01-01/hostedzone",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService1TestCaseOperation1, input, output)
+	output = &InputService1TestShapeInputService1TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService1ProtocolTest) InputService1TestCaseOperation1(input *InputService1TestShapeInputShape) (output *InputService1TestShapeInputService1TestCaseOperation1Output, err error) {
+	req, out := c.InputService1TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService1TestCaseOperation1 *aws.Operation
+
+// InputService1TestCaseOperation2Request generates a request for the InputService1TestCaseOperation2 operation.
+func (c *InputService1ProtocolTest) InputService1TestCaseOperation2Request(input *InputService1TestShapeInputShape) (req *aws.Request, output *InputService1TestShapeInputService1TestCaseOperation2Output) {
+	if opInputService1TestCaseOperation2 == nil {
+		opInputService1TestCaseOperation2 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "PUT",
+			HTTPPath:   "/2014-01-01/hostedzone",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService1TestCaseOperation2, input, output)
+	output = &InputService1TestShapeInputService1TestCaseOperation2Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService1ProtocolTest) InputService1TestCaseOperation2(input *InputService1TestShapeInputShape) (output *InputService1TestShapeInputService1TestCaseOperation2Output, err error) {
+	req, out := c.InputService1TestCaseOperation2Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService1TestCaseOperation2 *aws.Operation
+
+type InputService1TestShapeInputService1TestCaseOperation1Output struct {
+	metadataInputService1TestShapeInputService1TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService1TestShapeInputService1TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService1TestShapeInputService1TestCaseOperation2Output struct {
+	metadataInputService1TestShapeInputService1TestCaseOperation2Output `json:"-", xml:"-"`
+}
+
+type metadataInputService1TestShapeInputService1TestCaseOperation2Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService1TestShapeInputShape struct {
+	Description *string `type:"string"`
+
+	Name *string `type:"string"`
+
+	metadataInputService1TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService1TestShapeInputShape struct {
+	SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"`
+}
+
+// InputService2ProtocolTest is a client for InputService2ProtocolTest.
+type InputService2ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService2ProtocolTest client.
+func NewInputService2ProtocolTest(config *aws.Config) *InputService2ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	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(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &InputService2ProtocolTest{service}
+}
+
+// InputService2TestCaseOperation1Request generates a request for the InputService2TestCaseOperation1 operation.
+func (c *InputService2ProtocolTest) InputService2TestCaseOperation1Request(input *InputService2TestShapeInputShape) (req *aws.Request, output *InputService2TestShapeInputService2TestCaseOperation1Output) {
+	if opInputService2TestCaseOperation1 == nil {
+		opInputService2TestCaseOperation1 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/2014-01-01/hostedzone",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService2TestCaseOperation1, input, output)
+	output = &InputService2TestShapeInputService2TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService2ProtocolTest) InputService2TestCaseOperation1(input *InputService2TestShapeInputShape) (output *InputService2TestShapeInputService2TestCaseOperation1Output, err error) {
+	req, out := c.InputService2TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService2TestCaseOperation1 *aws.Operation
+
+type InputService2TestShapeInputService2TestCaseOperation1Output struct {
+	metadataInputService2TestShapeInputService2TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService2TestShapeInputService2TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService2TestShapeInputShape struct {
+	First *bool `type:"boolean"`
+
+	Fourth *int64 `type:"integer"`
+
+	Second *bool `type:"boolean"`
+
+	Third *float64 `type:"float"`
+
+	metadataInputService2TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService2TestShapeInputShape struct {
+	SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"`
+}
+
+// InputService3ProtocolTest is a client for InputService3ProtocolTest.
+type InputService3ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService3ProtocolTest client.
+func NewInputService3ProtocolTest(config *aws.Config) *InputService3ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	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(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &InputService3ProtocolTest{service}
+}
+
+// InputService3TestCaseOperation1Request generates a request for the InputService3TestCaseOperation1 operation.
+func (c *InputService3ProtocolTest) InputService3TestCaseOperation1Request(input *InputService3TestShapeInputShape) (req *aws.Request, output *InputService3TestShapeInputService3TestCaseOperation1Output) {
+	if opInputService3TestCaseOperation1 == nil {
+		opInputService3TestCaseOperation1 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/2014-01-01/hostedzone",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService3TestCaseOperation1, input, output)
+	output = &InputService3TestShapeInputService3TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService3ProtocolTest) InputService3TestCaseOperation1(input *InputService3TestShapeInputShape) (output *InputService3TestShapeInputService3TestCaseOperation1Output, err error) {
+	req, out := c.InputService3TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService3TestCaseOperation1 *aws.Operation
+
+type InputService3TestShapeInputService3TestCaseOperation1Output struct {
+	metadataInputService3TestShapeInputService3TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService3TestShapeInputService3TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService3TestShapeInputShape struct {
+	Description *string `type:"string"`
+
+	SubStructure *InputService3TestShapeSubStructure `type:"structure"`
+
+	metadataInputService3TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService3TestShapeInputShape struct {
+	SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"`
+}
+
+type InputService3TestShapeSubStructure struct {
+	Bar *string `type:"string"`
+
+	Foo *string `type:"string"`
+
+	metadataInputService3TestShapeSubStructure `json:"-", xml:"-"`
+}
+
+type metadataInputService3TestShapeSubStructure struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// InputService4ProtocolTest is a client for InputService4ProtocolTest.
+type InputService4ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService4ProtocolTest client.
+func NewInputService4ProtocolTest(config *aws.Config) *InputService4ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	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(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &InputService4ProtocolTest{service}
+}
+
+// InputService4TestCaseOperation1Request generates a request for the InputService4TestCaseOperation1 operation.
+func (c *InputService4ProtocolTest) InputService4TestCaseOperation1Request(input *InputService4TestShapeInputShape) (req *aws.Request, output *InputService4TestShapeInputService4TestCaseOperation1Output) {
+	if opInputService4TestCaseOperation1 == nil {
+		opInputService4TestCaseOperation1 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/2014-01-01/hostedzone",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService4TestCaseOperation1, input, output)
+	output = &InputService4TestShapeInputService4TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService4ProtocolTest) InputService4TestCaseOperation1(input *InputService4TestShapeInputShape) (output *InputService4TestShapeInputService4TestCaseOperation1Output, err error) {
+	req, out := c.InputService4TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService4TestCaseOperation1 *aws.Operation
+
+type InputService4TestShapeInputService4TestCaseOperation1Output struct {
+	metadataInputService4TestShapeInputService4TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService4TestShapeInputService4TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService4TestShapeInputShape struct {
+	Description *string `type:"string"`
+
+	SubStructure *InputService4TestShapeSubStructure `type:"structure"`
+
+	metadataInputService4TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService4TestShapeInputShape struct {
+	SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"`
+}
+
+type InputService4TestShapeSubStructure struct {
+	Bar *string `type:"string"`
+
+	Foo *string `type:"string"`
+
+	metadataInputService4TestShapeSubStructure `json:"-", xml:"-"`
+}
+
+type metadataInputService4TestShapeSubStructure struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// InputService5ProtocolTest is a client for InputService5ProtocolTest.
+type InputService5ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService5ProtocolTest client.
+func NewInputService5ProtocolTest(config *aws.Config) *InputService5ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	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(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &InputService5ProtocolTest{service}
+}
+
+// InputService5TestCaseOperation1Request generates a request for the InputService5TestCaseOperation1 operation.
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation1Request(input *InputService5TestShapeInputShape) (req *aws.Request, output *InputService5TestShapeInputService5TestCaseOperation1Output) {
+	if opInputService5TestCaseOperation1 == nil {
+		opInputService5TestCaseOperation1 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/2014-01-01/hostedzone",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService5TestCaseOperation1, input, output)
+	output = &InputService5TestShapeInputService5TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation1(input *InputService5TestShapeInputShape) (output *InputService5TestShapeInputService5TestCaseOperation1Output, err error) {
+	req, out := c.InputService5TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService5TestCaseOperation1 *aws.Operation
+
+type InputService5TestShapeInputService5TestCaseOperation1Output struct {
+	metadataInputService5TestShapeInputService5TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService5TestShapeInputService5TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService5TestShapeInputShape struct {
+	ListParam []*string `type:"list"`
+
+	metadataInputService5TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService5TestShapeInputShape struct {
+	SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"`
+}
+
+// InputService6ProtocolTest is a client for InputService6ProtocolTest.
+type InputService6ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService6ProtocolTest client.
+func NewInputService6ProtocolTest(config *aws.Config) *InputService6ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	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(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &InputService6ProtocolTest{service}
+}
+
+// InputService6TestCaseOperation1Request generates a request for the InputService6TestCaseOperation1 operation.
+func (c *InputService6ProtocolTest) InputService6TestCaseOperation1Request(input *InputService6TestShapeInputShape) (req *aws.Request, output *InputService6TestShapeInputService6TestCaseOperation1Output) {
+	if opInputService6TestCaseOperation1 == nil {
+		opInputService6TestCaseOperation1 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/2014-01-01/hostedzone",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService6TestCaseOperation1, input, output)
+	output = &InputService6TestShapeInputService6TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService6ProtocolTest) InputService6TestCaseOperation1(input *InputService6TestShapeInputShape) (output *InputService6TestShapeInputService6TestCaseOperation1Output, err error) {
+	req, out := c.InputService6TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService6TestCaseOperation1 *aws.Operation
+
+type InputService6TestShapeInputService6TestCaseOperation1Output struct {
+	metadataInputService6TestShapeInputService6TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService6TestShapeInputService6TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService6TestShapeInputShape struct {
+	ListParam []*string `locationName:"AlternateName" locationNameList:"NotMember" type:"list"`
+
+	metadataInputService6TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService6TestShapeInputShape struct {
+	SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"`
+}
+
+// InputService7ProtocolTest is a client for InputService7ProtocolTest.
+type InputService7ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService7ProtocolTest client.
+func NewInputService7ProtocolTest(config *aws.Config) *InputService7ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	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(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &InputService7ProtocolTest{service}
+}
+
+// InputService7TestCaseOperation1Request generates a request for the InputService7TestCaseOperation1 operation.
+func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input *InputService7TestShapeInputShape) (req *aws.Request, output *InputService7TestShapeInputService7TestCaseOperation1Output) {
+	if opInputService7TestCaseOperation1 == nil {
+		opInputService7TestCaseOperation1 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/2014-01-01/hostedzone",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService7TestCaseOperation1, input, output)
+	output = &InputService7TestShapeInputService7TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService7ProtocolTest) InputService7TestCaseOperation1(input *InputService7TestShapeInputShape) (output *InputService7TestShapeInputService7TestCaseOperation1Output, err error) {
+	req, out := c.InputService7TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService7TestCaseOperation1 *aws.Operation
+
+type InputService7TestShapeInputService7TestCaseOperation1Output struct {
+	metadataInputService7TestShapeInputService7TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService7TestShapeInputService7TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService7TestShapeInputShape struct {
+	ListParam []*string `type:"list" flattened:"true"`
+
+	metadataInputService7TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService7TestShapeInputShape struct {
+	SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"`
+}
+
+// InputService8ProtocolTest is a client for InputService8ProtocolTest.
+type InputService8ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService8ProtocolTest client.
+func NewInputService8ProtocolTest(config *aws.Config) *InputService8ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	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(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &InputService8ProtocolTest{service}
+}
+
+// InputService8TestCaseOperation1Request generates a request for the InputService8TestCaseOperation1 operation.
+func (c *InputService8ProtocolTest) InputService8TestCaseOperation1Request(input *InputService8TestShapeInputShape) (req *aws.Request, output *InputService8TestShapeInputService8TestCaseOperation1Output) {
+	if opInputService8TestCaseOperation1 == nil {
+		opInputService8TestCaseOperation1 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/2014-01-01/hostedzone",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService8TestCaseOperation1, input, output)
+	output = &InputService8TestShapeInputService8TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService8ProtocolTest) InputService8TestCaseOperation1(input *InputService8TestShapeInputShape) (output *InputService8TestShapeInputService8TestCaseOperation1Output, err error) {
+	req, out := c.InputService8TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService8TestCaseOperation1 *aws.Operation
+
+type InputService8TestShapeInputService8TestCaseOperation1Output struct {
+	metadataInputService8TestShapeInputService8TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService8TestShapeInputService8TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService8TestShapeInputShape struct {
+	ListParam []*string `locationName:"item" type:"list" flattened:"true"`
+
+	metadataInputService8TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService8TestShapeInputShape struct {
+	SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"`
+}
+
+// InputService9ProtocolTest is a client for InputService9ProtocolTest.
+type InputService9ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService9ProtocolTest client.
+func NewInputService9ProtocolTest(config *aws.Config) *InputService9ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "inputservice9protocoltest",
+		APIVersion:  "2014-01-01",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &InputService9ProtocolTest{service}
+}
+
+// InputService9TestCaseOperation1Request generates a request for the InputService9TestCaseOperation1 operation.
+func (c *InputService9ProtocolTest) InputService9TestCaseOperation1Request(input *InputService9TestShapeInputShape) (req *aws.Request, output *InputService9TestShapeInputService9TestCaseOperation1Output) {
+	if opInputService9TestCaseOperation1 == nil {
+		opInputService9TestCaseOperation1 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/2014-01-01/hostedzone",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService9TestCaseOperation1, input, output)
+	output = &InputService9TestShapeInputService9TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService9ProtocolTest) InputService9TestCaseOperation1(input *InputService9TestShapeInputShape) (output *InputService9TestShapeInputService9TestCaseOperation1Output, err error) {
+	req, out := c.InputService9TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService9TestCaseOperation1 *aws.Operation
+
+type InputService9TestShapeInputService9TestCaseOperation1Output struct {
+	metadataInputService9TestShapeInputService9TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService9TestShapeInputService9TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService9TestShapeInputShape struct {
+	ListParam []*InputService9TestShapeSingleFieldStruct `locationName:"item" type:"list" flattened:"true"`
+
+	metadataInputService9TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService9TestShapeInputShape struct {
+	SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"`
+}
+
+type InputService9TestShapeSingleFieldStruct struct {
+	Element *string `locationName:"value" type:"string"`
+
+	metadataInputService9TestShapeSingleFieldStruct `json:"-", xml:"-"`
+}
+
+type metadataInputService9TestShapeSingleFieldStruct struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// InputService10ProtocolTest is a client for InputService10ProtocolTest.
+type InputService10ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService10ProtocolTest client.
+func NewInputService10ProtocolTest(config *aws.Config) *InputService10ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "inputservice10protocoltest",
+		APIVersion:  "2014-01-01",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &InputService10ProtocolTest{service}
+}
+
+// InputService10TestCaseOperation1Request generates a request for the InputService10TestCaseOperation1 operation.
+func (c *InputService10ProtocolTest) InputService10TestCaseOperation1Request(input *InputService10TestShapeInputShape) (req *aws.Request, output *InputService10TestShapeInputService10TestCaseOperation1Output) {
+	if opInputService10TestCaseOperation1 == nil {
+		opInputService10TestCaseOperation1 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/2014-01-01/hostedzone",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService10TestCaseOperation1, input, output)
+	output = &InputService10TestShapeInputService10TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService10ProtocolTest) InputService10TestCaseOperation1(input *InputService10TestShapeInputShape) (output *InputService10TestShapeInputService10TestCaseOperation1Output, err error) {
+	req, out := c.InputService10TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService10TestCaseOperation1 *aws.Operation
+
+type InputService10TestShapeInputService10TestCaseOperation1Output struct {
+	metadataInputService10TestShapeInputService10TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService10TestShapeInputService10TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService10TestShapeInputShape struct {
+	StructureParam *InputService10TestShapeStructureShape `type:"structure"`
+
+	metadataInputService10TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService10TestShapeInputShape struct {
+	SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"`
+}
+
+type InputService10TestShapeStructureShape struct {
+	B []byte `locationName:"b" type:"blob"`
+
+	T *time.Time `locationName:"t" type:"timestamp" timestampFormat:"iso8601"`
+
+	metadataInputService10TestShapeStructureShape `json:"-", xml:"-"`
+}
+
+type metadataInputService10TestShapeStructureShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// InputService11ProtocolTest is a client for InputService11ProtocolTest.
+type InputService11ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService11ProtocolTest client.
+func NewInputService11ProtocolTest(config *aws.Config) *InputService11ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "inputservice11protocoltest",
+		APIVersion:  "2014-01-01",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &InputService11ProtocolTest{service}
+}
+
+// InputService11TestCaseOperation1Request generates a request for the InputService11TestCaseOperation1 operation.
+func (c *InputService11ProtocolTest) InputService11TestCaseOperation1Request(input *InputService11TestShapeInputShape) (req *aws.Request, output *InputService11TestShapeInputService11TestCaseOperation1Output) {
+	if opInputService11TestCaseOperation1 == nil {
+		opInputService11TestCaseOperation1 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService11TestCaseOperation1, input, output)
+	output = &InputService11TestShapeInputService11TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService11ProtocolTest) InputService11TestCaseOperation1(input *InputService11TestShapeInputShape) (output *InputService11TestShapeInputService11TestCaseOperation1Output, err error) {
+	req, out := c.InputService11TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService11TestCaseOperation1 *aws.Operation
+
+type InputService11TestShapeInputService11TestCaseOperation1Output struct {
+	metadataInputService11TestShapeInputService11TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService11TestShapeInputService11TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService11TestShapeInputShape struct {
+	Foo *map[string]*string `location:"headers" locationName:"x-foo-" type:"map"`
+
+	metadataInputService11TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService11TestShapeInputShape struct {
+	SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"`
+}
+
+// InputService12ProtocolTest is a client for InputService12ProtocolTest.
+type InputService12ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService12ProtocolTest client.
+func NewInputService12ProtocolTest(config *aws.Config) *InputService12ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "inputservice12protocoltest",
+		APIVersion:  "2014-01-01",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &InputService12ProtocolTest{service}
+}
+
+// InputService12TestCaseOperation1Request generates a request for the InputService12TestCaseOperation1 operation.
+func (c *InputService12ProtocolTest) InputService12TestCaseOperation1Request(input *InputService12TestShapeInputShape) (req *aws.Request, output *InputService12TestShapeInputService12TestCaseOperation1Output) {
+	if opInputService12TestCaseOperation1 == nil {
+		opInputService12TestCaseOperation1 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService12TestCaseOperation1, input, output)
+	output = &InputService12TestShapeInputService12TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService12ProtocolTest) InputService12TestCaseOperation1(input *InputService12TestShapeInputShape) (output *InputService12TestShapeInputService12TestCaseOperation1Output, err error) {
+	req, out := c.InputService12TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService12TestCaseOperation1 *aws.Operation
+
+type InputService12TestShapeInputService12TestCaseOperation1Output struct {
+	metadataInputService12TestShapeInputService12TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService12TestShapeInputService12TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService12TestShapeInputShape struct {
+	Foo *string `locationName:"foo" type:"string"`
+
+	metadataInputService12TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService12TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure" payload:"Foo"`
+}
+
+// InputService13ProtocolTest is a client for InputService13ProtocolTest.
+type InputService13ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService13ProtocolTest client.
+func NewInputService13ProtocolTest(config *aws.Config) *InputService13ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "inputservice13protocoltest",
+		APIVersion:  "2014-01-01",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &InputService13ProtocolTest{service}
+}
+
+// InputService13TestCaseOperation1Request generates a request for the InputService13TestCaseOperation1 operation.
+func (c *InputService13ProtocolTest) InputService13TestCaseOperation1Request(input *InputService13TestShapeInputShape) (req *aws.Request, output *InputService13TestShapeInputService13TestCaseOperation1Output) {
+	if opInputService13TestCaseOperation1 == nil {
+		opInputService13TestCaseOperation1 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService13TestCaseOperation1, input, output)
+	output = &InputService13TestShapeInputService13TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService13ProtocolTest) InputService13TestCaseOperation1(input *InputService13TestShapeInputShape) (output *InputService13TestShapeInputService13TestCaseOperation1Output, err error) {
+	req, out := c.InputService13TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService13TestCaseOperation1 *aws.Operation
+
+// InputService13TestCaseOperation2Request generates a request for the InputService13TestCaseOperation2 operation.
+func (c *InputService13ProtocolTest) InputService13TestCaseOperation2Request(input *InputService13TestShapeInputShape) (req *aws.Request, output *InputService13TestShapeInputService13TestCaseOperation2Output) {
+	if opInputService13TestCaseOperation2 == nil {
+		opInputService13TestCaseOperation2 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService13TestCaseOperation2, input, output)
+	output = &InputService13TestShapeInputService13TestCaseOperation2Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService13ProtocolTest) InputService13TestCaseOperation2(input *InputService13TestShapeInputShape) (output *InputService13TestShapeInputService13TestCaseOperation2Output, err error) {
+	req, out := c.InputService13TestCaseOperation2Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService13TestCaseOperation2 *aws.Operation
+
+type InputService13TestShapeInputService13TestCaseOperation1Output struct {
+	metadataInputService13TestShapeInputService13TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService13TestShapeInputService13TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService13TestShapeInputService13TestCaseOperation2Output struct {
+	metadataInputService13TestShapeInputService13TestCaseOperation2Output `json:"-", xml:"-"`
+}
+
+type metadataInputService13TestShapeInputService13TestCaseOperation2Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService13TestShapeInputShape struct {
+	Foo []byte `locationName:"foo" type:"blob"`
+
+	metadataInputService13TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService13TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure" payload:"Foo"`
+}
+
+// InputService14ProtocolTest is a client for InputService14ProtocolTest.
+type InputService14ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService14ProtocolTest client.
+func NewInputService14ProtocolTest(config *aws.Config) *InputService14ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "inputservice14protocoltest",
+		APIVersion:  "2014-01-01",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &InputService14ProtocolTest{service}
+}
+
+// InputService14TestCaseOperation1Request generates a request for the InputService14TestCaseOperation1 operation.
+func (c *InputService14ProtocolTest) InputService14TestCaseOperation1Request(input *InputService14TestShapeInputShape) (req *aws.Request, output *InputService14TestShapeInputService14TestCaseOperation1Output) {
+	if opInputService14TestCaseOperation1 == nil {
+		opInputService14TestCaseOperation1 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService14TestCaseOperation1, input, output)
+	output = &InputService14TestShapeInputService14TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService14ProtocolTest) InputService14TestCaseOperation1(input *InputService14TestShapeInputShape) (output *InputService14TestShapeInputService14TestCaseOperation1Output, err error) {
+	req, out := c.InputService14TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService14TestCaseOperation1 *aws.Operation
+
+// InputService14TestCaseOperation2Request generates a request for the InputService14TestCaseOperation2 operation.
+func (c *InputService14ProtocolTest) InputService14TestCaseOperation2Request(input *InputService14TestShapeInputShape) (req *aws.Request, output *InputService14TestShapeInputService14TestCaseOperation2Output) {
+	if opInputService14TestCaseOperation2 == nil {
+		opInputService14TestCaseOperation2 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService14TestCaseOperation2, input, output)
+	output = &InputService14TestShapeInputService14TestCaseOperation2Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService14ProtocolTest) InputService14TestCaseOperation2(input *InputService14TestShapeInputShape) (output *InputService14TestShapeInputService14TestCaseOperation2Output, err error) {
+	req, out := c.InputService14TestCaseOperation2Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService14TestCaseOperation2 *aws.Operation
+
+type InputService14TestShapeFooShape struct {
+	Baz *string `locationName:"baz" type:"string"`
+
+	metadataInputService14TestShapeFooShape `json:"-", xml:"-"`
+}
+
+type metadataInputService14TestShapeFooShape struct {
+	SDKShapeTraits bool `locationName:"foo" type:"structure"`
+}
+
+type InputService14TestShapeInputService14TestCaseOperation1Output struct {
+	metadataInputService14TestShapeInputService14TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService14TestShapeInputService14TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService14TestShapeInputService14TestCaseOperation2Output struct {
+	metadataInputService14TestShapeInputService14TestCaseOperation2Output `json:"-", xml:"-"`
+}
+
+type metadataInputService14TestShapeInputService14TestCaseOperation2Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService14TestShapeInputShape struct {
+	Foo *InputService14TestShapeFooShape `locationName:"foo" type:"structure"`
+
+	metadataInputService14TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService14TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure" payload:"Foo"`
+}
+
+// InputService15ProtocolTest is a client for InputService15ProtocolTest.
+type InputService15ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService15ProtocolTest client.
+func NewInputService15ProtocolTest(config *aws.Config) *InputService15ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "inputservice15protocoltest",
+		APIVersion:  "2014-01-01",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &InputService15ProtocolTest{service}
+}
+
+// InputService15TestCaseOperation1Request generates a request for the InputService15TestCaseOperation1 operation.
+func (c *InputService15ProtocolTest) InputService15TestCaseOperation1Request(input *InputService15TestShapeInputShape) (req *aws.Request, output *InputService15TestShapeInputService15TestCaseOperation1Output) {
+	if opInputService15TestCaseOperation1 == nil {
+		opInputService15TestCaseOperation1 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService15TestCaseOperation1, input, output)
+	output = &InputService15TestShapeInputService15TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService15ProtocolTest) InputService15TestCaseOperation1(input *InputService15TestShapeInputShape) (output *InputService15TestShapeInputService15TestCaseOperation1Output, err error) {
+	req, out := c.InputService15TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService15TestCaseOperation1 *aws.Operation
+
+type InputService15TestShapeGrant struct {
+	Grantee *InputService15TestShapeGrantee `type:"structure"`
+
+	metadataInputService15TestShapeGrant `json:"-", xml:"-"`
+}
+
+type metadataInputService15TestShapeGrant struct {
+	SDKShapeTraits bool `locationName:"Grant" type:"structure"`
+}
+
+type InputService15TestShapeGrantee struct {
+	EmailAddress *string `type:"string"`
+
+	Type *string `locationName:"xsi:type" type:"string" xmlAttribute:"true"`
+
+	metadataInputService15TestShapeGrantee `json:"-", xml:"-"`
+}
+
+type metadataInputService15TestShapeGrantee struct {
+	SDKShapeTraits bool `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"`
+}
+
+type InputService15TestShapeInputService15TestCaseOperation1Output struct {
+	metadataInputService15TestShapeInputService15TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService15TestShapeInputService15TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService15TestShapeInputShape struct {
+	Grant *InputService15TestShapeGrant `locationName:"Grant" type:"structure"`
+
+	metadataInputService15TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService15TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure" payload:"Grant"`
+}
+
+// InputService16ProtocolTest is a client for InputService16ProtocolTest.
+type InputService16ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService16ProtocolTest client.
+func NewInputService16ProtocolTest(config *aws.Config) *InputService16ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "inputservice16protocoltest",
+		APIVersion:  "2014-01-01",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &InputService16ProtocolTest{service}
+}
+
+// InputService16TestCaseOperation1Request generates a request for the InputService16TestCaseOperation1 operation.
+func (c *InputService16ProtocolTest) InputService16TestCaseOperation1Request(input *InputService16TestShapeInputShape) (req *aws.Request, output *InputService16TestShapeInputService16TestCaseOperation1Output) {
+	if opInputService16TestCaseOperation1 == nil {
+		opInputService16TestCaseOperation1 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "GET",
+			HTTPPath:   "/{Bucket}/{Key+}",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService16TestCaseOperation1, input, output)
+	output = &InputService16TestShapeInputService16TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService16ProtocolTest) InputService16TestCaseOperation1(input *InputService16TestShapeInputShape) (output *InputService16TestShapeInputService16TestCaseOperation1Output, err error) {
+	req, out := c.InputService16TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService16TestCaseOperation1 *aws.Operation
+
+type InputService16TestShapeInputService16TestCaseOperation1Output struct {
+	metadataInputService16TestShapeInputService16TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService16TestShapeInputService16TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService16TestShapeInputShape struct {
+	Bucket *string `location:"uri" type:"string"`
+
+	Key *string `location:"uri" type:"string"`
+
+	metadataInputService16TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService16TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// InputService17ProtocolTest is a client for InputService17ProtocolTest.
+type InputService17ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService17ProtocolTest client.
+func NewInputService17ProtocolTest(config *aws.Config) *InputService17ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "inputservice17protocoltest",
+		APIVersion:  "2014-01-01",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &InputService17ProtocolTest{service}
+}
+
+// InputService17TestCaseOperation1Request generates a request for the InputService17TestCaseOperation1 operation.
+func (c *InputService17ProtocolTest) InputService17TestCaseOperation1Request(input *InputService17TestShapeInputShape) (req *aws.Request, output *InputService17TestShapeInputService17TestCaseOperation1Output) {
+	if opInputService17TestCaseOperation1 == nil {
+		opInputService17TestCaseOperation1 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/path",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService17TestCaseOperation1, input, output)
+	output = &InputService17TestShapeInputService17TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService17ProtocolTest) InputService17TestCaseOperation1(input *InputService17TestShapeInputShape) (output *InputService17TestShapeInputService17TestCaseOperation1Output, err error) {
+	req, out := c.InputService17TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService17TestCaseOperation1 *aws.Operation
+
+// InputService17TestCaseOperation2Request generates a request for the InputService17TestCaseOperation2 operation.
+func (c *InputService17ProtocolTest) InputService17TestCaseOperation2Request(input *InputService17TestShapeInputShape) (req *aws.Request, output *InputService17TestShapeInputService17TestCaseOperation2Output) {
+	if opInputService17TestCaseOperation2 == nil {
+		opInputService17TestCaseOperation2 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/path?abc=mno",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService17TestCaseOperation2, input, output)
+	output = &InputService17TestShapeInputService17TestCaseOperation2Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService17ProtocolTest) InputService17TestCaseOperation2(input *InputService17TestShapeInputShape) (output *InputService17TestShapeInputService17TestCaseOperation2Output, err error) {
+	req, out := c.InputService17TestCaseOperation2Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService17TestCaseOperation2 *aws.Operation
+
+type InputService17TestShapeInputService17TestCaseOperation1Output struct {
+	metadataInputService17TestShapeInputService17TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService17TestShapeInputService17TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService17TestShapeInputService17TestCaseOperation2Output struct {
+	metadataInputService17TestShapeInputService17TestCaseOperation2Output `json:"-", xml:"-"`
+}
+
+type metadataInputService17TestShapeInputService17TestCaseOperation2Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService17TestShapeInputShape struct {
+	Foo *string `location:"querystring" locationName:"param-name" type:"string"`
+
+	metadataInputService17TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService17TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// InputService18ProtocolTest is a client for InputService18ProtocolTest.
+type InputService18ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService18ProtocolTest client.
+func NewInputService18ProtocolTest(config *aws.Config) *InputService18ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "inputservice18protocoltest",
+		APIVersion:  "2014-01-01",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &InputService18ProtocolTest{service}
+}
+
+// InputService18TestCaseOperation1Request generates a request for the InputService18TestCaseOperation1 operation.
+func (c *InputService18ProtocolTest) InputService18TestCaseOperation1Request(input *InputService18TestShapeInputShape) (req *aws.Request, output *InputService18TestShapeInputService18TestShapeInputService18TestCaseOperation1Output) {
+	if opInputService18TestCaseOperation1 == nil {
+		opInputService18TestCaseOperation1 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/path",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService18TestCaseOperation1, input, output)
+	output = &InputService18TestShapeInputService18TestShapeInputService18TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService18ProtocolTest) InputService18TestCaseOperation1(input *InputService18TestShapeInputShape) (output *InputService18TestShapeInputService18TestShapeInputService18TestCaseOperation1Output, err error) {
+	req, out := c.InputService18TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService18TestCaseOperation1 *aws.Operation
+
+// InputService18TestCaseOperation2Request generates a request for the InputService18TestCaseOperation2 operation.
+func (c *InputService18ProtocolTest) InputService18TestCaseOperation2Request(input *InputService18TestShapeInputShape) (req *aws.Request, output *InputService18TestShapeInputService18TestCaseOperation2Output) {
+	if opInputService18TestCaseOperation2 == nil {
+		opInputService18TestCaseOperation2 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/path",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService18TestCaseOperation2, input, output)
+	output = &InputService18TestShapeInputService18TestCaseOperation2Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService18ProtocolTest) InputService18TestCaseOperation2(input *InputService18TestShapeInputShape) (output *InputService18TestShapeInputService18TestCaseOperation2Output, err error) {
+	req, out := c.InputService18TestCaseOperation2Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService18TestCaseOperation2 *aws.Operation
+
+// InputService18TestCaseOperation3Request generates a request for the InputService18TestCaseOperation3 operation.
+func (c *InputService18ProtocolTest) InputService18TestCaseOperation3Request(input *InputService18TestShapeInputShape) (req *aws.Request, output *InputService18TestShapeInputService18TestCaseOperation3Output) {
+	if opInputService18TestCaseOperation3 == nil {
+		opInputService18TestCaseOperation3 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/path",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService18TestCaseOperation3, input, output)
+	output = &InputService18TestShapeInputService18TestCaseOperation3Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService18ProtocolTest) InputService18TestCaseOperation3(input *InputService18TestShapeInputShape) (output *InputService18TestShapeInputService18TestCaseOperation3Output, err error) {
+	req, out := c.InputService18TestCaseOperation3Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService18TestCaseOperation3 *aws.Operation
+
+// InputService18TestCaseOperation4Request generates a request for the InputService18TestCaseOperation4 operation.
+func (c *InputService18ProtocolTest) InputService18TestCaseOperation4Request(input *InputService18TestShapeInputShape) (req *aws.Request, output *InputService18TestShapeInputService18TestShapeInputService18TestCaseOperation4Output) {
+	if opInputService18TestCaseOperation4 == nil {
+		opInputService18TestCaseOperation4 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/path",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService18TestCaseOperation4, input, output)
+	output = &InputService18TestShapeInputService18TestShapeInputService18TestCaseOperation4Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService18ProtocolTest) InputService18TestCaseOperation4(input *InputService18TestShapeInputShape) (output *InputService18TestShapeInputService18TestShapeInputService18TestCaseOperation4Output, err error) {
+	req, out := c.InputService18TestCaseOperation4Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService18TestCaseOperation4 *aws.Operation
+
+// InputService18TestCaseOperation5Request generates a request for the InputService18TestCaseOperation5 operation.
+func (c *InputService18ProtocolTest) InputService18TestCaseOperation5Request(input *InputService18TestShapeInputShape) (req *aws.Request, output *InputService18TestShapeInputService18TestShapeInputService18TestCaseOperation5Output) {
+	if opInputService18TestCaseOperation5 == nil {
+		opInputService18TestCaseOperation5 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/path",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService18TestCaseOperation5, input, output)
+	output = &InputService18TestShapeInputService18TestShapeInputService18TestCaseOperation5Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService18ProtocolTest) InputService18TestCaseOperation5(input *InputService18TestShapeInputShape) (output *InputService18TestShapeInputService18TestShapeInputService18TestCaseOperation5Output, err error) {
+	req, out := c.InputService18TestCaseOperation5Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService18TestCaseOperation5 *aws.Operation
+
+// InputService18TestCaseOperation6Request generates a request for the InputService18TestCaseOperation6 operation.
+func (c *InputService18ProtocolTest) InputService18TestCaseOperation6Request(input *InputService18TestShapeInputShape) (req *aws.Request, output *InputService18TestShapeInputService18TestCaseOperation6Output) {
+	if opInputService18TestCaseOperation6 == nil {
+		opInputService18TestCaseOperation6 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/path",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService18TestCaseOperation6, input, output)
+	output = &InputService18TestShapeInputService18TestCaseOperation6Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService18ProtocolTest) InputService18TestCaseOperation6(input *InputService18TestShapeInputShape) (output *InputService18TestShapeInputService18TestCaseOperation6Output, err error) {
+	req, out := c.InputService18TestCaseOperation6Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService18TestCaseOperation6 *aws.Operation
+
+type InputService18TestShapeInputService18TestCaseOperation2Output struct {
+	metadataInputService18TestShapeInputService18TestCaseOperation2Output `json:"-", xml:"-"`
+}
+
+type metadataInputService18TestShapeInputService18TestCaseOperation2Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService18TestShapeInputService18TestCaseOperation3Output struct {
+	metadataInputService18TestShapeInputService18TestCaseOperation3Output `json:"-", xml:"-"`
+}
+
+type metadataInputService18TestShapeInputService18TestCaseOperation3Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService18TestShapeInputService18TestCaseOperation6Output struct {
+	metadataInputService18TestShapeInputService18TestCaseOperation6Output `json:"-", xml:"-"`
+}
+
+type metadataInputService18TestShapeInputService18TestCaseOperation6Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService18TestShapeInputService18TestShapeInputService18TestCaseOperation1Output struct {
+	metadataInputService18TestShapeInputService18TestShapeInputService18TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService18TestShapeInputService18TestShapeInputService18TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService18TestShapeInputService18TestShapeInputService18TestCaseOperation4Output struct {
+	metadataInputService18TestShapeInputService18TestShapeInputService18TestCaseOperation4Output `json:"-", xml:"-"`
+}
+
+type metadataInputService18TestShapeInputService18TestShapeInputService18TestCaseOperation4Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService18TestShapeInputService18TestShapeInputService18TestCaseOperation5Output struct {
+	metadataInputService18TestShapeInputService18TestShapeInputService18TestCaseOperation5Output `json:"-", xml:"-"`
+}
+
+type metadataInputService18TestShapeInputService18TestShapeInputService18TestCaseOperation5Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService18TestShapeInputShape struct {
+	RecursiveStruct *InputService18TestShapeRecursiveStructType `type:"structure"`
+
+	metadataInputService18TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService18TestShapeInputShape struct {
+	SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"`
+}
+
+type InputService18TestShapeRecursiveStructType struct {
+	NoRecurse *string `type:"string"`
+
+	RecursiveList []*InputService18TestShapeRecursiveStructType `type:"list"`
+
+	RecursiveMap *map[string]*InputService18TestShapeRecursiveStructType `type:"map"`
+
+	RecursiveStruct *InputService18TestShapeRecursiveStructType `type:"structure"`
+
+	metadataInputService18TestShapeRecursiveStructType `json:"-", xml:"-"`
+}
+
+type metadataInputService18TestShapeRecursiveStructType struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// InputService19ProtocolTest is a client for InputService19ProtocolTest.
+type InputService19ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new InputService19ProtocolTest client.
+func NewInputService19ProtocolTest(config *aws.Config) *InputService19ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "inputservice19protocoltest",
+		APIVersion:  "2014-01-01",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &InputService19ProtocolTest{service}
+}
+
+// InputService19TestCaseOperation1Request generates a request for the InputService19TestCaseOperation1 operation.
+func (c *InputService19ProtocolTest) InputService19TestCaseOperation1Request(input *InputService19TestShapeInputShape) (req *aws.Request, output *InputService19TestShapeInputService19TestCaseOperation1Output) {
+	if opInputService19TestCaseOperation1 == nil {
+		opInputService19TestCaseOperation1 = &aws.Operation{
+			Name:       "OperationName",
+			HTTPMethod: "POST",
+			HTTPPath:   "/path",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opInputService19TestCaseOperation1, input, output)
+	output = &InputService19TestShapeInputService19TestCaseOperation1Output{}
+	req.Data = output
+	return
+}
+
+func (c *InputService19ProtocolTest) InputService19TestCaseOperation1(input *InputService19TestShapeInputShape) (output *InputService19TestShapeInputService19TestCaseOperation1Output, err error) {
+	req, out := c.InputService19TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opInputService19TestCaseOperation1 *aws.Operation
+
+type InputService19TestShapeInputService19TestCaseOperation1Output struct {
+	metadataInputService19TestShapeInputService19TestCaseOperation1Output `json:"-", xml:"-"`
+}
+
+type metadataInputService19TestShapeInputService19TestCaseOperation1Output struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService19TestShapeInputShape struct {
+	TimeArgInHeader *time.Time `location:"header" locationName:"x-amz-timearg" type:"timestamp" timestampFormat:"rfc822"`
+
+	metadataInputService19TestShapeInputShape `json:"-", xml:"-"`
+}
+
+type metadataInputService19TestShapeInputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+//
+// Tests begin here
+//
+
+func TestInputService1ProtocolTestBasicXMLSerializationCase1(t *testing.T) {
+	svc := NewInputService1ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService1TestShapeInputShape{
+		Description: aws.String("bar"),
+		Name:        aws.String("foo"),
+	}
+	req, _ := svc.InputService1TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`<OperationRequest xmlns="https://foo/"><Description xmlns="https://foo/">bar</Description><Name xmlns="https://foo/">foo</Name></OperationRequest>`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService1ProtocolTestBasicXMLSerializationCase2(t *testing.T) {
+	svc := NewInputService1ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService1TestShapeInputShape{
+		Description: aws.String("bar"),
+		Name:        aws.String("foo"),
+	}
+	req, _ := svc.InputService1TestCaseOperation2Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`<OperationRequest xmlns="https://foo/"><Description xmlns="https://foo/">bar</Description><Name xmlns="https://foo/">foo</Name></OperationRequest>`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService2ProtocolTestSerializeOtherScalarTypesCase1(t *testing.T) {
+	svc := NewInputService2ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService2TestShapeInputShape{
+		First:  aws.Boolean(true),
+		Fourth: aws.Long(3),
+		Second: aws.Boolean(false),
+		Third:  aws.Double(1.2),
+	}
+	req, _ := svc.InputService2TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`<OperationRequest xmlns="https://foo/"><First xmlns="https://foo/">true</First><Fourth xmlns="https://foo/">3</Fourth><Second xmlns="https://foo/">false</Second><Third xmlns="https://foo/">1.2</Third></OperationRequest>`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService3ProtocolTestNestedStructuresCase1(t *testing.T) {
+	svc := NewInputService3ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService3TestShapeInputShape{
+		Description: aws.String("baz"),
+		SubStructure: &InputService3TestShapeSubStructure{
+			Bar: aws.String("b"),
+			Foo: aws.String("a"),
+		},
+	}
+	req, _ := svc.InputService3TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`<OperationRequest xmlns="https://foo/"><Description xmlns="https://foo/">baz</Description><SubStructure xmlns="https://foo/"><Bar xmlns="https://foo/">b</Bar><Foo xmlns="https://foo/">a</Foo></SubStructure></OperationRequest>`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService4ProtocolTestNestedStructuresCase1(t *testing.T) {
+	svc := NewInputService4ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService4TestShapeInputShape{
+		Description:  aws.String("baz"),
+		SubStructure: &InputService4TestShapeSubStructure{},
+	}
+	req, _ := svc.InputService4TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`<OperationRequest xmlns="https://foo/"><Description xmlns="https://foo/">baz</Description><SubStructure xmlns="https://foo/"></SubStructure></OperationRequest>`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService5ProtocolTestNonFlattenedListsCase1(t *testing.T) {
+	svc := NewInputService5ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService5TestShapeInputShape{
+		ListParam: []*string{
+			aws.String("one"),
+			aws.String("two"),
+			aws.String("three"),
+		},
+	}
+	req, _ := svc.InputService5TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`<OperationRequest xmlns="https://foo/"><ListParam xmlns="https://foo/"><member xmlns="https://foo/">one</member><member xmlns="https://foo/">two</member><member xmlns="https://foo/">three</member></ListParam></OperationRequest>`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService6ProtocolTestNonFlattenedListsWithLocationNameCase1(t *testing.T) {
+	svc := NewInputService6ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService6TestShapeInputShape{
+		ListParam: []*string{
+			aws.String("one"),
+			aws.String("two"),
+			aws.String("three"),
+		},
+	}
+	req, _ := svc.InputService6TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`<OperationRequest xmlns="https://foo/"><AlternateName xmlns="https://foo/"><NotMember xmlns="https://foo/">one</NotMember><NotMember xmlns="https://foo/">two</NotMember><NotMember xmlns="https://foo/">three</NotMember></AlternateName></OperationRequest>`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService7ProtocolTestFlattenedListsCase1(t *testing.T) {
+	svc := NewInputService7ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService7TestShapeInputShape{
+		ListParam: []*string{
+			aws.String("one"),
+			aws.String("two"),
+			aws.String("three"),
+		},
+	}
+	req, _ := svc.InputService7TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`<OperationRequest xmlns="https://foo/"><ListParam xmlns="https://foo/">one</ListParam><ListParam xmlns="https://foo/">two</ListParam><ListParam xmlns="https://foo/">three</ListParam></OperationRequest>`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService8ProtocolTestFlattenedListsWithLocationNameCase1(t *testing.T) {
+	svc := NewInputService8ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService8TestShapeInputShape{
+		ListParam: []*string{
+			aws.String("one"),
+			aws.String("two"),
+			aws.String("three"),
+		},
+	}
+	req, _ := svc.InputService8TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`<OperationRequest xmlns="https://foo/"><item xmlns="https://foo/">one</item><item xmlns="https://foo/">two</item><item xmlns="https://foo/">three</item></OperationRequest>`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService9ProtocolTestListOfStructuresCase1(t *testing.T) {
+	svc := NewInputService9ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService9TestShapeInputShape{
+		ListParam: []*InputService9TestShapeSingleFieldStruct{
+			&InputService9TestShapeSingleFieldStruct{
+				Element: aws.String("one"),
+			},
+			&InputService9TestShapeSingleFieldStruct{
+				Element: aws.String("two"),
+			},
+			&InputService9TestShapeSingleFieldStruct{
+				Element: aws.String("three"),
+			},
+		},
+	}
+	req, _ := svc.InputService9TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`<OperationRequest xmlns="https://foo/"><item xmlns="https://foo/"><value xmlns="https://foo/">one</value></item><item xmlns="https://foo/"><value xmlns="https://foo/">two</value></item><item xmlns="https://foo/"><value xmlns="https://foo/">three</value></item></OperationRequest>`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService10ProtocolTestBlobAndTimestampShapesCase1(t *testing.T) {
+	svc := NewInputService10ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService10TestShapeInputShape{
+		StructureParam: &InputService10TestShapeStructureShape{
+			B: []byte("foo"),
+			T: aws.Time(time.Unix(1422172800, 0)),
+		},
+	}
+	req, _ := svc.InputService10TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`<OperationRequest xmlns="https://foo/"><StructureParam xmlns="https://foo/"><b xmlns="https://foo/">Zm9v</b><t xmlns="https://foo/">2015-01-25T08:00:00Z</t></StructureParam></OperationRequest>`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService11ProtocolTestHeaderMapsCase1(t *testing.T) {
+	svc := NewInputService11ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService11TestShapeInputShape{
+		Foo: &map[string]*string{
+			"a": aws.String("b"),
+			"c": aws.String("d"),
+		},
+	}
+	req, _ := svc.InputService11TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+	assert.Equal(t, "b", r.Header.Get("x-foo-a"))
+	assert.Equal(t, "d", r.Header.Get("x-foo-c"))
+
+}
+
+func TestInputService12ProtocolTestStringPayloadCase1(t *testing.T) {
+	svc := NewInputService12ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService12TestShapeInputShape{
+		Foo: aws.String("bar"),
+	}
+	req, _ := svc.InputService12TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`bar`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService13ProtocolTestBlobPayloadCase1(t *testing.T) {
+	svc := NewInputService13ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService13TestShapeInputShape{
+		Foo: []byte("bar"),
+	}
+	req, _ := svc.InputService13TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`bar`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService13ProtocolTestBlobPayloadCase2(t *testing.T) {
+	svc := NewInputService13ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService13TestShapeInputShape{}
+	req, _ := svc.InputService13TestCaseOperation2Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService14ProtocolTestStructurePayloadCase1(t *testing.T) {
+	svc := NewInputService14ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService14TestShapeInputShape{
+		Foo: &InputService14TestShapeFooShape{
+			Baz: aws.String("bar"),
+		},
+	}
+	req, _ := svc.InputService14TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`<foo><baz>bar</baz></foo>`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService14ProtocolTestStructurePayloadCase2(t *testing.T) {
+	svc := NewInputService14ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService14TestShapeInputShape{}
+	req, _ := svc.InputService14TestCaseOperation2Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService15ProtocolTestXMLAttributeCase1(t *testing.T) {
+	svc := NewInputService15ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService15TestShapeInputShape{
+		Grant: &InputService15TestShapeGrant{
+			Grantee: &InputService15TestShapeGrantee{
+				EmailAddress: aws.String("foo@example.com"),
+				Type:         aws.String("CanonicalUser"),
+			},
+		},
+	}
+	req, _ := svc.InputService15TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`<Grant xmlns:_xmlns="xmlns" _xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:XMLSchema-instance="http://www.w3.org/2001/XMLSchema-instance" XMLSchema-instance:type="CanonicalUser"><Grantee><EmailAddress>foo@example.com</EmailAddress></Grantee></Grant>`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService16ProtocolTestGreedyKeysCase1(t *testing.T) {
+	svc := NewInputService16ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService16TestShapeInputShape{
+		Bucket: aws.String("my/bucket"),
+		Key:    aws.String("testing /123"),
+	}
+	req, _ := svc.InputService16TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert URL
+	assert.Equal(t, "https://test/my%2Fbucket/testing%20/123", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService17ProtocolTestOmitsNullQueryParamsButSerializesEmptyStringsCase1(t *testing.T) {
+	svc := NewInputService17ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService17TestShapeInputShape{}
+	req, _ := svc.InputService17TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert URL
+	assert.Equal(t, "https://test/path", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService17ProtocolTestOmitsNullQueryParamsButSerializesEmptyStringsCase2(t *testing.T) {
+	svc := NewInputService17ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService17TestShapeInputShape{
+		Foo: aws.String(""),
+	}
+	req, _ := svc.InputService17TestCaseOperation2Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert URL
+	assert.Equal(t, "https://test/path?abc=mno&param-name=", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService18ProtocolTestRecursiveShapesCase1(t *testing.T) {
+	svc := NewInputService18ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService18TestShapeInputShape{
+		RecursiveStruct: &InputService18TestShapeRecursiveStructType{
+			NoRecurse: aws.String("foo"),
+		},
+	}
+	req, _ := svc.InputService18TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`<OperationRequest xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><NoRecurse xmlns="https://foo/">foo</NoRecurse></RecursiveStruct></OperationRequest>`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/path", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService18ProtocolTestRecursiveShapesCase2(t *testing.T) {
+	svc := NewInputService18ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService18TestShapeInputShape{
+		RecursiveStruct: &InputService18TestShapeRecursiveStructType{
+			RecursiveStruct: &InputService18TestShapeRecursiveStructType{
+				NoRecurse: aws.String("foo"),
+			},
+		},
+	}
+	req, _ := svc.InputService18TestCaseOperation2Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`<OperationRequest xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><NoRecurse xmlns="https://foo/">foo</NoRecurse></RecursiveStruct></RecursiveStruct></OperationRequest>`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/path", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService18ProtocolTestRecursiveShapesCase3(t *testing.T) {
+	svc := NewInputService18ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService18TestShapeInputShape{
+		RecursiveStruct: &InputService18TestShapeRecursiveStructType{
+			RecursiveStruct: &InputService18TestShapeRecursiveStructType{
+				RecursiveStruct: &InputService18TestShapeRecursiveStructType{
+					RecursiveStruct: &InputService18TestShapeRecursiveStructType{
+						NoRecurse: aws.String("foo"),
+					},
+				},
+			},
+		},
+	}
+	req, _ := svc.InputService18TestCaseOperation3Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`<OperationRequest xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><NoRecurse xmlns="https://foo/">foo</NoRecurse></RecursiveStruct></RecursiveStruct></RecursiveStruct></RecursiveStruct></OperationRequest>`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/path", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService18ProtocolTestRecursiveShapesCase4(t *testing.T) {
+	svc := NewInputService18ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService18TestShapeInputShape{
+		RecursiveStruct: &InputService18TestShapeRecursiveStructType{
+			RecursiveList: []*InputService18TestShapeRecursiveStructType{
+				&InputService18TestShapeRecursiveStructType{
+					NoRecurse: aws.String("foo"),
+				},
+				&InputService18TestShapeRecursiveStructType{
+					NoRecurse: aws.String("bar"),
+				},
+			},
+		},
+	}
+	req, _ := svc.InputService18TestCaseOperation4Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`<OperationRequest xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><RecursiveList xmlns="https://foo/"><member xmlns="https://foo/"><NoRecurse xmlns="https://foo/">foo</NoRecurse></member><member xmlns="https://foo/"><NoRecurse xmlns="https://foo/">bar</NoRecurse></member></RecursiveList></RecursiveStruct></OperationRequest>`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/path", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService18ProtocolTestRecursiveShapesCase5(t *testing.T) {
+	svc := NewInputService18ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService18TestShapeInputShape{
+		RecursiveStruct: &InputService18TestShapeRecursiveStructType{
+			RecursiveList: []*InputService18TestShapeRecursiveStructType{
+				&InputService18TestShapeRecursiveStructType{
+					NoRecurse: aws.String("foo"),
+				},
+				&InputService18TestShapeRecursiveStructType{
+					RecursiveStruct: &InputService18TestShapeRecursiveStructType{
+						NoRecurse: aws.String("bar"),
+					},
+				},
+			},
+		},
+	}
+	req, _ := svc.InputService18TestCaseOperation5Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`<OperationRequest xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><RecursiveList xmlns="https://foo/"><member xmlns="https://foo/"><NoRecurse xmlns="https://foo/">foo</NoRecurse></member><member xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><NoRecurse xmlns="https://foo/">bar</NoRecurse></RecursiveStruct></member></RecursiveList></RecursiveStruct></OperationRequest>`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/path", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService18ProtocolTestRecursiveShapesCase6(t *testing.T) {
+	svc := NewInputService18ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService18TestShapeInputShape{
+		RecursiveStruct: &InputService18TestShapeRecursiveStructType{
+			RecursiveMap: &map[string]*InputService18TestShapeRecursiveStructType{
+				"bar": &InputService18TestShapeRecursiveStructType{
+					NoRecurse: aws.String("bar"),
+				},
+				"foo": &InputService18TestShapeRecursiveStructType{
+					NoRecurse: aws.String("foo"),
+				},
+			},
+		},
+	}
+	req, _ := svc.InputService18TestCaseOperation6Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert body
+	assert.NotNil(t, r.Body)
+	body := util.SortXML(r.Body)
+	assert.Equal(t, util.Trim(`<OperationRequest xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><RecursiveMap xmlns="https://foo/"><entry xmlns="https://foo/"><key xmlns="https://foo/">bar</key><value xmlns="https://foo/"><NoRecurse xmlns="https://foo/">bar</NoRecurse></value></entry><entry xmlns="https://foo/"><key xmlns="https://foo/">foo</key><value xmlns="https://foo/"><NoRecurse xmlns="https://foo/">foo</NoRecurse></value></entry></RecursiveMap></RecursiveStruct></OperationRequest>`), util.Trim(string(body)))
+
+	// assert URL
+	assert.Equal(t, "https://test/path", r.URL.String())
+
+	// assert headers
+
+}
+
+func TestInputService19ProtocolTestTimestampInHeaderCase1(t *testing.T) {
+	svc := NewInputService19ProtocolTest(nil)
+	svc.Endpoint = "https://test"
+
+	input := &InputService19TestShapeInputShape{
+		TimeArgInHeader: aws.Time(time.Unix(1422172800, 0)),
+	}
+	req, _ := svc.InputService19TestCaseOperation1Request(input)
+	r := req.HTTPRequest
+
+	// build request
+	restxml.Build(req)
+	assert.NoError(t, req.Error)
+
+	// assert URL
+	assert.Equal(t, "https://test/path", r.URL.String())
+
+	// assert headers
+	assert.Equal(t, "Sun, 25 Jan 2015 08:00:00 GMT", r.Header.Get("x-amz-timearg"))
+
+}
+
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/restxml/restxml.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/restxml/restxml.go
new file mode 100644
index 000000000..9a952ee19
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/restxml/restxml.go
@@ -0,0 +1,48 @@
+package restxml
+
+//go:generate go run ../../fixtures/protocol/generate.go ../../fixtures/protocol/input/rest-xml.json build_test.go
+//go:generate go run ../../fixtures/protocol/generate.go ../../fixtures/protocol/output/rest-xml.json unmarshal_test.go
+
+import (
+	"bytes"
+	"encoding/xml"
+
+	"github.com/awslabs/aws-sdk-go/aws"
+	"github.com/awslabs/aws-sdk-go/internal/protocol/query"
+	"github.com/awslabs/aws-sdk-go/internal/protocol/rest"
+	"github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil"
+)
+
+func Build(r *aws.Request) {
+	rest.Build(r)
+
+	if t := rest.PayloadType(r.Params); t == "structure" || t == "" {
+		var buf bytes.Buffer
+		err := xmlutil.BuildXML(r.Params, xml.NewEncoder(&buf))
+		if err != nil {
+			r.Error = err
+			return
+		}
+		r.SetBufferBody(buf.Bytes())
+	}
+}
+
+func Unmarshal(r *aws.Request) {
+	if t := rest.PayloadType(r.Data); t == "structure" || t == "" {
+		defer r.HTTPResponse.Body.Close()
+		decoder := xml.NewDecoder(r.HTTPResponse.Body)
+		err := xmlutil.UnmarshalXML(r.Data, decoder, "")
+		if err != nil {
+			r.Error = err
+			return
+		}
+	}
+}
+
+func UnmarshalMeta(r *aws.Request) {
+	rest.Unmarshal(r)
+}
+
+func UnmarshalError(r *aws.Request) {
+	query.UnmarshalError(r)
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/restxml/unmarshal_test.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/restxml/unmarshal_test.go
new file mode 100644
index 000000000..33e261628
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/restxml/unmarshal_test.go
@@ -0,0 +1,1171 @@
+package restxml_test
+
+import (
+	"github.com/awslabs/aws-sdk-go/aws"
+	"github.com/awslabs/aws-sdk-go/internal/protocol/restxml"
+	"github.com/awslabs/aws-sdk-go/internal/signer/v4"
+
+	"bytes"
+	"encoding/json"
+	"encoding/xml"
+	"github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil"
+	"github.com/awslabs/aws-sdk-go/internal/util"
+	"github.com/stretchr/testify/assert"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"testing"
+	"time"
+)
+
+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{}
+
+// OutputService1ProtocolTest is a client for OutputService1ProtocolTest.
+type OutputService1ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService1ProtocolTest client.
+func NewOutputService1ProtocolTest(config *aws.Config) *OutputService1ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice1protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &OutputService1ProtocolTest{service}
+}
+
+// OutputService1TestCaseOperation1Request generates a request for the OutputService1TestCaseOperation1 operation.
+func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1Request(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (req *aws.Request, output *OutputService1TestShapeOutputShape) {
+	if opOutputService1TestCaseOperation1 == nil {
+		opOutputService1TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService1TestCaseOperation1, input, output)
+	output = &OutputService1TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (output *OutputService1TestShapeOutputShape, err error) {
+	req, out := c.OutputService1TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService1TestCaseOperation1 *aws.Operation
+
+// OutputService1TestCaseOperation2Request generates a request for the OutputService1TestCaseOperation2 operation.
+func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2Request(input *OutputService1TestShapeOutputService1TestCaseOperation2Input) (req *aws.Request, output *OutputService1TestShapeOutputShape) {
+	if opOutputService1TestCaseOperation2 == nil {
+		opOutputService1TestCaseOperation2 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService1TestCaseOperation2, input, output)
+	output = &OutputService1TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2(input *OutputService1TestShapeOutputService1TestCaseOperation2Input) (output *OutputService1TestShapeOutputShape, err error) {
+	req, out := c.OutputService1TestCaseOperation2Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService1TestCaseOperation2 *aws.Operation
+
+type OutputService1TestShapeOutputService1TestCaseOperation1Input struct {
+	metadataOutputService1TestShapeOutputService1TestCaseOperation1Input `json:"-", xml:"-"`
+}
+
+type metadataOutputService1TestShapeOutputService1TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService1TestShapeOutputService1TestCaseOperation2Input struct {
+	metadataOutputService1TestShapeOutputService1TestCaseOperation2Input `json:"-", xml:"-"`
+}
+
+type metadataOutputService1TestShapeOutputService1TestCaseOperation2Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService1TestShapeOutputShape struct {
+	Char *string `type:"character"`
+
+	Double *float64 `type:"double"`
+
+	FalseBool *bool `type:"boolean"`
+
+	Float *float64 `type:"float"`
+
+	ImaHeader *string `location:"header" type:"string"`
+
+	ImaHeaderLocation *string `location:"header" locationName:"X-Foo" type:"string"`
+
+	Long *int64 `type:"long"`
+
+	Num *int64 `locationName:"FooNum" type:"integer"`
+
+	Str *string `type:"string"`
+
+	Timestamp *time.Time `type:"timestamp" timestampFormat:"iso8601"`
+
+	TrueBool *bool `type:"boolean"`
+
+	metadataOutputService1TestShapeOutputShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService1TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService2ProtocolTest is a client for OutputService2ProtocolTest.
+type OutputService2ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService2ProtocolTest client.
+func NewOutputService2ProtocolTest(config *aws.Config) *OutputService2ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice2protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &OutputService2ProtocolTest{service}
+}
+
+// OutputService2TestCaseOperation1Request generates a request for the OutputService2TestCaseOperation1 operation.
+func (c *OutputService2ProtocolTest) OutputService2TestCaseOperation1Request(input *OutputService2TestShapeOutputService2TestCaseOperation1Input) (req *aws.Request, output *OutputService2TestShapeOutputShape) {
+	if opOutputService2TestCaseOperation1 == nil {
+		opOutputService2TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService2TestCaseOperation1, input, output)
+	output = &OutputService2TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService2ProtocolTest) OutputService2TestCaseOperation1(input *OutputService2TestShapeOutputService2TestCaseOperation1Input) (output *OutputService2TestShapeOutputShape, err error) {
+	req, out := c.OutputService2TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService2TestCaseOperation1 *aws.Operation
+
+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"`
+}
+
+// OutputService3ProtocolTest is a client for OutputService3ProtocolTest.
+type OutputService3ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService3ProtocolTest client.
+func NewOutputService3ProtocolTest(config *aws.Config) *OutputService3ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice3protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &OutputService3ProtocolTest{service}
+}
+
+// OutputService3TestCaseOperation1Request generates a request for the OutputService3TestCaseOperation1 operation.
+func (c *OutputService3ProtocolTest) OutputService3TestCaseOperation1Request(input *OutputService3TestShapeOutputService3TestCaseOperation1Input) (req *aws.Request, output *OutputService3TestShapeOutputShape) {
+	if opOutputService3TestCaseOperation1 == nil {
+		opOutputService3TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService3TestCaseOperation1, input, output)
+	output = &OutputService3TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService3ProtocolTest) OutputService3TestCaseOperation1(input *OutputService3TestShapeOutputService3TestCaseOperation1Input) (output *OutputService3TestShapeOutputShape, err error) {
+	req, out := c.OutputService3TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService3TestCaseOperation1 *aws.Operation
+
+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"`
+}
+
+// OutputService4ProtocolTest is a client for OutputService4ProtocolTest.
+type OutputService4ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService4ProtocolTest client.
+func NewOutputService4ProtocolTest(config *aws.Config) *OutputService4ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice4protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &OutputService4ProtocolTest{service}
+}
+
+// OutputService4TestCaseOperation1Request generates a request for the OutputService4TestCaseOperation1 operation.
+func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1Request(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (req *aws.Request, output *OutputService4TestShapeOutputShape) {
+	if opOutputService4TestCaseOperation1 == nil {
+		opOutputService4TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService4TestCaseOperation1, input, output)
+	output = &OutputService4TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (output *OutputService4TestShapeOutputShape, err error) {
+	req, out := c.OutputService4TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService4TestCaseOperation1 *aws.Operation
+
+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"`
+}
+
+// OutputService5ProtocolTest is a client for OutputService5ProtocolTest.
+type OutputService5ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService5ProtocolTest client.
+func NewOutputService5ProtocolTest(config *aws.Config) *OutputService5ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice5protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &OutputService5ProtocolTest{service}
+}
+
+// OutputService5TestCaseOperation1Request generates a request for the OutputService5TestCaseOperation1 operation.
+func (c *OutputService5ProtocolTest) OutputService5TestCaseOperation1Request(input *OutputService5TestShapeOutputService5TestCaseOperation1Input) (req *aws.Request, output *OutputService5TestShapeOutputShape) {
+	if opOutputService5TestCaseOperation1 == nil {
+		opOutputService5TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService5TestCaseOperation1, input, output)
+	output = &OutputService5TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService5ProtocolTest) OutputService5TestCaseOperation1(input *OutputService5TestShapeOutputService5TestCaseOperation1Input) (output *OutputService5TestShapeOutputShape, err error) {
+	req, out := c.OutputService5TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService5TestCaseOperation1 *aws.Operation
+
+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"`
+}
+
+// OutputService6ProtocolTest is a client for OutputService6ProtocolTest.
+type OutputService6ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService6ProtocolTest client.
+func NewOutputService6ProtocolTest(config *aws.Config) *OutputService6ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice6protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &OutputService6ProtocolTest{service}
+}
+
+// OutputService6TestCaseOperation1Request generates a request for the OutputService6TestCaseOperation1 operation.
+func (c *OutputService6ProtocolTest) OutputService6TestCaseOperation1Request(input *OutputService6TestShapeOutputService6TestCaseOperation1Input) (req *aws.Request, output *OutputService6TestShapeOutputShape) {
+	if opOutputService6TestCaseOperation1 == nil {
+		opOutputService6TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService6TestCaseOperation1, input, output)
+	output = &OutputService6TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService6ProtocolTest) OutputService6TestCaseOperation1(input *OutputService6TestShapeOutputService6TestCaseOperation1Input) (output *OutputService6TestShapeOutputShape, err error) {
+	req, out := c.OutputService6TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService6TestCaseOperation1 *aws.Operation
+
+type OutputService6TestShapeOutputService6TestCaseOperation1Input struct {
+	metadataOutputService6TestShapeOutputService6TestCaseOperation1Input `json:"-", xml:"-"`
+}
+
+type metadataOutputService6TestShapeOutputService6TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService6TestShapeOutputShape struct {
+	Map *map[string]*OutputService6TestShapeSingleStructure `type:"map"`
+
+	metadataOutputService6TestShapeOutputShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService6TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService6TestShapeSingleStructure struct {
+	Foo *string `locationName:"foo" type:"string"`
+
+	metadataOutputService6TestShapeSingleStructure `json:"-", xml:"-"`
+}
+
+type metadataOutputService6TestShapeSingleStructure struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService7ProtocolTest is a client for OutputService7ProtocolTest.
+type OutputService7ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService7ProtocolTest client.
+func NewOutputService7ProtocolTest(config *aws.Config) *OutputService7ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice7protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &OutputService7ProtocolTest{service}
+}
+
+// OutputService7TestCaseOperation1Request generates a request for the OutputService7TestCaseOperation1 operation.
+func (c *OutputService7ProtocolTest) OutputService7TestCaseOperation1Request(input *OutputService7TestShapeOutputService7TestCaseOperation1Input) (req *aws.Request, output *OutputService7TestShapeOutputShape) {
+	if opOutputService7TestCaseOperation1 == nil {
+		opOutputService7TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService7TestCaseOperation1, input, output)
+	output = &OutputService7TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService7ProtocolTest) OutputService7TestCaseOperation1(input *OutputService7TestShapeOutputService7TestCaseOperation1Input) (output *OutputService7TestShapeOutputShape, err error) {
+	req, out := c.OutputService7TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService7TestCaseOperation1 *aws.Operation
+
+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"`
+}
+
+// OutputService8ProtocolTest is a client for OutputService8ProtocolTest.
+type OutputService8ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService8ProtocolTest client.
+func NewOutputService8ProtocolTest(config *aws.Config) *OutputService8ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice8protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &OutputService8ProtocolTest{service}
+}
+
+// OutputService8TestCaseOperation1Request generates a request for the OutputService8TestCaseOperation1 operation.
+func (c *OutputService8ProtocolTest) OutputService8TestCaseOperation1Request(input *OutputService8TestShapeOutputService8TestCaseOperation1Input) (req *aws.Request, output *OutputService8TestShapeOutputShape) {
+	if opOutputService8TestCaseOperation1 == nil {
+		opOutputService8TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService8TestCaseOperation1, input, output)
+	output = &OutputService8TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService8ProtocolTest) OutputService8TestCaseOperation1(input *OutputService8TestShapeOutputService8TestCaseOperation1Input) (output *OutputService8TestShapeOutputShape, err error) {
+	req, out := c.OutputService8TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService8TestCaseOperation1 *aws.Operation
+
+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"`
+
+	metadataOutputService8TestShapeOutputShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService8TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService9ProtocolTest is a client for OutputService9ProtocolTest.
+type OutputService9ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService9ProtocolTest client.
+func NewOutputService9ProtocolTest(config *aws.Config) *OutputService9ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice9protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &OutputService9ProtocolTest{service}
+}
+
+// OutputService9TestCaseOperation1Request generates a request for the OutputService9TestCaseOperation1 operation.
+func (c *OutputService9ProtocolTest) OutputService9TestCaseOperation1Request(input *OutputService9TestShapeOutputService9TestCaseOperation1Input) (req *aws.Request, output *OutputService9TestShapeOutputShape) {
+	if opOutputService9TestCaseOperation1 == nil {
+		opOutputService9TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService9TestCaseOperation1, input, output)
+	output = &OutputService9TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService9ProtocolTest) OutputService9TestCaseOperation1(input *OutputService9TestShapeOutputService9TestCaseOperation1Input) (output *OutputService9TestShapeOutputShape, err error) {
+	req, out := c.OutputService9TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService9TestCaseOperation1 *aws.Operation
+
+type OutputService9TestShapeOutputService9TestCaseOperation1Input struct {
+	metadataOutputService9TestShapeOutputService9TestCaseOperation1Input `json:"-", xml:"-"`
+}
+
+type metadataOutputService9TestShapeOutputService9TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService9TestShapeOutputShape struct {
+	Data *OutputService9TestShapeSingleStructure `type:"structure"`
+
+	Header *string `location:"header" locationName:"X-Foo" type:"string"`
+
+	metadataOutputService9TestShapeOutputShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService9TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure" payload:"Data"`
+}
+
+type OutputService9TestShapeSingleStructure struct {
+	Foo *string `type:"string"`
+
+	metadataOutputService9TestShapeSingleStructure `json:"-", xml:"-"`
+}
+
+type metadataOutputService9TestShapeSingleStructure struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService10ProtocolTest is a client for OutputService10ProtocolTest.
+type OutputService10ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService10ProtocolTest client.
+func NewOutputService10ProtocolTest(config *aws.Config) *OutputService10ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice10protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &OutputService10ProtocolTest{service}
+}
+
+// OutputService10TestCaseOperation1Request generates a request for the OutputService10TestCaseOperation1 operation.
+func (c *OutputService10ProtocolTest) OutputService10TestCaseOperation1Request(input *OutputService10TestShapeOutputService10TestCaseOperation1Input) (req *aws.Request, output *OutputService10TestShapeOutputShape) {
+	if opOutputService10TestCaseOperation1 == nil {
+		opOutputService10TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService10TestCaseOperation1, input, output)
+	output = &OutputService10TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService10ProtocolTest) OutputService10TestCaseOperation1(input *OutputService10TestShapeOutputService10TestCaseOperation1Input) (output *OutputService10TestShapeOutputShape, err error) {
+	req, out := c.OutputService10TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService10TestCaseOperation1 *aws.Operation
+
+type OutputService10TestShapeOutputService10TestCaseOperation1Input struct {
+	metadataOutputService10TestShapeOutputService10TestCaseOperation1Input `json:"-", xml:"-"`
+}
+
+type metadataOutputService10TestShapeOutputService10TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService10TestShapeOutputShape struct {
+	Stream []byte `type:"blob"`
+
+	metadataOutputService10TestShapeOutputShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService10TestShapeOutputShape struct {
+	SDKShapeTraits bool `type:"structure" payload:"Stream"`
+}
+
+// OutputService11ProtocolTest is a client for OutputService11ProtocolTest.
+type OutputService11ProtocolTest struct {
+	*aws.Service
+}
+
+// New returns a new OutputService11ProtocolTest client.
+func NewOutputService11ProtocolTest(config *aws.Config) *OutputService11ProtocolTest {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "outputservice11protocoltest",
+		APIVersion:  "",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	return &OutputService11ProtocolTest{service}
+}
+
+// OutputService11TestCaseOperation1Request generates a request for the OutputService11TestCaseOperation1 operation.
+func (c *OutputService11ProtocolTest) OutputService11TestCaseOperation1Request(input *OutputService11TestShapeOutputService11TestCaseOperation1Input) (req *aws.Request, output *OutputService11TestShapeOutputShape) {
+	if opOutputService11TestCaseOperation1 == nil {
+		opOutputService11TestCaseOperation1 = &aws.Operation{
+			Name: "OperationName",
+		}
+	}
+
+	req = aws.NewRequest(c.Service, opOutputService11TestCaseOperation1, input, output)
+	output = &OutputService11TestShapeOutputShape{}
+	req.Data = output
+	return
+}
+
+func (c *OutputService11ProtocolTest) OutputService11TestCaseOperation1(input *OutputService11TestShapeOutputService11TestCaseOperation1Input) (output *OutputService11TestShapeOutputShape, err error) {
+	req, out := c.OutputService11TestCaseOperation1Request(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opOutputService11TestCaseOperation1 *aws.Operation
+
+type OutputService11TestShapeOutputService11TestCaseOperation1Input struct {
+	metadataOutputService11TestShapeOutputService11TestCaseOperation1Input `json:"-", xml:"-"`
+}
+
+type metadataOutputService11TestShapeOutputService11TestCaseOperation1Input struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService11TestShapeOutputShape struct {
+	Char *string `location:"header" locationName:"x-char" type:"character"`
+
+	Double *float64 `location:"header" locationName:"x-double" type:"double"`
+
+	FalseBool *bool `location:"header" locationName:"x-false-bool" type:"boolean"`
+
+	Float *float64 `location:"header" locationName:"x-float" type:"float"`
+
+	Integer *int64 `location:"header" locationName:"x-int" type:"integer"`
+
+	Long *int64 `location:"header" locationName:"x-long" type:"long"`
+
+	Str *string `location:"header" locationName:"x-str" type:"string"`
+
+	Timestamp *time.Time `location:"header" locationName:"x-timestamp" type:"timestamp" timestampFormat:"iso8601"`
+
+	TrueBool *bool `location:"header" locationName:"x-true-bool" type:"boolean"`
+
+	metadataOutputService11TestShapeOutputShape `json:"-", xml:"-"`
+}
+
+type metadataOutputService11TestShapeOutputShape 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><Timestamp>2015-01-25T08:00:00Z</Timestamp></OperationNameResponse>"))
+	req, out := svc.OutputService1TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+	req.HTTPResponse.Header.Set("ImaHeader", "test")
+	req.HTTPResponse.Header.Set("X-Foo", "abc")
+
+	// unmarshal response
+	restxml.UnmarshalMeta(req)
+	restxml.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, "test", *out.ImaHeader)
+	assert.Equal(t, "abc", *out.ImaHeaderLocation)
+	assert.Equal(t, 200, *out.Long)
+	assert.Equal(t, 123, *out.Num)
+	assert.Equal(t, "myname", *out.Str)
+	assert.Equal(t, time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.String())
+	assert.Equal(t, true, *out.TrueBool)
+
+}
+
+func TestOutputService1ProtocolTestScalarMembersCase2(t *testing.T) {
+	svc := NewOutputService1ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse><Str></Str><FooNum>123</FooNum><FalseBool>false</FalseBool><TrueBool>true</TrueBool><Float>1.2</Float><Double>1.3</Double><Long>200</Long><Char>a</Char><Timestamp>2015-01-25T08:00:00Z</Timestamp></OperationNameResponse>"))
+	req, out := svc.OutputService1TestCaseOperation2Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+	req.HTTPResponse.Header.Set("ImaHeader", "test")
+	req.HTTPResponse.Header.Set("X-Foo", "abc")
+
+	// unmarshal response
+	restxml.UnmarshalMeta(req)
+	restxml.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, "test", *out.ImaHeader)
+	assert.Equal(t, "abc", *out.ImaHeaderLocation)
+	assert.Equal(t, 200, *out.Long)
+	assert.Equal(t, 123, *out.Num)
+	assert.Equal(t, "", *out.Str)
+	assert.Equal(t, time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.String())
+	assert.Equal(t, true, *out.TrueBool)
+
+}
+
+func TestOutputService2ProtocolTestBlobCase1(t *testing.T) {
+	svc := NewOutputService2ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResult><Blob>dmFsdWU=</Blob></OperationNameResult>"))
+	req, out := svc.OutputService2TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	restxml.UnmarshalMeta(req)
+	restxml.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("<OperationNameResult><ListMember><member>abc</member><member>123</member></ListMember></OperationNameResult>"))
+	req, out := svc.OutputService3TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	restxml.UnmarshalMeta(req)
+	restxml.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("<OperationNameResult><ListMember><item>abc</item><item>123</item></ListMember></OperationNameResult>"))
+	req, out := svc.OutputService4TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	restxml.UnmarshalMeta(req)
+	restxml.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("<OperationNameResult><ListMember>abc</ListMember><ListMember>123</ListMember></OperationNameResult>"))
+	req, out := svc.OutputService5TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	restxml.UnmarshalMeta(req)
+	restxml.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("<OperationNameResult><Map><entry><key>qux</key><value><foo>bar</foo></value></entry><entry><key>baz</key><value><foo>bam</foo></value></entry></Map></OperationNameResult>"))
+	req, out := svc.OutputService6TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	restxml.UnmarshalMeta(req)
+	restxml.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("<OperationNameResult><Map><key>qux</key><value>bar</value></Map><Map><key>baz</key><value>bam</value></Map></OperationNameResult>"))
+	req, out := svc.OutputService7TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	restxml.UnmarshalMeta(req)
+	restxml.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("<OperationNameResult><Map><entry><foo>qux</foo><bar>bar</bar></entry><entry><foo>baz</foo><bar>bam</bar></entry></Map></OperationNameResult>"))
+	req, out := svc.OutputService8TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	restxml.UnmarshalMeta(req)
+	restxml.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 TestOutputService9ProtocolTestXMLPayloadCase1(t *testing.T) {
+	svc := NewOutputService9ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("<OperationNameResponse><Foo>abc</Foo></OperationNameResponse>"))
+	req, out := svc.OutputService9TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+	req.HTTPResponse.Header.Set("X-Foo", "baz")
+
+	// unmarshal response
+	restxml.UnmarshalMeta(req)
+	restxml.Unmarshal(req)
+	assert.NoError(t, req.Error)
+
+	// assert response
+	assert.NotNil(t, out) // ensure out variable is used
+	assert.Equal(t, "abc", *out.Data.Foo)
+	assert.Equal(t, "baz", *out.Header)
+
+}
+
+func TestOutputService10ProtocolTestStreamingPayloadCase1(t *testing.T) {
+	svc := NewOutputService10ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte("abc"))
+	req, out := svc.OutputService10TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+
+	// unmarshal response
+	restxml.UnmarshalMeta(req)
+	restxml.Unmarshal(req)
+	assert.NoError(t, req.Error)
+
+	// assert response
+	assert.NotNil(t, out) // ensure out variable is used
+	assert.Equal(t, "abc", string(out.Stream))
+
+}
+
+func TestOutputService11ProtocolTestScalarMembersInHeadersCase1(t *testing.T) {
+	svc := NewOutputService11ProtocolTest(nil)
+
+	buf := bytes.NewReader([]byte(""))
+	req, out := svc.OutputService11TestCaseOperation1Request(nil)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+	// set headers
+	req.HTTPResponse.Header.Set("x-char", "a")
+	req.HTTPResponse.Header.Set("x-double", "1.5")
+	req.HTTPResponse.Header.Set("x-false-bool", "false")
+	req.HTTPResponse.Header.Set("x-float", "1.5")
+	req.HTTPResponse.Header.Set("x-int", "1")
+	req.HTTPResponse.Header.Set("x-long", "100")
+	req.HTTPResponse.Header.Set("x-str", "string")
+	req.HTTPResponse.Header.Set("x-timestamp", "Sun, 25 Jan 2015 08:00:00 GMT")
+	req.HTTPResponse.Header.Set("x-true-bool", "true")
+
+	// unmarshal response
+	restxml.UnmarshalMeta(req)
+	restxml.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.5, *out.Double)
+	assert.Equal(t, false, *out.FalseBool)
+	assert.Equal(t, 1.5, *out.Float)
+	assert.Equal(t, 1, *out.Integer)
+	assert.Equal(t, 100, *out.Long)
+	assert.Equal(t, "string", *out.Str)
+	assert.Equal(t, time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.String())
+	assert.Equal(t, true, *out.TrueBool)
+
+}
+
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil/build.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil/build.go
new file mode 100644
index 000000000..af2ce630b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil/build.go
@@ -0,0 +1,262 @@
+package xmlutil
+
+import (
+	"encoding/base64"
+	"encoding/xml"
+	"fmt"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+func BuildXML(params interface{}, e *xml.Encoder) error {
+	b := xmlBuilder{encoder: e, namespaces: map[string]string{}}
+	root := NewXMLElement(xml.Name{})
+	if err := b.buildValue(reflect.ValueOf(params), root, ""); err != nil {
+		return err
+	}
+	for _, c := range root.Children {
+		for _, v := range c {
+			return StructToXML(e, v, false)
+		}
+	}
+	return nil
+}
+
+func elemOf(value reflect.Value) reflect.Value {
+	for value.Kind() == reflect.Ptr {
+		value = value.Elem()
+	}
+	return value
+}
+
+type xmlBuilder struct {
+	encoder    *xml.Encoder
+	namespaces map[string]string
+}
+
+func (b *xmlBuilder) buildValue(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
+	value = elemOf(value)
+	if !value.IsValid() { // no need to handle zero values
+		return nil
+	} else if tag.Get("location") != "" { // don't handle non-body location values
+		return nil
+	}
+
+	t := tag.Get("type")
+	if t == "" {
+		switch value.Kind() {
+		case reflect.Struct:
+			t = "structure"
+		case reflect.Slice:
+			t = "list"
+		case reflect.Map:
+			t = "map"
+		}
+	}
+
+	switch t {
+	case "structure":
+		if field, ok := value.Type().FieldByName("SDKShapeTraits"); ok {
+			tag = tag + reflect.StructTag(" ") + field.Tag
+		}
+		return b.buildStruct(value, current, tag)
+	case "list":
+		return b.buildList(value, current, tag)
+	case "map":
+		return b.buildMap(value, current, tag)
+	default:
+		return b.buildScalar(value, current, tag)
+	}
+}
+
+func (b *xmlBuilder) buildStruct(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
+	if !value.IsValid() {
+		return nil
+	}
+
+	fieldAdded := false
+
+	// unwrap payloads
+	if payload := tag.Get("payload"); payload != "" {
+		field, _ := value.Type().FieldByName(payload)
+		tag = field.Tag
+		value = elemOf(value.FieldByName(payload))
+
+		if !value.IsValid() {
+			return nil
+		}
+	}
+
+	child := NewXMLElement(xml.Name{Local: tag.Get("locationName")})
+
+	// there is an xmlNamespace associated with this struct
+	if prefix, uri := tag.Get("xmlPrefix"), tag.Get("xmlURI"); uri != "" {
+		ns := xml.Attr{
+			Name:  xml.Name{Local: "xmlns"},
+			Value: uri,
+		}
+		if prefix != "" {
+			b.namespaces[prefix] = uri // register the namespace
+			ns.Name.Local = "xmlns:" + prefix
+		}
+
+		child.Attr = append(child.Attr, ns)
+	}
+
+	t := value.Type()
+	for i := 0; i < value.NumField(); i++ {
+		if c := t.Field(i).Name[0:1]; strings.ToLower(c) == c {
+			continue // ignore unexported fields
+		}
+
+		member := elemOf(value.Field(i))
+		field := t.Field(i)
+		mTag := field.Tag
+
+		if mTag.Get("location") != "" { // skip non-body members
+			continue
+		}
+
+		memberName := mTag.Get("locationName")
+		if memberName == "" {
+			memberName = field.Name
+			mTag = reflect.StructTag(string(mTag) + ` locationName:"` + memberName + `"`)
+		}
+		if err := b.buildValue(member, child, mTag); err != nil {
+			return err
+		}
+
+		fieldAdded = true
+	}
+
+	if fieldAdded { // only append this child if we have one ore more valid members
+		current.AddChild(child)
+	}
+
+	return nil
+}
+
+func (b *xmlBuilder) buildList(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
+	if value.IsNil() { // don't build omitted lists
+		return nil
+	}
+
+	// check for unflattened list member
+	flattened := tag.Get("flattened") != ""
+
+	xname := xml.Name{Local: tag.Get("locationName")}
+	if flattened {
+		for i := 0; i < value.Len(); i++ {
+			child := NewXMLElement(xname)
+			current.AddChild(child)
+			if err := b.buildValue(value.Index(i), child, ""); err != nil {
+				return err
+			}
+		}
+	} else {
+		list := NewXMLElement(xname)
+		current.AddChild(list)
+
+		for i := 0; i < value.Len(); i++ {
+			iname := tag.Get("locationNameList")
+			if iname == "" {
+				iname = "member"
+			}
+
+			child := NewXMLElement(xml.Name{Local: iname})
+			list.AddChild(child)
+			if err := b.buildValue(value.Index(i), child, ""); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (b *xmlBuilder) buildMap(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
+	if value.IsNil() { // don't build omitted maps
+		return nil
+	}
+
+	maproot := NewXMLElement(xml.Name{Local: tag.Get("locationName")})
+	current.AddChild(maproot)
+	current = maproot
+
+	kname, vname := "key", "value"
+	if n := tag.Get("locationNameKey"); n != "" {
+		kname = n
+	}
+	if n := tag.Get("locationNameValue"); n != "" {
+		vname = n
+	}
+
+	// sorting is not required for compliance, but it makes testing easier
+	keys := make([]string, value.Len())
+	for i, k := range value.MapKeys() {
+		keys[i] = k.String()
+	}
+	sort.Strings(keys)
+
+	for _, k := range keys {
+		v := value.MapIndex(reflect.ValueOf(k))
+		fmt.Println(k, v.Interface())
+
+		mapcur := current
+		if tag.Get("flattened") == "" { // add "entry" tag to non-flat maps
+			child := NewXMLElement(xml.Name{Local: "entry"})
+			mapcur.AddChild(child)
+			mapcur = child
+		}
+
+		kchild := NewXMLElement(xml.Name{Local: kname})
+		kchild.Text = k
+		vchild := NewXMLElement(xml.Name{Local: vname})
+		mapcur.AddChild(kchild)
+		mapcur.AddChild(vchild)
+
+		if err := b.buildValue(v, vchild, ""); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (b *xmlBuilder) buildScalar(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
+	var str string
+	switch converted := value.Interface().(type) {
+	case string:
+		str = converted
+	case []byte:
+		str = base64.StdEncoding.EncodeToString(converted)
+	case bool:
+		str = strconv.FormatBool(converted)
+	case int64:
+		str = strconv.FormatInt(converted, 10)
+	case int:
+		str = strconv.Itoa(converted)
+	case float64:
+		str = strconv.FormatFloat(converted, 'f', -1, 64)
+	case float32:
+		str = strconv.FormatFloat(float64(converted), 'f', -1, 32)
+	case time.Time:
+		const ISO8601UTC = "2006-01-02T15:04:05Z"
+		str = converted.UTC().Format(ISO8601UTC)
+	default:
+		return fmt.Errorf("unsupported value for param %s: %v (%s)",
+			tag.Get("locationName"), value.Interface(), value.Type().Name())
+	}
+
+	xname := xml.Name{Local: tag.Get("locationName")}
+	if tag.Get("xmlAttribute") != "" { // put into current node's attribute list
+		attr := xml.Attr{Name: xname, Value: str}
+		current.Attr = append(current.Attr, attr)
+	} else { // regular text node
+		current.AddChild(&XMLNode{Name: xname, Text: str})
+	}
+	return nil
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil/unmarshal.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil/unmarshal.go
new file mode 100644
index 000000000..d5b7d71be
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil/unmarshal.go
@@ -0,0 +1,251 @@
+package xmlutil
+
+import (
+	"encoding/base64"
+	"encoding/xml"
+	"fmt"
+	"io"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+)
+
+func UnmarshalXML(v interface{}, d *xml.Decoder, wrapper string) error {
+	n, _ := XMLToStruct(d, nil)
+	if n.Children != nil {
+		for _, root := range n.Children {
+			for _, c := range root {
+				if wrappedChild, ok := c.Children[wrapper]; ok {
+					c = wrappedChild[0] // pull out wrapped element
+				}
+
+				err := parse(reflect.ValueOf(v), c, "")
+				if err != nil {
+					if err == io.EOF {
+						return nil
+					}
+					return err
+				}
+			}
+		}
+		return nil
+	}
+	return nil
+}
+
+func parse(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
+	rtype := r.Type()
+	if rtype.Kind() == reflect.Ptr {
+		rtype = rtype.Elem() // check kind of actual element type
+	}
+
+	t := tag.Get("type")
+	if t == "" {
+		switch rtype.Kind() {
+		case reflect.Struct:
+			t = "structure"
+		case reflect.Slice:
+			t = "list"
+		case reflect.Map:
+			t = "map"
+		}
+	}
+
+	switch t {
+	case "structure":
+		if field, ok := rtype.FieldByName("SDKShapeTraits"); ok {
+			tag = field.Tag
+		}
+		return parseStruct(r, node, tag)
+	case "list":
+		return parseList(r, node, tag)
+	case "map":
+		return parseMap(r, node, tag)
+	default:
+		return parseScalar(r, node, tag)
+	}
+}
+
+func parseStruct(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
+	t := r.Type()
+	if r.Kind() == reflect.Ptr {
+		if r.IsNil() { // create the structure if it's nil
+			s := reflect.New(r.Type().Elem())
+			r.Set(s)
+			r = s
+		}
+
+		r = r.Elem()
+		t = t.Elem()
+	}
+
+	// unwrap any payloads
+	if payload := tag.Get("payload"); payload != "" {
+		field, _ := t.FieldByName(payload)
+		return parseStruct(r.FieldByName(payload), node, field.Tag)
+	}
+
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+		if c := field.Name[0:1]; strings.ToLower(c) == c {
+			continue // ignore unexported fields
+		}
+
+		// figure out what this field is called
+		name := field.Name
+		if field.Tag.Get("flattened") != "" && field.Tag.Get("locationNameList") != "" {
+			name = field.Tag.Get("locationNameList")
+		} else if locName := field.Tag.Get("locationName"); locName != "" {
+			name = locName
+		}
+
+		// try to find the field by name in elements
+		elems := node.Children[name]
+
+		if elems == nil { // try to find the field in attributes
+			for _, a := range node.Attr {
+				if name == a.Name.Local {
+					// turn this into a text node for de-serializing
+					elems = []*XMLNode{&XMLNode{Text: a.Value}}
+				}
+			}
+		}
+
+		member := r.FieldByName(field.Name)
+		for _, elem := range elems {
+			err := parse(member, elem, field.Tag)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func parseList(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
+	t := r.Type()
+
+	if tag.Get("flattened") == "" { // look at all item entries
+		mname := "member"
+		if name := tag.Get("locationNameList"); name != "" {
+			mname = name
+		}
+
+		if Children, ok := node.Children[mname]; ok {
+			if r.IsNil() {
+				r.Set(reflect.MakeSlice(t, len(Children), len(Children)))
+			}
+
+			for i, c := range Children {
+				err := parse(r.Index(i), c, "")
+				if err != nil {
+					return err
+				}
+			}
+		}
+	} else { // flattened list means this is a single element
+		if r.IsNil() {
+			r.Set(reflect.MakeSlice(t, 0, 0))
+		}
+
+		childR := reflect.Zero(t.Elem())
+		r.Set(reflect.Append(r, childR))
+		err := parse(r.Index(r.Len()-1), node, "")
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func parseMap(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
+	t := r.Type()
+	if r.Kind() == reflect.Ptr {
+		t = t.Elem()
+		if r.IsNil() {
+			r.Set(reflect.New(t))
+			r.Elem().Set(reflect.MakeMap(t))
+		}
+
+		r = r.Elem()
+	}
+
+	if tag.Get("flattened") == "" { // look at all child entries
+		for _, entry := range node.Children["entry"] {
+			parseMapEntry(r, entry, tag)
+		}
+	} else { // this element is itself an entry
+		parseMapEntry(r, node, tag)
+	}
+
+	return nil
+}
+
+func parseMapEntry(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
+	kname, vname := "key", "value"
+	if n := tag.Get("locationNameKey"); n != "" {
+		kname = n
+	}
+	if n := tag.Get("locationNameValue"); n != "" {
+		vname = n
+	}
+
+	keys, ok := node.Children[kname]
+	values := node.Children[vname]
+	if ok {
+		for i, key := range keys {
+			keyR := reflect.ValueOf(key.Text)
+			value := values[i]
+			valueR := reflect.New(r.Type().Elem()).Elem()
+
+			parse(valueR, value, "")
+			r.SetMapIndex(keyR, valueR)
+		}
+	}
+	return nil
+}
+
+func parseScalar(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
+	switch r.Interface().(type) {
+	case *string:
+		r.Set(reflect.ValueOf(&node.Text))
+		return nil
+	case []byte:
+		b, err := base64.StdEncoding.DecodeString(node.Text)
+		if err != nil {
+			return err
+		}
+		r.Set(reflect.ValueOf(b))
+	case *bool:
+		v, err := strconv.ParseBool(node.Text)
+		if err != nil {
+			return err
+		}
+		r.Set(reflect.ValueOf(&v))
+	case *int64:
+		v, err := strconv.ParseInt(node.Text, 10, 64)
+		if err != nil {
+			return err
+		}
+		r.Set(reflect.ValueOf(&v))
+	case *float64:
+		v, err := strconv.ParseFloat(node.Text, 64)
+		if err != nil {
+			return err
+		}
+		r.Set(reflect.ValueOf(&v))
+	case *time.Time:
+		const ISO8601UTC = "2006-01-02T15:04:05Z"
+		t, err := time.Parse(ISO8601UTC, node.Text)
+		if err != nil {
+			return err
+		} else {
+			r.Set(reflect.ValueOf(&t))
+		}
+	default:
+		return fmt.Errorf("unsupported value: %v (%s)", r.Interface(), r.Type())
+	}
+	return nil
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil/xml_to_struct.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil/xml_to_struct.go
new file mode 100644
index 000000000..b6a1cfadd
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil/xml_to_struct.go
@@ -0,0 +1,100 @@
+package xmlutil
+
+import (
+	"encoding/xml"
+	"io"
+	"sort"
+)
+
+type XMLNode struct {
+	Name     xml.Name              `json:",omitempty"`
+	Children map[string][]*XMLNode `json:",omitempty"`
+	Text     string                `json:",omitempty"`
+	Attr     []xml.Attr            `json:",omitempty"`
+}
+
+func NewXMLElement(name xml.Name) *XMLNode {
+	return &XMLNode{
+		Name:     name,
+		Children: map[string][]*XMLNode{},
+		Attr:     []xml.Attr{},
+	}
+}
+
+func (n *XMLNode) AddChild(child *XMLNode) {
+	if _, ok := n.Children[child.Name.Local]; !ok {
+		n.Children[child.Name.Local] = []*XMLNode{}
+	}
+	n.Children[child.Name.Local] = append(n.Children[child.Name.Local], child)
+}
+
+func XMLToStruct(d *xml.Decoder, s *xml.StartElement) (*XMLNode, error) {
+	out := &XMLNode{}
+	for {
+		tok, err := d.Token()
+		if tok == nil || err == io.EOF {
+			break
+		}
+		if err != nil {
+			return out, err
+		}
+
+		switch typed := tok.(type) {
+		case xml.CharData:
+			out.Text = string(typed.Copy())
+		case xml.StartElement:
+			el := typed.Copy()
+			out.Attr = el.Attr
+			if out.Children == nil {
+				out.Children = map[string][]*XMLNode{}
+			}
+
+			name := typed.Name.Local
+			slice := out.Children[name]
+			if slice == nil {
+				slice = []*XMLNode{}
+			}
+			node, e := XMLToStruct(d, &el)
+			if e != nil {
+				return out, e
+			}
+			node.Name = typed.Name
+			slice = append(slice, node)
+			out.Children[name] = slice
+		case xml.EndElement:
+			if s != nil && s.Name.Local == typed.Name.Local { // matching end token
+				return out, nil
+			}
+		}
+	}
+	return out, nil
+}
+
+func StructToXML(e *xml.Encoder, node *XMLNode, sorted bool) error {
+	e.EncodeToken(xml.StartElement{Name: node.Name, Attr: node.Attr})
+
+	if node.Text != "" {
+		e.EncodeToken(xml.CharData([]byte(node.Text)))
+	} else if sorted {
+		sortedNames := []string{}
+		for k, _ := range node.Children {
+			sortedNames = append(sortedNames, k)
+		}
+		sort.Strings(sortedNames)
+
+		for _, k := range sortedNames {
+			for _, v := range node.Children[k] {
+				StructToXML(e, v, sorted)
+			}
+		}
+	} else {
+		for _, c := range node.Children {
+			for _, v := range c {
+				StructToXML(e, v, sorted)
+			}
+		}
+	}
+
+	e.EncodeToken(xml.EndElement{Name: node.Name})
+	return e.Flush()
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/signer/v4/v4.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/signer/v4/v4.go
new file mode 100644
index 000000000..d331475f4
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/signer/v4/v4.go
@@ -0,0 +1,296 @@
+package v4
+
+import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/awslabs/aws-sdk-go/aws"
+)
+
+const (
+	authHeaderPrefix = "AWS4-HMAC-SHA256"
+	timeFormat       = "20060102T150405Z"
+	shortTimeFormat  = "20060102"
+)
+
+var ignoredHeaders = map[string]bool{
+	"Authorization":  true,
+	"Content-Type":   true,
+	"Content-Length": true,
+	"User-Agent":     true,
+}
+
+type signer struct {
+	Request         *http.Request
+	Time            time.Time
+	ExpireTime      time.Duration
+	ServiceName     string
+	Region          string
+	AccessKeyID     string
+	SecretAccessKey string
+	SessionToken    string
+	Query           url.Values
+	Body            io.ReadSeeker
+	Debug           uint
+	Logger          io.Writer
+
+	isPresign          bool
+	formattedTime      string
+	formattedShortTime string
+
+	signedHeaders    string
+	canonicalHeaders string
+	canonicalString  string
+	credentialString string
+	stringToSign     string
+	signature        string
+	authorization    string
+}
+
+// Sign requests with signature version 4.
+func Sign(req *aws.Request) {
+	creds, err := req.Service.Config.Credentials.Credentials()
+	if err != nil {
+		req.Error = err
+		return
+	}
+
+	s := signer{
+		Request:         req.HTTPRequest,
+		Time:            req.Time,
+		ExpireTime:      req.ExpireTime,
+		Query:           req.HTTPRequest.URL.Query(),
+		Body:            req.Body,
+		ServiceName:     req.Service.ServiceName,
+		Region:          req.Service.Config.Region,
+		AccessKeyID:     creds.AccessKeyID,
+		SecretAccessKey: creds.SecretAccessKey,
+		SessionToken:    creds.SessionToken,
+		Debug:           req.Service.Config.LogLevel,
+		Logger:          req.Service.Config.Logger,
+	}
+	s.sign()
+	return
+}
+
+func (v4 *signer) sign() {
+	if v4.ExpireTime != 0 {
+		v4.isPresign = true
+	}
+
+	if v4.isPresign {
+		v4.Query.Set("X-Amz-Algorithm", authHeaderPrefix)
+		if v4.SessionToken != "" {
+			v4.Query.Set("X-Amz-Security-Token", v4.SessionToken)
+		} else {
+			v4.Query.Del("X-Amz-Security-Token")
+		}
+	} else if v4.SessionToken != "" {
+		v4.Request.Header.Set("X-Amz-Security-Token", v4.SessionToken)
+	}
+
+	v4.build()
+
+	if v4.Debug > 0 {
+		out := v4.Logger
+		fmt.Fprintf(out, "---[ CANONICAL STRING  ]-----------------------------\n")
+		fmt.Fprintln(out, v4.canonicalString)
+		fmt.Fprintf(out, "---[ STRING TO SIGN ]--------------------------------\n")
+		fmt.Fprintln(out, v4.stringToSign)
+		fmt.Fprintf(out, "---[ SIGNED URL ]--------------------------------\n")
+		fmt.Fprintln(out, v4.Request.URL)
+		fmt.Fprintf(out, "-----------------------------------------------------\n")
+	}
+}
+
+func (v4 *signer) build() {
+	v4.buildTime()             // no depends
+	v4.buildCredentialString() // no depends
+	if v4.isPresign {
+		v4.buildQuery() // no depends
+	}
+	v4.buildCanonicalHeaders() // depends on cred string
+	v4.buildCanonicalString()  // depends on canon headers / signed headers
+	v4.buildStringToSign()     // depends on canon string
+	v4.buildSignature()        // depends on string to sign
+
+	if v4.isPresign {
+		v4.Request.URL.RawQuery += "&X-Amz-Signature=" + v4.signature
+	} else {
+		parts := []string{
+			authHeaderPrefix + " Credential=" + v4.AccessKeyID + "/" + v4.credentialString,
+			"SignedHeaders=" + v4.signedHeaders,
+			"Signature=" + v4.signature,
+		}
+		v4.Request.Header.Set("Authorization", strings.Join(parts, ", "))
+	}
+}
+
+func (v4 *signer) buildTime() {
+	v4.formattedTime = v4.Time.UTC().Format(timeFormat)
+	v4.formattedShortTime = v4.Time.UTC().Format(shortTimeFormat)
+
+	if v4.isPresign {
+		duration := int64(v4.ExpireTime / time.Second)
+		v4.Query.Set("X-Amz-Date", v4.formattedTime)
+		v4.Query.Set("X-Amz-Expires", strconv.FormatInt(duration, 10))
+	} else {
+		v4.Request.Header.Set("X-Amz-Date", v4.formattedTime)
+	}
+}
+
+func (v4 *signer) buildCredentialString() {
+	v4.credentialString = strings.Join([]string{
+		v4.formattedShortTime,
+		v4.Region,
+		v4.ServiceName,
+		"aws4_request",
+	}, "/")
+
+	if v4.isPresign {
+		v4.Query.Set("X-Amz-Credential", v4.AccessKeyID+"/"+v4.credentialString)
+	}
+}
+
+func (v4 *signer) buildQuery() {
+	for k, h := range v4.Request.Header {
+		if strings.HasPrefix(http.CanonicalHeaderKey(k), "X-Amz-") {
+			continue // never hoist x-amz-* headers, they must be signed
+		}
+		if _, ok := ignoredHeaders[http.CanonicalHeaderKey(k)]; ok {
+			continue // never hoist ignored headers
+		}
+
+		v4.Request.Header.Del(k)
+		v4.Query.Del(k)
+		for _, v := range h {
+			v4.Query.Add(k, v)
+		}
+	}
+}
+
+func (v4 *signer) buildCanonicalHeaders() {
+	headers := make([]string, 0)
+	headers = append(headers, "host")
+	for k, _ := range v4.Request.Header {
+		if _, ok := ignoredHeaders[http.CanonicalHeaderKey(k)]; ok {
+			continue // ignored header
+		}
+		headers = append(headers, strings.ToLower(k))
+	}
+	sort.Strings(headers)
+
+	v4.signedHeaders = strings.Join(headers, ";")
+
+	if v4.isPresign {
+		v4.Query.Set("X-Amz-SignedHeaders", v4.signedHeaders)
+	}
+
+	headerValues := make([]string, len(headers))
+	for i, k := range headers {
+		if k == "host" {
+			headerValues[i] = "host:" + v4.Request.URL.Host
+		} else {
+			headerValues[i] = k + ":" +
+				strings.Join(v4.Request.Header[http.CanonicalHeaderKey(k)], ",")
+		}
+	}
+
+	v4.canonicalHeaders = strings.Join(headerValues, "\n")
+}
+
+func (v4 *signer) buildCanonicalString() {
+	v4.Request.URL.RawQuery = v4.Query.Encode()
+	uri := v4.Request.URL.Opaque
+	if uri != "" {
+		uri = "/" + strings.Join(strings.Split(uri, "/")[3:], "/")
+	} else {
+		uri = v4.Request.URL.Path
+	}
+	if uri == "" {
+		uri = "/"
+	}
+
+	v4.canonicalString = strings.Join([]string{
+		v4.Request.Method,
+		uri,
+		v4.Request.URL.RawQuery,
+		v4.canonicalHeaders + "\n",
+		v4.signedHeaders,
+		v4.bodyDigest(),
+	}, "\n")
+}
+
+func (v4 *signer) buildStringToSign() {
+	v4.stringToSign = strings.Join([]string{
+		authHeaderPrefix,
+		v4.formattedTime,
+		v4.credentialString,
+		hex.EncodeToString(makeSha256([]byte(v4.canonicalString))),
+	}, "\n")
+}
+
+func (v4 *signer) buildSignature() {
+	secret := v4.SecretAccessKey
+	date := makeHmac([]byte("AWS4"+secret), []byte(v4.formattedShortTime))
+	region := makeHmac(date, []byte(v4.Region))
+	service := makeHmac(region, []byte(v4.ServiceName))
+	credentials := makeHmac(service, []byte("aws4_request"))
+	signature := makeHmac(credentials, []byte(v4.stringToSign))
+	v4.signature = hex.EncodeToString(signature)
+}
+
+func (v4 *signer) bodyDigest() string {
+	hash := v4.Request.Header.Get("X-Amz-Content-Sha256")
+	if hash == "" {
+		if v4.isPresign && v4.ServiceName == "s3" {
+			hash = "UNSIGNED-PAYLOAD"
+		} else if v4.Body == nil {
+			hash = hex.EncodeToString(makeSha256([]byte{}))
+		} else {
+			hash = hex.EncodeToString(makeSha256Reader(v4.Body))
+		}
+		v4.Request.Header.Add("X-Amz-Content-Sha256", hash)
+	}
+	return hash
+}
+
+func makeHmac(key []byte, data []byte) []byte {
+	hash := hmac.New(sha256.New, key)
+	hash.Write(data)
+	return hash.Sum(nil)
+}
+
+func makeSha256(data []byte) []byte {
+	hash := sha256.New()
+	hash.Write(data)
+	return hash.Sum(nil)
+}
+
+func makeSha256Reader(reader io.ReadSeeker) []byte {
+	packet := make([]byte, 4096)
+	hash := sha256.New()
+
+	reader.Seek(0, 0)
+	for {
+		n, err := reader.Read(packet)
+		if n > 0 {
+			hash.Write(packet[0:n])
+		}
+		if err == io.EOF || n == 0 {
+			break
+		}
+	}
+	reader.Seek(0, 0)
+
+	return hash.Sum(nil)
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/signer/v4/v4_test.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/signer/v4/v4_test.go
new file mode 100644
index 000000000..fb15c3949
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/signer/v4/v4_test.go
@@ -0,0 +1,89 @@
+package v4
+
+import (
+	"net/http"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func buildSigner(serviceName string, region string, signTime time.Time, expireTime time.Duration, body string) signer {
+	endpoint := "https://" + serviceName + "." + region + ".amazonaws.com"
+	reader := strings.NewReader(body)
+	req, _ := http.NewRequest("POST", endpoint, reader)
+	req.URL.Opaque = "//example.org/bucket/key-._~,!@#$%^&*()"
+	req.Header.Add("X-Amz-Target", "prefix.Operation")
+	req.Header.Add("Content-Type", "application/x-amz-json-1.0")
+	req.Header.Add("Content-Length", string(len(body)))
+	req.Header.Add("X-Amz-Meta-Other-Header", "some-value=!@#$%^&* ()")
+
+	return signer{
+		Request:         req,
+		Time:            signTime,
+		ExpireTime:      expireTime,
+		Query:           req.URL.Query(),
+		Body:            reader,
+		ServiceName:     serviceName,
+		Region:          region,
+		AccessKeyID:     "AKID",
+		SecretAccessKey: "SECRET",
+		SessionToken:    "SESSION",
+	}
+}
+
+func removeWS(text string) string {
+	text = strings.Replace(text, " ", "", -1)
+	text = strings.Replace(text, "\n", "", -1)
+	text = strings.Replace(text, "\t", "", -1)
+	return text
+}
+
+func assertEqual(t *testing.T, expected, given string) {
+	if removeWS(expected) != removeWS(given) {
+		t.Errorf("\nExpected: %s\nGiven:    %s", expected, given)
+	}
+}
+
+func TestPresignRequest(t *testing.T) {
+	signer := buildSigner("dynamodb", "us-east-1", time.Unix(0, 0), 300*time.Second, "{}")
+	signer.sign()
+
+	expectedDate := "19700101T000000Z"
+	expectedHeaders := "host;x-amz-meta-other-header;x-amz-target"
+	expectedSig := "41c18d68f9191079dfeead4e3f034328f89d86c79f8e9d51dd48bb70eaf623fc"
+	expectedCred := "AKID/19700101/us-east-1/dynamodb/aws4_request"
+
+	q := signer.Request.URL.Query()
+	assert.Equal(t, expectedSig, q.Get("X-Amz-Signature"))
+	assert.Equal(t, expectedCred, q.Get("X-Amz-Credential"))
+	assert.Equal(t, expectedHeaders, q.Get("X-Amz-SignedHeaders"))
+	assert.Equal(t, expectedDate, q.Get("X-Amz-Date"))
+}
+
+func TestSignRequest(t *testing.T) {
+	signer := buildSigner("dynamodb", "us-east-1", time.Unix(0, 0), 0, "{}")
+	signer.sign()
+
+	expectedDate := "19700101T000000Z"
+	expectedSig := "AWS4-HMAC-SHA256 Credential=AKID/19700101/us-east-1/dynamodb/aws4_request, SignedHeaders=host;x-amz-date;x-amz-meta-other-header;x-amz-security-token;x-amz-target, Signature=0196959cabd964bd10c05217b40ed151882dd394190438bab0c658dafdbff7a1"
+
+	q := signer.Request.Header
+	assert.Equal(t, expectedSig, q.Get("Authorization"))
+	assert.Equal(t, expectedDate, q.Get("X-Amz-Date"))
+}
+
+func BenchmarkPresignRequest(b *testing.B) {
+	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 300*time.Second, "{}")
+	for i := 0; i < b.N; i++ {
+		signer.sign()
+	}
+}
+
+func BenchmarkSignRequest(b *testing.B) {
+	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "{}")
+	for i := 0; i < b.N; i++ {
+		signer.sign()
+	}
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/route53/api.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/route53/api.go
new file mode 100644
index 000000000..8aea62dc6
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/route53/api.go
@@ -0,0 +1,2738 @@
+// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
+
+// Package route53 provides a client for Amazon Route 53.
+package route53
+
+import (
+	"time"
+
+	"github.com/awslabs/aws-sdk-go/aws"
+)
+
+// AssociateVPCWithHostedZoneRequest generates a request for the AssociateVPCWithHostedZone operation.
+func (c *Route53) AssociateVPCWithHostedZoneRequest(input *AssociateVPCWithHostedZoneInput) (req *aws.Request, output *AssociateVPCWithHostedZoneOutput) {
+	if opAssociateVPCWithHostedZone == nil {
+		opAssociateVPCWithHostedZone = &aws.Operation{
+			Name:       "AssociateVPCWithHostedZone",
+			HTTPMethod: "POST",
+			HTTPPath:   "/2013-04-01/hostedzone/{Id}/associatevpc",
+		}
+	}
+
+	req = c.newRequest(opAssociateVPCWithHostedZone, input, output)
+	output = &AssociateVPCWithHostedZoneOutput{}
+	req.Data = output
+	return
+}
+
+// This action associates a VPC with an hosted zone.
+//
+//  To associate a VPC with an hosted zone, send a POST request to the 2013-04-01/hostedzone/hosted
+// zone ID/associatevpc resource. The request body must include an XML document
+// with a AssociateVPCWithHostedZoneRequest element. The response returns the
+// AssociateVPCWithHostedZoneResponse element that contains ChangeInfo for you
+// to track the progress of the AssociateVPCWithHostedZoneRequest you made.
+// See GetChange operation for how to track the progress of your change.
+func (c *Route53) AssociateVPCWithHostedZone(input *AssociateVPCWithHostedZoneInput) (output *AssociateVPCWithHostedZoneOutput, err error) {
+	req, out := c.AssociateVPCWithHostedZoneRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opAssociateVPCWithHostedZone *aws.Operation
+
+// ChangeResourceRecordSetsRequest generates a request for the ChangeResourceRecordSets operation.
+func (c *Route53) ChangeResourceRecordSetsRequest(input *ChangeResourceRecordSetsInput) (req *aws.Request, output *ChangeResourceRecordSetsOutput) {
+	if opChangeResourceRecordSets == nil {
+		opChangeResourceRecordSets = &aws.Operation{
+			Name:       "ChangeResourceRecordSets",
+			HTTPMethod: "POST",
+			HTTPPath:   "/2013-04-01/hostedzone/{Id}/rrset/",
+		}
+	}
+
+	req = c.newRequest(opChangeResourceRecordSets, input, output)
+	output = &ChangeResourceRecordSetsOutput{}
+	req.Data = output
+	return
+}
+
+// Use this action to create or change your authoritative DNS information. To
+// use this action, send a POST request to the 2013-04-01/hostedzone/hosted
+// Zone ID/rrset resource. The request body must include an XML document with
+// a ChangeResourceRecordSetsRequest element.
+//
+// Changes are a list of change items and are considered transactional. For
+// more information on transactional changes, also known as change batches,
+// see Creating, Changing, and Deleting Resource Record Sets Using the Route
+// 53 API (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/RRSchanges.html#RRSchanges_API)
+// in the Amazon Route 53 Developer Guide.
+//
+// Due to the nature of transactional changes, you cannot delete the same resource
+// record set more than once in a single change batch. If you attempt to delete
+// the same change batch more than once, Route 53 returns an InvalidChangeBatch
+// error. In response to a ChangeResourceRecordSets request, your DNS data is
+// changed on all Route 53 DNS servers. Initially, the status of a change is
+// PENDING. This means the change has not yet propagated to all the authoritative
+// Route 53 DNS servers. When the change is propagated to all hosts, the change
+// returns a status of INSYNC.
+//
+// Note the following limitations on a ChangeResourceRecordSets request:
+//
+// - A request cannot contain more than 100 Change elements.
+//
+// - A request cannot contain more than 1000 ResourceRecord elements.
+//
+// The sum of the number of characters (including spaces) in all Value elements
+// in a request cannot exceed 32,000 characters.
+func (c *Route53) ChangeResourceRecordSets(input *ChangeResourceRecordSetsInput) (output *ChangeResourceRecordSetsOutput, err error) {
+	req, out := c.ChangeResourceRecordSetsRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opChangeResourceRecordSets *aws.Operation
+
+// ChangeTagsForResourceRequest generates a request for the ChangeTagsForResource operation.
+func (c *Route53) ChangeTagsForResourceRequest(input *ChangeTagsForResourceInput) (req *aws.Request, output *ChangeTagsForResourceOutput) {
+	if opChangeTagsForResource == nil {
+		opChangeTagsForResource = &aws.Operation{
+			Name:       "ChangeTagsForResource",
+			HTTPMethod: "POST",
+			HTTPPath:   "/2013-04-01/tags/{ResourceType}/{ResourceId}",
+		}
+	}
+
+	req = c.newRequest(opChangeTagsForResource, input, output)
+	output = &ChangeTagsForResourceOutput{}
+	req.Data = output
+	return
+}
+
+func (c *Route53) ChangeTagsForResource(input *ChangeTagsForResourceInput) (output *ChangeTagsForResourceOutput, err error) {
+	req, out := c.ChangeTagsForResourceRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opChangeTagsForResource *aws.Operation
+
+// CreateHealthCheckRequest generates a request for the CreateHealthCheck operation.
+func (c *Route53) CreateHealthCheckRequest(input *CreateHealthCheckInput) (req *aws.Request, output *CreateHealthCheckOutput) {
+	if opCreateHealthCheck == nil {
+		opCreateHealthCheck = &aws.Operation{
+			Name:       "CreateHealthCheck",
+			HTTPMethod: "POST",
+			HTTPPath:   "/2013-04-01/healthcheck",
+		}
+	}
+
+	req = c.newRequest(opCreateHealthCheck, input, output)
+	output = &CreateHealthCheckOutput{}
+	req.Data = output
+	return
+}
+
+// This action creates a new health check.
+//
+//  To create a new health check, send a POST request to the 2013-04-01/healthcheck
+// resource. The request body must include an XML document with a CreateHealthCheckRequest
+// element. The response returns the CreateHealthCheckResponse element that
+// contains metadata about the health check.
+func (c *Route53) CreateHealthCheck(input *CreateHealthCheckInput) (output *CreateHealthCheckOutput, err error) {
+	req, out := c.CreateHealthCheckRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opCreateHealthCheck *aws.Operation
+
+// CreateHostedZoneRequest generates a request for the CreateHostedZone operation.
+func (c *Route53) CreateHostedZoneRequest(input *CreateHostedZoneInput) (req *aws.Request, output *CreateHostedZoneOutput) {
+	if opCreateHostedZone == nil {
+		opCreateHostedZone = &aws.Operation{
+			Name:       "CreateHostedZone",
+			HTTPMethod: "POST",
+			HTTPPath:   "/2013-04-01/hostedzone",
+		}
+	}
+
+	req = c.newRequest(opCreateHostedZone, input, output)
+	output = &CreateHostedZoneOutput{}
+	req.Data = output
+	return
+}
+
+// This action creates a new hosted zone.
+//
+// To create a new hosted zone, send a POST request to the 2013-04-01/hostedzone
+// resource. The request body must include an XML document with a CreateHostedZoneRequest
+// element. The response returns the CreateHostedZoneResponse element that contains
+// metadata about the hosted zone.
+//
+// Route 53 automatically creates a default SOA record and four NS records
+// for the zone. The NS records in the hosted zone are the name servers you
+// give your registrar to delegate your domain to. For more information about
+// SOA and NS records, see NS and SOA Records that Route 53 Creates for a Hosted
+// Zone (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/SOA-NSrecords.html)
+// in the Amazon Route 53 Developer Guide.
+//
+// When you create a zone, its initial status is PENDING. This means that it
+// is not yet available on all DNS servers. The status of the zone changes to
+// INSYNC when the NS and SOA records are available on all Route 53 DNS servers.
+//
+// When trying to create a hosted zone using a reusable delegation set, you
+// could specify an optional DelegationSetId, and Route53 would assign those
+// 4 NS records for the zone, instead of alloting a new one.
+func (c *Route53) CreateHostedZone(input *CreateHostedZoneInput) (output *CreateHostedZoneOutput, err error) {
+	req, out := c.CreateHostedZoneRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opCreateHostedZone *aws.Operation
+
+// CreateReusableDelegationSetRequest generates a request for the CreateReusableDelegationSet operation.
+func (c *Route53) CreateReusableDelegationSetRequest(input *CreateReusableDelegationSetInput) (req *aws.Request, output *CreateReusableDelegationSetOutput) {
+	if opCreateReusableDelegationSet == nil {
+		opCreateReusableDelegationSet = &aws.Operation{
+			Name:       "CreateReusableDelegationSet",
+			HTTPMethod: "POST",
+			HTTPPath:   "/2013-04-01/delegationset",
+		}
+	}
+
+	req = c.newRequest(opCreateReusableDelegationSet, input, output)
+	output = &CreateReusableDelegationSetOutput{}
+	req.Data = output
+	return
+}
+
+// This action creates a reusable delegationSet.
+//
+//  To create a new reusable delegationSet, send a POST request to the 2013-04-01/delegationset
+// resource. The request body must include an XML document with a CreateReusableDelegationSetRequest
+// element. The response returns the CreateReusableDelegationSetResponse element
+// that contains metadata about the delegationSet.
+//
+//  If the optional parameter HostedZoneId is specified, it marks the delegationSet
+// associated with that particular hosted zone as reusable.
+func (c *Route53) CreateReusableDelegationSet(input *CreateReusableDelegationSetInput) (output *CreateReusableDelegationSetOutput, err error) {
+	req, out := c.CreateReusableDelegationSetRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opCreateReusableDelegationSet *aws.Operation
+
+// DeleteHealthCheckRequest generates a request for the DeleteHealthCheck operation.
+func (c *Route53) DeleteHealthCheckRequest(input *DeleteHealthCheckInput) (req *aws.Request, output *DeleteHealthCheckOutput) {
+	if opDeleteHealthCheck == nil {
+		opDeleteHealthCheck = &aws.Operation{
+			Name:       "DeleteHealthCheck",
+			HTTPMethod: "DELETE",
+			HTTPPath:   "/2013-04-01/healthcheck/{HealthCheckId}",
+		}
+	}
+
+	req = c.newRequest(opDeleteHealthCheck, input, output)
+	output = &DeleteHealthCheckOutput{}
+	req.Data = output
+	return
+}
+
+// This action deletes a health check. To delete a health check, send a DELETE
+// request to the 2013-04-01/healthcheck/health check ID resource.
+//
+//  You can delete a health check only if there are no resource record sets
+// associated with this health check. If resource record sets are associated
+// with this health check, you must disassociate them before you can delete
+// your health check. If you try to delete a health check that is associated
+// with resource record sets, Route 53 will deny your request with a HealthCheckInUse
+// error. For information about disassociating the records from your health
+// check, see ChangeResourceRecordSets.
+func (c *Route53) DeleteHealthCheck(input *DeleteHealthCheckInput) (output *DeleteHealthCheckOutput, err error) {
+	req, out := c.DeleteHealthCheckRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opDeleteHealthCheck *aws.Operation
+
+// DeleteHostedZoneRequest generates a request for the DeleteHostedZone operation.
+func (c *Route53) DeleteHostedZoneRequest(input *DeleteHostedZoneInput) (req *aws.Request, output *DeleteHostedZoneOutput) {
+	if opDeleteHostedZone == nil {
+		opDeleteHostedZone = &aws.Operation{
+			Name:       "DeleteHostedZone",
+			HTTPMethod: "DELETE",
+			HTTPPath:   "/2013-04-01/hostedzone/{Id}",
+		}
+	}
+
+	req = c.newRequest(opDeleteHostedZone, input, output)
+	output = &DeleteHostedZoneOutput{}
+	req.Data = output
+	return
+}
+
+// This action deletes a hosted zone. To delete a hosted zone, send a DELETE
+// request to the 2013-04-01/hostedzone/hosted zone ID resource.
+//
+// For more information about deleting a hosted zone, see Deleting a Hosted
+// Zone (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/DeleteHostedZone.html)
+// in the Amazon Route 53 Developer Guide.
+//
+//  You can delete a hosted zone only if there are no resource record sets
+// other than the default SOA record and NS resource record sets. If your hosted
+// zone contains other resource record sets, you must delete them before you
+// can delete your hosted zone. If you try to delete a hosted zone that contains
+// other resource record sets, Route 53 will deny your request with a HostedZoneNotEmpty
+// error. For information about deleting records from your hosted zone, see
+// ChangeResourceRecordSets.
+func (c *Route53) DeleteHostedZone(input *DeleteHostedZoneInput) (output *DeleteHostedZoneOutput, err error) {
+	req, out := c.DeleteHostedZoneRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opDeleteHostedZone *aws.Operation
+
+// DeleteReusableDelegationSetRequest generates a request for the DeleteReusableDelegationSet operation.
+func (c *Route53) DeleteReusableDelegationSetRequest(input *DeleteReusableDelegationSetInput) (req *aws.Request, output *DeleteReusableDelegationSetOutput) {
+	if opDeleteReusableDelegationSet == nil {
+		opDeleteReusableDelegationSet = &aws.Operation{
+			Name:       "DeleteReusableDelegationSet",
+			HTTPMethod: "DELETE",
+			HTTPPath:   "/2013-04-01/delegationset/{Id}",
+		}
+	}
+
+	req = c.newRequest(opDeleteReusableDelegationSet, input, output)
+	output = &DeleteReusableDelegationSetOutput{}
+	req.Data = output
+	return
+}
+
+// This action deletes a reusable delegation set. To delete a reusable delegation
+// set, send a DELETE request to the 2013-04-01/delegationset/delegation set
+// ID resource.
+//
+//  You can delete a reusable delegation set only if there are no associated
+// hosted zones. If your reusable delegation set contains associated hosted
+// zones, you must delete them before you can delete your reusable delegation
+// set. If you try to delete a reusable delegation set that contains associated
+// hosted zones, Route 53 will deny your request with a DelegationSetInUse error.
+func (c *Route53) DeleteReusableDelegationSet(input *DeleteReusableDelegationSetInput) (output *DeleteReusableDelegationSetOutput, err error) {
+	req, out := c.DeleteReusableDelegationSetRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opDeleteReusableDelegationSet *aws.Operation
+
+// DisassociateVPCFromHostedZoneRequest generates a request for the DisassociateVPCFromHostedZone operation.
+func (c *Route53) DisassociateVPCFromHostedZoneRequest(input *DisassociateVPCFromHostedZoneInput) (req *aws.Request, output *DisassociateVPCFromHostedZoneOutput) {
+	if opDisassociateVPCFromHostedZone == nil {
+		opDisassociateVPCFromHostedZone = &aws.Operation{
+			Name:       "DisassociateVPCFromHostedZone",
+			HTTPMethod: "POST",
+			HTTPPath:   "/2013-04-01/hostedzone/{Id}/disassociatevpc",
+		}
+	}
+
+	req = c.newRequest(opDisassociateVPCFromHostedZone, input, output)
+	output = &DisassociateVPCFromHostedZoneOutput{}
+	req.Data = output
+	return
+}
+
+// This action disassociates a VPC from an hosted zone.
+//
+//  To disassociate a VPC to a hosted zone, send a POST request to the 2013-04-01/hostedzone/hosted
+// zone ID/disassociatevpc resource. The request body must include an XML document
+// with a DisassociateVPCFromHostedZoneRequest element. The response returns
+// the DisassociateVPCFromHostedZoneResponse element that contains ChangeInfo
+// for you to track the progress of the DisassociateVPCFromHostedZoneRequest
+// you made. See GetChange operation for how to track the progress of your change.
+func (c *Route53) DisassociateVPCFromHostedZone(input *DisassociateVPCFromHostedZoneInput) (output *DisassociateVPCFromHostedZoneOutput, err error) {
+	req, out := c.DisassociateVPCFromHostedZoneRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opDisassociateVPCFromHostedZone *aws.Operation
+
+// GetChangeRequest generates a request for the GetChange operation.
+func (c *Route53) GetChangeRequest(input *GetChangeInput) (req *aws.Request, output *GetChangeOutput) {
+	if opGetChange == nil {
+		opGetChange = &aws.Operation{
+			Name:       "GetChange",
+			HTTPMethod: "GET",
+			HTTPPath:   "/2013-04-01/change/{Id}",
+		}
+	}
+
+	req = c.newRequest(opGetChange, input, output)
+	output = &GetChangeOutput{}
+	req.Data = output
+	return
+}
+
+// This action returns the current status of a change batch request. The status
+// is one of the following values:
+//
+// - PENDING indicates that the changes in this request have not replicated
+// to all Route 53 DNS servers. This is the initial status of all change batch
+// requests.
+//
+// - INSYNC indicates that the changes have replicated to all Amazon Route
+// 53 DNS servers.
+func (c *Route53) GetChange(input *GetChangeInput) (output *GetChangeOutput, err error) {
+	req, out := c.GetChangeRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opGetChange *aws.Operation
+
+// GetCheckerIPRangesRequest generates a request for the GetCheckerIPRanges operation.
+func (c *Route53) GetCheckerIPRangesRequest(input *GetCheckerIPRangesInput) (req *aws.Request, output *GetCheckerIPRangesOutput) {
+	if opGetCheckerIPRanges == nil {
+		opGetCheckerIPRanges = &aws.Operation{
+			Name:       "GetCheckerIpRanges",
+			HTTPMethod: "GET",
+			HTTPPath:   "/2013-04-01/checkeripranges",
+		}
+	}
+
+	req = c.newRequest(opGetCheckerIPRanges, input, output)
+	output = &GetCheckerIPRangesOutput{}
+	req.Data = output
+	return
+}
+
+// To retrieve a list of the IP ranges used by Amazon Route 53 health checkers
+// to check the health of your resources, send a GET request to the 2013-04-01/checkeripranges
+// resource. You can use these IP addresses to configure router and firewall
+// rules to allow health checkers to check the health of your resources.
+func (c *Route53) GetCheckerIPRanges(input *GetCheckerIPRangesInput) (output *GetCheckerIPRangesOutput, err error) {
+	req, out := c.GetCheckerIPRangesRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opGetCheckerIPRanges *aws.Operation
+
+// GetGeoLocationRequest generates a request for the GetGeoLocation operation.
+func (c *Route53) GetGeoLocationRequest(input *GetGeoLocationInput) (req *aws.Request, output *GetGeoLocationOutput) {
+	if opGetGeoLocation == nil {
+		opGetGeoLocation = &aws.Operation{
+			Name:       "GetGeoLocation",
+			HTTPMethod: "GET",
+			HTTPPath:   "/2013-04-01/geolocation",
+		}
+	}
+
+	req = c.newRequest(opGetGeoLocation, input, output)
+	output = &GetGeoLocationOutput{}
+	req.Data = output
+	return
+}
+
+// To retrieve a single geo location, send a GET request to the 2013-04-01/geolocation
+// resource with one of these options: continentcode | countrycode | countrycode
+// and subdivisioncode.
+func (c *Route53) GetGeoLocation(input *GetGeoLocationInput) (output *GetGeoLocationOutput, err error) {
+	req, out := c.GetGeoLocationRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opGetGeoLocation *aws.Operation
+
+// GetHealthCheckRequest generates a request for the GetHealthCheck operation.
+func (c *Route53) GetHealthCheckRequest(input *GetHealthCheckInput) (req *aws.Request, output *GetHealthCheckOutput) {
+	if opGetHealthCheck == nil {
+		opGetHealthCheck = &aws.Operation{
+			Name:       "GetHealthCheck",
+			HTTPMethod: "GET",
+			HTTPPath:   "/2013-04-01/healthcheck/{HealthCheckId}",
+		}
+	}
+
+	req = c.newRequest(opGetHealthCheck, input, output)
+	output = &GetHealthCheckOutput{}
+	req.Data = output
+	return
+}
+
+// To retrieve the health check, send a GET request to the 2013-04-01/healthcheck/health
+// check ID resource.
+func (c *Route53) GetHealthCheck(input *GetHealthCheckInput) (output *GetHealthCheckOutput, err error) {
+	req, out := c.GetHealthCheckRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opGetHealthCheck *aws.Operation
+
+// GetHealthCheckCountRequest generates a request for the GetHealthCheckCount operation.
+func (c *Route53) GetHealthCheckCountRequest(input *GetHealthCheckCountInput) (req *aws.Request, output *GetHealthCheckCountOutput) {
+	if opGetHealthCheckCount == nil {
+		opGetHealthCheckCount = &aws.Operation{
+			Name:       "GetHealthCheckCount",
+			HTTPMethod: "GET",
+			HTTPPath:   "/2013-04-01/healthcheckcount",
+		}
+	}
+
+	req = c.newRequest(opGetHealthCheckCount, input, output)
+	output = &GetHealthCheckCountOutput{}
+	req.Data = output
+	return
+}
+
+// To retrieve a count of all your health checks, send a GET request to the
+// 2013-04-01/healthcheckcount resource.
+func (c *Route53) GetHealthCheckCount(input *GetHealthCheckCountInput) (output *GetHealthCheckCountOutput, err error) {
+	req, out := c.GetHealthCheckCountRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opGetHealthCheckCount *aws.Operation
+
+// GetHealthCheckLastFailureReasonRequest generates a request for the GetHealthCheckLastFailureReason operation.
+func (c *Route53) GetHealthCheckLastFailureReasonRequest(input *GetHealthCheckLastFailureReasonInput) (req *aws.Request, output *GetHealthCheckLastFailureReasonOutput) {
+	if opGetHealthCheckLastFailureReason == nil {
+		opGetHealthCheckLastFailureReason = &aws.Operation{
+			Name:       "GetHealthCheckLastFailureReason",
+			HTTPMethod: "GET",
+			HTTPPath:   "/2013-04-01/healthcheck/{HealthCheckId}/lastfailurereason",
+		}
+	}
+
+	req = c.newRequest(opGetHealthCheckLastFailureReason, input, output)
+	output = &GetHealthCheckLastFailureReasonOutput{}
+	req.Data = output
+	return
+}
+
+// If you want to learn why a health check is currently failing or why it failed
+// most recently (if at all), you can get the failure reason for the most recent
+// failure. Send a GET request to the 2013-04-01/healthcheck/health check ID/lastfailurereason
+// resource.
+func (c *Route53) GetHealthCheckLastFailureReason(input *GetHealthCheckLastFailureReasonInput) (output *GetHealthCheckLastFailureReasonOutput, err error) {
+	req, out := c.GetHealthCheckLastFailureReasonRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opGetHealthCheckLastFailureReason *aws.Operation
+
+// GetHealthCheckStatusRequest generates a request for the GetHealthCheckStatus operation.
+func (c *Route53) GetHealthCheckStatusRequest(input *GetHealthCheckStatusInput) (req *aws.Request, output *GetHealthCheckStatusOutput) {
+	if opGetHealthCheckStatus == nil {
+		opGetHealthCheckStatus = &aws.Operation{
+			Name:       "GetHealthCheckStatus",
+			HTTPMethod: "GET",
+			HTTPPath:   "/2013-04-01/healthcheck/{HealthCheckId}/status",
+		}
+	}
+
+	req = c.newRequest(opGetHealthCheckStatus, input, output)
+	output = &GetHealthCheckStatusOutput{}
+	req.Data = output
+	return
+}
+
+// To retrieve the health check status, send a GET request to the 2013-04-01/healthcheck/health
+// check ID/status resource. You can use this call to get a health check's current
+// status.
+func (c *Route53) GetHealthCheckStatus(input *GetHealthCheckStatusInput) (output *GetHealthCheckStatusOutput, err error) {
+	req, out := c.GetHealthCheckStatusRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opGetHealthCheckStatus *aws.Operation
+
+// GetHostedZoneRequest generates a request for the GetHostedZone operation.
+func (c *Route53) GetHostedZoneRequest(input *GetHostedZoneInput) (req *aws.Request, output *GetHostedZoneOutput) {
+	if opGetHostedZone == nil {
+		opGetHostedZone = &aws.Operation{
+			Name:       "GetHostedZone",
+			HTTPMethod: "GET",
+			HTTPPath:   "/2013-04-01/hostedzone/{Id}",
+		}
+	}
+
+	req = c.newRequest(opGetHostedZone, input, output)
+	output = &GetHostedZoneOutput{}
+	req.Data = output
+	return
+}
+
+// To retrieve the delegation set for a hosted zone, send a GET request to the
+// 2013-04-01/hostedzone/hosted zone ID resource. The delegation set is the
+// four Route 53 name servers that were assigned to the hosted zone when you
+// created it.
+func (c *Route53) GetHostedZone(input *GetHostedZoneInput) (output *GetHostedZoneOutput, err error) {
+	req, out := c.GetHostedZoneRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opGetHostedZone *aws.Operation
+
+// GetHostedZoneCountRequest generates a request for the GetHostedZoneCount operation.
+func (c *Route53) GetHostedZoneCountRequest(input *GetHostedZoneCountInput) (req *aws.Request, output *GetHostedZoneCountOutput) {
+	if opGetHostedZoneCount == nil {
+		opGetHostedZoneCount = &aws.Operation{
+			Name:       "GetHostedZoneCount",
+			HTTPMethod: "GET",
+			HTTPPath:   "/2013-04-01/hostedzonecount",
+		}
+	}
+
+	req = c.newRequest(opGetHostedZoneCount, input, output)
+	output = &GetHostedZoneCountOutput{}
+	req.Data = output
+	return
+}
+
+// To retrieve a count of all your hosted zones, send a GET request to the 2013-04-01/hostedzonecount
+// resource.
+func (c *Route53) GetHostedZoneCount(input *GetHostedZoneCountInput) (output *GetHostedZoneCountOutput, err error) {
+	req, out := c.GetHostedZoneCountRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opGetHostedZoneCount *aws.Operation
+
+// GetReusableDelegationSetRequest generates a request for the GetReusableDelegationSet operation.
+func (c *Route53) GetReusableDelegationSetRequest(input *GetReusableDelegationSetInput) (req *aws.Request, output *GetReusableDelegationSetOutput) {
+	if opGetReusableDelegationSet == nil {
+		opGetReusableDelegationSet = &aws.Operation{
+			Name:       "GetReusableDelegationSet",
+			HTTPMethod: "GET",
+			HTTPPath:   "/2013-04-01/delegationset/{Id}",
+		}
+	}
+
+	req = c.newRequest(opGetReusableDelegationSet, input, output)
+	output = &GetReusableDelegationSetOutput{}
+	req.Data = output
+	return
+}
+
+// To retrieve the reusable delegation set, send a GET request to the 2013-04-01/delegationset/delegation
+// set ID resource.
+func (c *Route53) GetReusableDelegationSet(input *GetReusableDelegationSetInput) (output *GetReusableDelegationSetOutput, err error) {
+	req, out := c.GetReusableDelegationSetRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opGetReusableDelegationSet *aws.Operation
+
+// ListGeoLocationsRequest generates a request for the ListGeoLocations operation.
+func (c *Route53) ListGeoLocationsRequest(input *ListGeoLocationsInput) (req *aws.Request, output *ListGeoLocationsOutput) {
+	if opListGeoLocations == nil {
+		opListGeoLocations = &aws.Operation{
+			Name:       "ListGeoLocations",
+			HTTPMethod: "GET",
+			HTTPPath:   "/2013-04-01/geolocations",
+		}
+	}
+
+	req = c.newRequest(opListGeoLocations, input, output)
+	output = &ListGeoLocationsOutput{}
+	req.Data = output
+	return
+}
+
+// To retrieve a list of supported geo locations, send a GET request to the
+// 2013-04-01/geolocations resource. The response to this request includes a
+// GeoLocationDetailsList element with zero, one, or multiple GeoLocationDetails
+// child elements. The list is sorted by country code, and then subdivision
+// code, followed by continents at the end of the list.
+//
+//  By default, the list of geo locations is displayed on a single page. You
+// can control the length of the page that is displayed by using the MaxItems
+// parameter. If the list is truncated, IsTruncated will be set to true and
+// a combination of NextContinentCode, NextCountryCode, NextSubdivisionCode
+// will be populated. You can pass these as parameters to StartContinentCode,
+// StartCountryCode, StartSubdivisionCode to control the geo location that the
+// list begins with.
+func (c *Route53) ListGeoLocations(input *ListGeoLocationsInput) (output *ListGeoLocationsOutput, err error) {
+	req, out := c.ListGeoLocationsRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opListGeoLocations *aws.Operation
+
+// ListHealthChecksRequest generates a request for the ListHealthChecks operation.
+func (c *Route53) ListHealthChecksRequest(input *ListHealthChecksInput) (req *aws.Request, output *ListHealthChecksOutput) {
+	if opListHealthChecks == nil {
+		opListHealthChecks = &aws.Operation{
+			Name:       "ListHealthChecks",
+			HTTPMethod: "GET",
+			HTTPPath:   "/2013-04-01/healthcheck",
+		}
+	}
+
+	req = c.newRequest(opListHealthChecks, input, output)
+	output = &ListHealthChecksOutput{}
+	req.Data = output
+	return
+}
+
+// To retrieve a list of your health checks, send a GET request to the 2013-04-01/healthcheck
+// resource. The response to this request includes a HealthChecks element with
+// zero, one, or multiple HealthCheck child elements. By default, the list of
+// health checks is displayed on a single page. You can control the length of
+// the page that is displayed by using the MaxItems parameter. You can use the
+// Marker parameter to control the health check that the list begins with.
+//
+//  Amazon Route 53 returns a maximum of 100 items. If you set MaxItems to
+// a value greater than 100, Amazon Route 53 returns only the first 100.
+func (c *Route53) ListHealthChecks(input *ListHealthChecksInput) (output *ListHealthChecksOutput, err error) {
+	req, out := c.ListHealthChecksRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opListHealthChecks *aws.Operation
+
+// ListHostedZonesRequest generates a request for the ListHostedZones operation.
+func (c *Route53) ListHostedZonesRequest(input *ListHostedZonesInput) (req *aws.Request, output *ListHostedZonesOutput) {
+	if opListHostedZones == nil {
+		opListHostedZones = &aws.Operation{
+			Name:       "ListHostedZones",
+			HTTPMethod: "GET",
+			HTTPPath:   "/2013-04-01/hostedzone",
+		}
+	}
+
+	req = c.newRequest(opListHostedZones, input, output)
+	output = &ListHostedZonesOutput{}
+	req.Data = output
+	return
+}
+
+// To retrieve a list of your hosted zones, send a GET request to the 2013-04-01/hostedzone
+// resource. The response to this request includes a HostedZones element with
+// zero, one, or multiple HostedZone child elements. By default, the list of
+// hosted zones is displayed on a single page. You can control the length of
+// the page that is displayed by using the MaxItems parameter. You can use the
+// Marker parameter to control the hosted zone that the list begins with.
+//
+//  Amazon Route 53 returns a maximum of 100 items. If you set MaxItems to
+// a value greater than 100, Amazon Route 53 returns only the first 100.
+func (c *Route53) ListHostedZones(input *ListHostedZonesInput) (output *ListHostedZonesOutput, err error) {
+	req, out := c.ListHostedZonesRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opListHostedZones *aws.Operation
+
+// ListHostedZonesByNameRequest generates a request for the ListHostedZonesByName operation.
+func (c *Route53) ListHostedZonesByNameRequest(input *ListHostedZonesByNameInput) (req *aws.Request, output *ListHostedZonesByNameOutput) {
+	if opListHostedZonesByName == nil {
+		opListHostedZonesByName = &aws.Operation{
+			Name:       "ListHostedZonesByName",
+			HTTPMethod: "GET",
+			HTTPPath:   "/2013-04-01/hostedzonesbyname",
+		}
+	}
+
+	req = c.newRequest(opListHostedZonesByName, input, output)
+	output = &ListHostedZonesByNameOutput{}
+	req.Data = output
+	return
+}
+
+// To retrieve a list of your hosted zones in lexicographic order, send a GET
+// request to the 2013-04-01/hostedzonesbyname resource. The response to this
+// request includes a HostedZones element with zero or more HostedZone child
+// elements lexicographically ordered by DNS name. By default, the list of hosted
+// zones is displayed on a single page. You can control the length of the page
+// that is displayed by using the MaxItems parameter. You can use the DNSName
+// and HostedZoneId parameters to control the hosted zone that the list begins
+// with.
+//
+//  Amazon Route 53 returns a maximum of 100 items. If you set MaxItems to
+// a value greater than 100, Amazon Route 53 returns only the first 100.
+func (c *Route53) ListHostedZonesByName(input *ListHostedZonesByNameInput) (output *ListHostedZonesByNameOutput, err error) {
+	req, out := c.ListHostedZonesByNameRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opListHostedZonesByName *aws.Operation
+
+// ListResourceRecordSetsRequest generates a request for the ListResourceRecordSets operation.
+func (c *Route53) ListResourceRecordSetsRequest(input *ListResourceRecordSetsInput) (req *aws.Request, output *ListResourceRecordSetsOutput) {
+	if opListResourceRecordSets == nil {
+		opListResourceRecordSets = &aws.Operation{
+			Name:       "ListResourceRecordSets",
+			HTTPMethod: "GET",
+			HTTPPath:   "/2013-04-01/hostedzone/{Id}/rrset",
+		}
+	}
+
+	req = c.newRequest(opListResourceRecordSets, input, output)
+	output = &ListResourceRecordSetsOutput{}
+	req.Data = output
+	return
+}
+
+// Imagine all the resource record sets in a zone listed out in front of you.
+// Imagine them sorted lexicographically first by DNS name (with the labels
+// reversed, like "com.amazon.www" for example), and secondarily, lexicographically
+// by record type. This operation retrieves at most MaxItems resource record
+// sets from this list, in order, starting at a position specified by the Name
+// and Type arguments:
+//
+//  If both Name and Type are omitted, this means start the results at the
+// first RRSET in the HostedZone. If Name is specified but Type is omitted,
+// this means start the results at the first RRSET in the list whose name is
+// greater than or equal to Name.  If both Name and Type are specified, this
+// means start the results at the first RRSET in the list whose name is greater
+// than or equal to Name and whose type is greater than or equal to Type. It
+// is an error to specify the Type but not the Name.  Use ListResourceRecordSets
+// to retrieve a single known record set by specifying the record set's name
+// and type, and setting MaxItems = 1
+//
+// To retrieve all the records in a HostedZone, first pause any processes making
+// calls to ChangeResourceRecordSets. Initially call ListResourceRecordSets
+// without a Name and Type to get the first page of record sets. For subsequent
+// calls, set Name and Type to the NextName and NextType values returned by
+// the previous response.
+//
+// In the presence of concurrent ChangeResourceRecordSets calls, there is no
+// consistency of results across calls to ListResourceRecordSets. The only way
+// to get a consistent multi-page snapshot of all RRSETs in a zone is to stop
+// making changes while pagination is in progress.
+//
+// However, the results from ListResourceRecordSets are consistent within a
+// page. If MakeChange calls are taking place concurrently, the result of each
+// one will either be completely visible in your results or not at all. You
+// will not see partial changes, or changes that do not ultimately succeed.
+// (This follows from the fact that MakeChange is atomic)
+//
+// The results from ListResourceRecordSets are strongly consistent with ChangeResourceRecordSets.
+// To be precise, if a single process makes a call to ChangeResourceRecordSets
+// and receives a successful response, the effects of that change will be visible
+// in a subsequent call to ListResourceRecordSets by that process.
+func (c *Route53) ListResourceRecordSets(input *ListResourceRecordSetsInput) (output *ListResourceRecordSetsOutput, err error) {
+	req, out := c.ListResourceRecordSetsRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opListResourceRecordSets *aws.Operation
+
+// ListReusableDelegationSetsRequest generates a request for the ListReusableDelegationSets operation.
+func (c *Route53) ListReusableDelegationSetsRequest(input *ListReusableDelegationSetsInput) (req *aws.Request, output *ListReusableDelegationSetsOutput) {
+	if opListReusableDelegationSets == nil {
+		opListReusableDelegationSets = &aws.Operation{
+			Name:       "ListReusableDelegationSets",
+			HTTPMethod: "GET",
+			HTTPPath:   "/2013-04-01/delegationset",
+		}
+	}
+
+	req = c.newRequest(opListReusableDelegationSets, input, output)
+	output = &ListReusableDelegationSetsOutput{}
+	req.Data = output
+	return
+}
+
+// To retrieve a list of your reusable delegation sets, send a GET request to
+// the 2013-04-01/delegationset resource. The response to this request includes
+// a DelegationSets element with zero, one, or multiple DelegationSet child
+// elements. By default, the list of delegation sets is displayed on a single
+// page. You can control the length of the page that is displayed by using the
+// MaxItems parameter. You can use the Marker parameter to control the delegation
+// set that the list begins with.
+//
+//  Amazon Route 53 returns a maximum of 100 items. If you set MaxItems to
+// a value greater than 100, Amazon Route 53 returns only the first 100.
+func (c *Route53) ListReusableDelegationSets(input *ListReusableDelegationSetsInput) (output *ListReusableDelegationSetsOutput, err error) {
+	req, out := c.ListReusableDelegationSetsRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opListReusableDelegationSets *aws.Operation
+
+// ListTagsForResourceRequest generates a request for the ListTagsForResource operation.
+func (c *Route53) ListTagsForResourceRequest(input *ListTagsForResourceInput) (req *aws.Request, output *ListTagsForResourceOutput) {
+	if opListTagsForResource == nil {
+		opListTagsForResource = &aws.Operation{
+			Name:       "ListTagsForResource",
+			HTTPMethod: "GET",
+			HTTPPath:   "/2013-04-01/tags/{ResourceType}/{ResourceId}",
+		}
+	}
+
+	req = c.newRequest(opListTagsForResource, input, output)
+	output = &ListTagsForResourceOutput{}
+	req.Data = output
+	return
+}
+
+func (c *Route53) ListTagsForResource(input *ListTagsForResourceInput) (output *ListTagsForResourceOutput, err error) {
+	req, out := c.ListTagsForResourceRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opListTagsForResource *aws.Operation
+
+// ListTagsForResourcesRequest generates a request for the ListTagsForResources operation.
+func (c *Route53) ListTagsForResourcesRequest(input *ListTagsForResourcesInput) (req *aws.Request, output *ListTagsForResourcesOutput) {
+	if opListTagsForResources == nil {
+		opListTagsForResources = &aws.Operation{
+			Name:       "ListTagsForResources",
+			HTTPMethod: "POST",
+			HTTPPath:   "/2013-04-01/tags/{ResourceType}",
+		}
+	}
+
+	req = c.newRequest(opListTagsForResources, input, output)
+	output = &ListTagsForResourcesOutput{}
+	req.Data = output
+	return
+}
+
+func (c *Route53) ListTagsForResources(input *ListTagsForResourcesInput) (output *ListTagsForResourcesOutput, err error) {
+	req, out := c.ListTagsForResourcesRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opListTagsForResources *aws.Operation
+
+// UpdateHealthCheckRequest generates a request for the UpdateHealthCheck operation.
+func (c *Route53) UpdateHealthCheckRequest(input *UpdateHealthCheckInput) (req *aws.Request, output *UpdateHealthCheckOutput) {
+	if opUpdateHealthCheck == nil {
+		opUpdateHealthCheck = &aws.Operation{
+			Name:       "UpdateHealthCheck",
+			HTTPMethod: "POST",
+			HTTPPath:   "/2013-04-01/healthcheck/{HealthCheckId}",
+		}
+	}
+
+	req = c.newRequest(opUpdateHealthCheck, input, output)
+	output = &UpdateHealthCheckOutput{}
+	req.Data = output
+	return
+}
+
+// This action updates an existing health check.
+//
+//  To update a health check, send a POST request to the 2013-04-01/healthcheck/health
+// check ID resource. The request body must include an XML document with an
+// UpdateHealthCheckRequest element. The response returns an UpdateHealthCheckResponse
+// element, which contains metadata about the health check.
+func (c *Route53) UpdateHealthCheck(input *UpdateHealthCheckInput) (output *UpdateHealthCheckOutput, err error) {
+	req, out := c.UpdateHealthCheckRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opUpdateHealthCheck *aws.Operation
+
+// UpdateHostedZoneCommentRequest generates a request for the UpdateHostedZoneComment operation.
+func (c *Route53) UpdateHostedZoneCommentRequest(input *UpdateHostedZoneCommentInput) (req *aws.Request, output *UpdateHostedZoneCommentOutput) {
+	if opUpdateHostedZoneComment == nil {
+		opUpdateHostedZoneComment = &aws.Operation{
+			Name:       "UpdateHostedZoneComment",
+			HTTPMethod: "POST",
+			HTTPPath:   "/2013-04-01/hostedzone/{Id}",
+		}
+	}
+
+	req = c.newRequest(opUpdateHostedZoneComment, input, output)
+	output = &UpdateHostedZoneCommentOutput{}
+	req.Data = output
+	return
+}
+
+// To update the hosted zone comment, send a POST request to the 2013-04-01/hostedzone/hosted
+// zone ID resource. The request body must include an XML document with a UpdateHostedZoneCommentRequest
+// element. The response to this request includes the modified HostedZone element.
+//
+//  The comment can have a maximum length of 256 characters.
+func (c *Route53) UpdateHostedZoneComment(input *UpdateHostedZoneCommentInput) (output *UpdateHostedZoneCommentOutput, err error) {
+	req, out := c.UpdateHostedZoneCommentRequest(input)
+	output = out
+	err = req.Send()
+	return
+}
+
+var opUpdateHostedZoneComment *aws.Operation
+
+// Alias resource record sets only: Information about the domain to which you
+// are redirecting traffic.
+//
+// For more information and an example, see Creating Alias Resource Record
+// Sets (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/CreatingAliasRRSets.html)
+// in the Amazon Route 53 Developer Guide
+//
+// .
+type AliasTarget struct {
+	// Alias resource record sets only: The external DNS name associated with the
+	// AWS Resource.
+	//
+	// For more information and an example, see Creating Alias Resource Record
+	// Sets (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/CreatingAliasRRSets.html)
+	// in the Amazon Route 53 Developer Guide
+	//
+	// .
+	DNSName *string `type:"string" required:"true"`
+
+	// Alias resource record sets only: A boolean value that indicates whether this
+	// Resource Record Set should respect the health status of any health checks
+	// associated with the ALIAS target record which it is linked to.
+	//
+	// For more information and an example, see Creating Alias Resource Record
+	// Sets (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/CreatingAliasRRSets.html)
+	// in the Amazon Route 53 Developer Guide
+	//
+	// .
+	EvaluateTargetHealth *bool `type:"boolean" required:"true"`
+
+	// Alias resource record sets only: The value of the hosted zone ID for the
+	// AWS resource.
+	//
+	// For more information and an example, see Creating Alias Resource Record
+	// Sets (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/CreatingAliasRRSets.html)
+	// in the Amazon Route 53 Developer Guide
+	//
+	// .
+	HostedZoneID *string `locationName:"HostedZoneId" type:"string" required:"true"`
+
+	metadataAliasTarget `json:"-", xml:"-"`
+}
+
+type metadataAliasTarget struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains information about the request to associate a
+// VPC with an hosted zone.
+type AssociateVPCWithHostedZoneInput struct {
+	// Optional: Any comments you want to include about a AssociateVPCWithHostedZoneRequest.
+	Comment *string `type:"string"`
+
+	// The ID of the hosted zone you want to associate your VPC with.
+	//
+	// Note that you cannot associate a VPC with a hosted zone that doesn't have
+	// an existing VPC association.
+	HostedZoneID *string `location:"uri" locationName:"Id" type:"string" required:"true"`
+
+	// The VPC that you want your hosted zone to be associated with.
+	VPC *VPC `type:"structure" required:"true"`
+
+	metadataAssociateVPCWithHostedZoneInput `json:"-", xml:"-"`
+}
+
+type metadataAssociateVPCWithHostedZoneInput struct {
+	SDKShapeTraits bool `locationName:"AssociateVPCWithHostedZoneRequest" type:"structure" xmlURI:"https://route53.amazonaws.com/doc/2013-04-01/"`
+}
+
+// A complex type containing the response information for the request.
+type AssociateVPCWithHostedZoneOutput struct {
+	// A complex type that contains the ID, the status, and the date and time of
+	// your AssociateVPCWithHostedZoneRequest.
+	ChangeInfo *ChangeInfo `type:"structure" required:"true"`
+
+	metadataAssociateVPCWithHostedZoneOutput `json:"-", xml:"-"`
+}
+
+type metadataAssociateVPCWithHostedZoneOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains the information for each change in a change
+// batch request.
+type Change struct {
+	// The action to perform.
+	//
+	// Valid values: CREATE | DELETE | UPSERT
+	Action *string `type:"string" required:"true"`
+
+	// Information about the resource record set to create or delete.
+	ResourceRecordSet *ResourceRecordSet `type:"structure" required:"true"`
+
+	metadataChange `json:"-", xml:"-"`
+}
+
+type metadataChange struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains an optional comment and the changes that you
+// want to make with a change batch request.
+type ChangeBatch struct {
+	// A complex type that contains one Change element for each resource record
+	// set that you want to create or delete.
+	Changes []*Change `locationNameList:"Change" type:"list" required:"true"`
+
+	// Optional: Any comments you want to include about a change batch request.
+	Comment *string `type:"string"`
+
+	metadataChangeBatch `json:"-", xml:"-"`
+}
+
+type metadataChangeBatch struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that describes change information about changes made to your
+// hosted zone.
+//
+// This element contains an ID that you use when performing a GetChange action
+// to get detailed information about the change.
+type ChangeInfo struct {
+	// A complex type that describes change information about changes made to your
+	// hosted zone.
+	//
+	// This element contains an ID that you use when performing a GetChange action
+	// to get detailed information about the change.
+	Comment *string `type:"string"`
+
+	// The ID of the request. Use this ID to track when the change has completed
+	// across all Amazon Route 53 DNS servers.
+	ID *string `locationName:"Id" type:"string" required:"true"`
+
+	// The current state of the request. PENDING indicates that this request has
+	// not yet been applied to all Amazon Route 53 DNS servers.
+	//
+	// Valid Values: PENDING | INSYNC
+	Status *string `type:"string" required:"true"`
+
+	// The date and time the change was submitted, in the format YYYY-MM-DDThh:mm:ssZ,
+	// as specified in the ISO 8601 standard (for example, 2009-11-19T19:37:58Z).
+	// The Z after the time indicates that the time is listed in Coordinated Universal
+	// Time (UTC), which is synonymous with Greenwich Mean Time in this context.
+	SubmittedAt *time.Time `type:"timestamp" timestampFormat:"iso8601" required:"true"`
+
+	metadataChangeInfo `json:"-", xml:"-"`
+}
+
+type metadataChangeInfo struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains a change batch.
+type ChangeResourceRecordSetsInput struct {
+	// A complex type that contains an optional comment and the Changes element.
+	ChangeBatch *ChangeBatch `type:"structure" required:"true"`
+
+	// The ID of the hosted zone that contains the resource record sets that you
+	// want to change.
+	HostedZoneID *string `location:"uri" locationName:"Id" type:"string" required:"true"`
+
+	metadataChangeResourceRecordSetsInput `json:"-", xml:"-"`
+}
+
+type metadataChangeResourceRecordSetsInput struct {
+	SDKShapeTraits bool `locationName:"ChangeResourceRecordSetsRequest" type:"structure" xmlURI:"https://route53.amazonaws.com/doc/2013-04-01/"`
+}
+
+// A complex type containing the response for the request.
+type ChangeResourceRecordSetsOutput struct {
+	// A complex type that contains information about changes made to your hosted
+	// zone.
+	//
+	// This element contains an ID that you use when performing a GetChange action
+	// to get detailed information about the change.
+	ChangeInfo *ChangeInfo `type:"structure" required:"true"`
+
+	metadataChangeResourceRecordSetsOutput `json:"-", xml:"-"`
+}
+
+type metadataChangeResourceRecordSetsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type containing information about a request to add, change, or
+// delete the tags that are associated with a resource.
+type ChangeTagsForResourceInput struct {
+	// A complex type that contains a list of Tag elements. Each Tag element identifies
+	// a tag that you want to add or update for the specified resource.
+	AddTags []*Tag `locationNameList:"Tag" type:"list"`
+
+	// A list of Tag keys that you want to remove from the specified resource.
+	RemoveTagKeys []*string `locationNameList:"Key" type:"list"`
+
+	// The ID of the resource for which you want to add, change, or delete tags.
+	ResourceID *string `location:"uri" locationName:"ResourceId" type:"string" required:"true"`
+
+	// The type of the resource.
+	//
+	// - The resource type for health checks is healthcheck.
+	//
+	// - The resource type for hosted zones is hostedzone.
+	ResourceType *string `location:"uri" locationName:"ResourceType" type:"string" required:"true"`
+
+	metadataChangeTagsForResourceInput `json:"-", xml:"-"`
+}
+
+type metadataChangeTagsForResourceInput struct {
+	SDKShapeTraits bool `locationName:"ChangeTagsForResourceRequest" type:"structure" xmlURI:"https://route53.amazonaws.com/doc/2013-04-01/"`
+}
+
+// Empty response for the request.
+type ChangeTagsForResourceOutput struct {
+	metadataChangeTagsForResourceOutput `json:"-", xml:"-"`
+}
+
+type metadataChangeTagsForResourceOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// >A complex type that contains information about the request to create a health
+// check.
+type CreateHealthCheckInput struct {
+	// A unique string that identifies the request and that allows failed CreateHealthCheck
+	// requests to be retried without the risk of executing the operation twice.
+	// You must use a unique CallerReference string every time you create a health
+	// check. CallerReference can be any unique string; you might choose to use
+	// a string that identifies your project.
+	//
+	// Valid characters are any Unicode code points that are legal in an XML 1.0
+	// document. The UTF-8 encoding of the value must be less than 128 bytes.
+	CallerReference *string `type:"string" required:"true"`
+
+	// A complex type that contains health check configuration.
+	HealthCheckConfig *HealthCheckConfig `type:"structure" required:"true"`
+
+	metadataCreateHealthCheckInput `json:"-", xml:"-"`
+}
+
+type metadataCreateHealthCheckInput struct {
+	SDKShapeTraits bool `locationName:"CreateHealthCheckRequest" type:"structure" xmlURI:"https://route53.amazonaws.com/doc/2013-04-01/"`
+}
+
+// A complex type containing the response information for the new health check.
+type CreateHealthCheckOutput struct {
+	// A complex type that contains identifying information about the health check.
+	HealthCheck *HealthCheck `type:"structure" required:"true"`
+
+	// The unique URL representing the new health check.
+	Location *string `location:"header" locationName:"Location" type:"string" required:"true"`
+
+	metadataCreateHealthCheckOutput `json:"-", xml:"-"`
+}
+
+type metadataCreateHealthCheckOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains information about the request to create a hosted
+// zone.
+type CreateHostedZoneInput struct {
+	// A unique string that identifies the request and that allows failed CreateHostedZone
+	// requests to be retried without the risk of executing the operation twice.
+	// You must use a unique CallerReference string every time you create a hosted
+	// zone. CallerReference can be any unique string; you might choose to use a
+	// string that identifies your project, such as DNSMigration_01.
+	//
+	// Valid characters are any Unicode code points that are legal in an XML 1.0
+	// document. The UTF-8 encoding of the value must be less than 128 bytes.
+	CallerReference *string `type:"string" required:"true"`
+
+	// The delegation set id of the reusable delgation set whose NS records you
+	// want to assign to the new hosted zone.
+	DelegationSetID *string `locationName:"DelegationSetId" type:"string"`
+
+	// A complex type that contains an optional comment about your hosted zone.
+	HostedZoneConfig *HostedZoneConfig `type:"structure"`
+
+	// The name of the domain. This must be a fully-specified domain, for example,
+	// www.example.com. The trailing dot is optional; Route 53 assumes that the
+	// domain name is fully qualified. This means that Route 53 treats www.example.com
+	// (without a trailing dot) and www.example.com. (with a trailing dot) as identical.
+	//
+	// This is the name you have registered with your DNS registrar. You should
+	// ask your registrar to change the authoritative name servers for your domain
+	// to the set of NameServers elements returned in DelegationSet.
+	Name *string `type:"string" required:"true"`
+
+	// The VPC that you want your hosted zone to be associated with. By providing
+	// this parameter, your newly created hosted cannot be resolved anywhere other
+	// than the given VPC.
+	VPC *VPC `type:"structure"`
+
+	metadataCreateHostedZoneInput `json:"-", xml:"-"`
+}
+
+type metadataCreateHostedZoneInput struct {
+	SDKShapeTraits bool `locationName:"CreateHostedZoneRequest" type:"structure" xmlURI:"https://route53.amazonaws.com/doc/2013-04-01/"`
+}
+
+// A complex type containing the response information for the new hosted zone.
+type CreateHostedZoneOutput struct {
+	// A complex type that contains information about the request to create a hosted
+	// zone. This includes an ID that you use when you call the GetChange action
+	// to get the current status of the change request.
+	ChangeInfo *ChangeInfo `type:"structure" required:"true"`
+
+	// A complex type that contains name server information.
+	DelegationSet *DelegationSet `type:"structure" required:"true"`
+
+	// A complex type that contains identifying information about the hosted zone.
+	HostedZone *HostedZone `type:"structure" required:"true"`
+
+	// The unique URL representing the new hosted zone.
+	Location *string `location:"header" locationName:"Location" type:"string" required:"true"`
+
+	VPC *VPC `type:"structure"`
+
+	metadataCreateHostedZoneOutput `json:"-", xml:"-"`
+}
+
+type metadataCreateHostedZoneOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type CreateReusableDelegationSetInput struct {
+	// A unique string that identifies the request and that allows failed CreateReusableDelegationSet
+	// requests to be retried without the risk of executing the operation twice.
+	// You must use a unique CallerReference string every time you create a reusable
+	// delegation set. CallerReference can be any unique string; you might choose
+	// to use a string that identifies your project, such as DNSMigration_01.
+	//
+	// Valid characters are any Unicode code points that are legal in an XML 1.0
+	// document. The UTF-8 encoding of the value must be less than 128 bytes.
+	CallerReference *string `type:"string" required:"true"`
+
+	// The ID of the hosted zone whose delegation set you want to mark as reusable.
+	// It is an optional parameter.
+	HostedZoneID *string `locationName:"HostedZoneId" type:"string"`
+
+	metadataCreateReusableDelegationSetInput `json:"-", xml:"-"`
+}
+
+type metadataCreateReusableDelegationSetInput struct {
+	SDKShapeTraits bool `locationName:"CreateReusableDelegationSetRequest" type:"structure" xmlURI:"https://route53.amazonaws.com/doc/2013-04-01/"`
+}
+
+type CreateReusableDelegationSetOutput struct {
+	// A complex type that contains name server information.
+	DelegationSet *DelegationSet `type:"structure" required:"true"`
+
+	// The unique URL representing the new reusbale delegation set.
+	Location *string `location:"header" locationName:"Location" type:"string" required:"true"`
+
+	metadataCreateReusableDelegationSetOutput `json:"-", xml:"-"`
+}
+
+type metadataCreateReusableDelegationSetOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains name server information.
+type DelegationSet struct {
+	CallerReference *string `type:"string"`
+
+	ID *string `locationName:"Id" type:"string"`
+
+	// A complex type that contains the authoritative name servers for the hosted
+	// zone. Use the method provided by your domain registrar to add an NS record
+	// to your domain for each NameServer that is assigned to your hosted zone.
+	NameServers []*string `locationNameList:"NameServer" type:"list" required:"true"`
+
+	metadataDelegationSet `json:"-", xml:"-"`
+}
+
+type metadataDelegationSet struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type containing the request information for delete health check.
+type DeleteHealthCheckInput struct {
+	// The ID of the health check to delete.
+	HealthCheckID *string `location:"uri" locationName:"HealthCheckId" type:"string" required:"true"`
+
+	metadataDeleteHealthCheckInput `json:"-", xml:"-"`
+}
+
+type metadataDeleteHealthCheckInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// Empty response for the request.
+type DeleteHealthCheckOutput struct {
+	metadataDeleteHealthCheckOutput `json:"-", xml:"-"`
+}
+
+type metadataDeleteHealthCheckOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains information about the hosted zone that you want
+// to delete.
+type DeleteHostedZoneInput struct {
+	// The ID of the hosted zone you want to delete.
+	ID *string `location:"uri" locationName:"Id" type:"string" required:"true"`
+
+	metadataDeleteHostedZoneInput `json:"-", xml:"-"`
+}
+
+type metadataDeleteHostedZoneInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type containing the response information for the request.
+type DeleteHostedZoneOutput struct {
+	// A complex type that contains the ID, the status, and the date and time of
+	// your delete request.
+	ChangeInfo *ChangeInfo `type:"structure" required:"true"`
+
+	metadataDeleteHostedZoneOutput `json:"-", xml:"-"`
+}
+
+type metadataDeleteHostedZoneOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type containing the information for the delete request.
+type DeleteReusableDelegationSetInput struct {
+	// The ID of the reusable delegation set you want to delete.
+	ID *string `location:"uri" locationName:"Id" type:"string" required:"true"`
+
+	metadataDeleteReusableDelegationSetInput `json:"-", xml:"-"`
+}
+
+type metadataDeleteReusableDelegationSetInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// Empty response for the request.
+type DeleteReusableDelegationSetOutput struct {
+	metadataDeleteReusableDelegationSetOutput `json:"-", xml:"-"`
+}
+
+type metadataDeleteReusableDelegationSetOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains information about the request to disassociate
+// a VPC from an hosted zone.
+type DisassociateVPCFromHostedZoneInput struct {
+	// Optional: Any comments you want to include about a DisassociateVPCFromHostedZoneRequest.
+	Comment *string `type:"string"`
+
+	// The ID of the hosted zone you want to disassociate your VPC from.
+	//
+	// Note that you cannot disassociate the last VPC from a hosted zone.
+	HostedZoneID *string `location:"uri" locationName:"Id" type:"string" required:"true"`
+
+	// The VPC that you want your hosted zone to be disassociated from.
+	VPC *VPC `type:"structure" required:"true"`
+
+	metadataDisassociateVPCFromHostedZoneInput `json:"-", xml:"-"`
+}
+
+type metadataDisassociateVPCFromHostedZoneInput struct {
+	SDKShapeTraits bool `locationName:"DisassociateVPCFromHostedZoneRequest" type:"structure" xmlURI:"https://route53.amazonaws.com/doc/2013-04-01/"`
+}
+
+// A complex type containing the response information for the request.
+type DisassociateVPCFromHostedZoneOutput struct {
+	// A complex type that contains the ID, the status, and the date and time of
+	// your DisassociateVPCFromHostedZoneRequest.
+	ChangeInfo *ChangeInfo `type:"structure" required:"true"`
+
+	metadataDisassociateVPCFromHostedZoneOutput `json:"-", xml:"-"`
+}
+
+type metadataDisassociateVPCFromHostedZoneOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains information about a geo location.
+type GeoLocation struct {
+	// The code for a continent geo location. Note: only continent locations have
+	// a continent code.
+	//
+	// Valid values: AF | AN | AS | EU | OC | NA | SA
+	//
+	// Constraint: Specifying ContinentCode with either CountryCode or SubdivisionCode
+	// returns an InvalidInput error.
+	ContinentCode *string `type:"string"`
+
+	// The code for a country geo location. The default location uses '*' for the
+	// country code and will match all locations that are not matched by a geo location.
+	//
+	// The default geo location uses a * for the country code. All other country
+	// codes follow the ISO 3166 two-character code.
+	CountryCode *string `type:"string"`
+
+	// The code for a country's subdivision (e.g., a province of Canada). A subdivision
+	// code is only valid with the appropriate country code.
+	//
+	// Constraint: Specifying SubdivisionCode without CountryCode returns an InvalidInput
+	// error.
+	SubdivisionCode *string `type:"string"`
+
+	metadataGeoLocation `json:"-", xml:"-"`
+}
+
+type metadataGeoLocation struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains information about a GeoLocation.
+type GeoLocationDetails struct {
+	// The code for a continent geo location. Note: only continent locations have
+	// a continent code.
+	ContinentCode *string `type:"string"`
+
+	// The name of the continent. This element is only present if ContinentCode
+	// is also present.
+	ContinentName *string `type:"string"`
+
+	// The code for a country geo location. The default location uses '*' for the
+	// country code and will match all locations that are not matched by a geo location.
+	//
+	// The default geo location uses a * for the country code. All other country
+	// codes follow the ISO 3166 two-character code.
+	CountryCode *string `type:"string"`
+
+	// The name of the country. This element is only present if CountryCode is also
+	// present.
+	CountryName *string `type:"string"`
+
+	// The code for a country's subdivision (e.g., a province of Canada). A subdivision
+	// code is only valid with the appropriate country code.
+	SubdivisionCode *string `type:"string"`
+
+	// The name of the subdivision. This element is only present if SubdivisionCode
+	// is also present.
+	SubdivisionName *string `type:"string"`
+
+	metadataGeoLocationDetails `json:"-", xml:"-"`
+}
+
+type metadataGeoLocationDetails struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// The input for a GetChange request.
+type GetChangeInput struct {
+	// The ID of the change batch request. The value that you specify here is the
+	// value that ChangeResourceRecordSets returned in the Id element when you submitted
+	// the request.
+	ID *string `location:"uri" locationName:"Id" type:"string" required:"true"`
+
+	metadataGetChangeInput `json:"-", xml:"-"`
+}
+
+type metadataGetChangeInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains the ChangeInfo element.
+type GetChangeOutput struct {
+	// A complex type that contains information about the specified change batch,
+	// including the change batch ID, the status of the change, and the date and
+	// time of the request.
+	ChangeInfo *ChangeInfo `type:"structure" required:"true"`
+
+	metadataGetChangeOutput `json:"-", xml:"-"`
+}
+
+type metadataGetChangeOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// Empty request.
+type GetCheckerIPRangesInput struct {
+	metadataGetCheckerIPRangesInput `json:"-", xml:"-"`
+}
+
+type metadataGetCheckerIPRangesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains the CheckerIpRanges element.
+type GetCheckerIPRangesOutput struct {
+	// A complex type that contains sorted list of IP ranges in CIDR format for
+	// Amazon Route 53 health checkers.
+	CheckerIPRanges []*string `locationName:"CheckerIpRanges" type:"list" required:"true"`
+
+	metadataGetCheckerIPRangesOutput `json:"-", xml:"-"`
+}
+
+type metadataGetCheckerIPRangesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains information about the request to get a geo location.
+type GetGeoLocationInput struct {
+	// The code for a continent geo location. Note: only continent locations have
+	// a continent code.
+	//
+	// Valid values: AF | AN | AS | EU | OC | NA | SA
+	//
+	// Constraint: Specifying ContinentCode with either CountryCode or SubdivisionCode
+	// returns an InvalidInput error.
+	ContinentCode *string `location:"querystring" locationName:"continentcode" type:"string"`
+
+	// The code for a country geo location. The default location uses '*' for the
+	// country code and will match all locations that are not matched by a geo location.
+	//
+	// The default geo location uses a * for the country code. All other country
+	// codes follow the ISO 3166 two-character code.
+	CountryCode *string `location:"querystring" locationName:"countrycode" type:"string"`
+
+	// The code for a country's subdivision (e.g., a province of Canada). A subdivision
+	// code is only valid with the appropriate country code.
+	//
+	// Constraint: Specifying SubdivisionCode without CountryCode returns an InvalidInput
+	// error.
+	SubdivisionCode *string `location:"querystring" locationName:"subdivisioncode" type:"string"`
+
+	metadataGetGeoLocationInput `json:"-", xml:"-"`
+}
+
+type metadataGetGeoLocationInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type containing information about the specified geo location.
+type GetGeoLocationOutput struct {
+	// A complex type that contains the information about the specified geo location.
+	GeoLocationDetails *GeoLocationDetails `type:"structure" required:"true"`
+
+	metadataGetGeoLocationOutput `json:"-", xml:"-"`
+}
+
+type metadataGetGeoLocationOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// To retrieve a count of all your health checks, send a GET request to the
+// 2013-04-01/healthcheckcount resource.
+type GetHealthCheckCountInput struct {
+	metadataGetHealthCheckCountInput `json:"-", xml:"-"`
+}
+
+type metadataGetHealthCheckCountInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains the count of health checks associated with the
+// current AWS account.
+type GetHealthCheckCountOutput struct {
+	// The number of health checks associated with the current AWS account.
+	HealthCheckCount *int64 `type:"long" required:"true"`
+
+	metadataGetHealthCheckCountOutput `json:"-", xml:"-"`
+}
+
+type metadataGetHealthCheckCountOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains information about the request to get a health
+// check.
+type GetHealthCheckInput struct {
+	// The ID of the health check to retrieve.
+	HealthCheckID *string `location:"uri" locationName:"HealthCheckId" type:"string" required:"true"`
+
+	metadataGetHealthCheckInput `json:"-", xml:"-"`
+}
+
+type metadataGetHealthCheckInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains information about the request to get the most
+// recent failure reason for a health check.
+type GetHealthCheckLastFailureReasonInput struct {
+	// The ID of the health check for which you want to retrieve the reason for
+	// the most recent failure.
+	HealthCheckID *string `location:"uri" locationName:"HealthCheckId" type:"string" required:"true"`
+
+	metadataGetHealthCheckLastFailureReasonInput `json:"-", xml:"-"`
+}
+
+type metadataGetHealthCheckLastFailureReasonInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains information about the most recent failure for
+// the specified health check.
+type GetHealthCheckLastFailureReasonOutput struct {
+	// A list that contains one HealthCheckObservation element for each Route 53
+	// health checker.
+	HealthCheckObservations []*HealthCheckObservation `locationNameList:"HealthCheckObservation" type:"list" required:"true"`
+
+	metadataGetHealthCheckLastFailureReasonOutput `json:"-", xml:"-"`
+}
+
+type metadataGetHealthCheckLastFailureReasonOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type containing information about the specified health check.
+type GetHealthCheckOutput struct {
+	// A complex type that contains the information about the specified health check.
+	HealthCheck *HealthCheck `type:"structure" required:"true"`
+
+	metadataGetHealthCheckOutput `json:"-", xml:"-"`
+}
+
+type metadataGetHealthCheckOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains information about the request to get health
+// check status for a health check.
+type GetHealthCheckStatusInput struct {
+	// The ID of the health check for which you want to retrieve the most recent
+	// status.
+	HealthCheckID *string `location:"uri" locationName:"HealthCheckId" type:"string" required:"true"`
+
+	metadataGetHealthCheckStatusInput `json:"-", xml:"-"`
+}
+
+type metadataGetHealthCheckStatusInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains information about the status of the specified
+// health check.
+type GetHealthCheckStatusOutput struct {
+	// A list that contains one HealthCheckObservation element for each Route 53
+	// health checker.
+	HealthCheckObservations []*HealthCheckObservation `locationNameList:"HealthCheckObservation" type:"list" required:"true"`
+
+	metadataGetHealthCheckStatusOutput `json:"-", xml:"-"`
+}
+
+type metadataGetHealthCheckStatusOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// To retrieve a count of all your hosted zones, send a GET request to the 2013-04-01/hostedzonecount
+// resource.
+type GetHostedZoneCountInput struct {
+	metadataGetHostedZoneCountInput `json:"-", xml:"-"`
+}
+
+type metadataGetHostedZoneCountInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains the count of hosted zones associated with the
+// current AWS account.
+type GetHostedZoneCountOutput struct {
+	// The number of hosted zones associated with the current AWS account.
+	HostedZoneCount *int64 `type:"long" required:"true"`
+
+	metadataGetHostedZoneCountOutput `json:"-", xml:"-"`
+}
+
+type metadataGetHostedZoneCountOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// The input for a GetHostedZone request.
+type GetHostedZoneInput struct {
+	// The ID of the hosted zone for which you want to get a list of the name servers
+	// in the delegation set.
+	ID *string `location:"uri" locationName:"Id" type:"string" required:"true"`
+
+	metadataGetHostedZoneInput `json:"-", xml:"-"`
+}
+
+type metadataGetHostedZoneInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type containing information about the specified hosted zone.
+type GetHostedZoneOutput struct {
+	// A complex type that contains information about the name servers for the specified
+	// hosted zone.
+	DelegationSet *DelegationSet `type:"structure"`
+
+	// A complex type that contains the information about the specified hosted zone.
+	HostedZone *HostedZone `type:"structure" required:"true"`
+
+	// A complex type that contains information about VPCs associated with the specified
+	// hosted zone.
+	VPCs []*VPC `locationNameList:"VPC" type:"list"`
+
+	metadataGetHostedZoneOutput `json:"-", xml:"-"`
+}
+
+type metadataGetHostedZoneOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// The input for a GetReusableDelegationSet request.
+type GetReusableDelegationSetInput struct {
+	// The ID of the reusable delegation set for which you want to get a list of
+	// the name server.
+	ID *string `location:"uri" locationName:"Id" type:"string" required:"true"`
+
+	metadataGetReusableDelegationSetInput `json:"-", xml:"-"`
+}
+
+type metadataGetReusableDelegationSetInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type containing information about the specified reusable delegation
+// set.
+type GetReusableDelegationSetOutput struct {
+	// A complex type that contains the information about the nameservers for the
+	// specified delegation set ID.
+	DelegationSet *DelegationSet `type:"structure" required:"true"`
+
+	metadataGetReusableDelegationSetOutput `json:"-", xml:"-"`
+}
+
+type metadataGetReusableDelegationSetOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains identifying information about the health check.
+type HealthCheck struct {
+	// A unique string that identifies the request to create the health check.
+	CallerReference *string `type:"string" required:"true"`
+
+	// A complex type that contains the health check configuration.
+	HealthCheckConfig *HealthCheckConfig `type:"structure" required:"true"`
+
+	// The version of the health check. You can optionally pass this value in a
+	// call to UpdateHealthCheck to prevent overwriting another change to the health
+	// check.
+	HealthCheckVersion *int64 `type:"long" required:"true"`
+
+	// The ID of the specified health check.
+	ID *string `locationName:"Id" type:"string" required:"true"`
+
+	metadataHealthCheck `json:"-", xml:"-"`
+}
+
+type metadataHealthCheck struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains the health check configuration.
+type HealthCheckConfig struct {
+	// The number of consecutive health checks that an endpoint must pass or fail
+	// for Route 53 to change the current status of the endpoint from unhealthy
+	// to healthy or vice versa.
+	//
+	// Valid values are integers between 1 and 10. For more information, see "How
+	// Amazon Route 53 Determines Whether an Endpoint Is Healthy" in the Amazon
+	// Route 53 Developer Guide.
+	FailureThreshold *int64 `type:"integer"`
+
+	// Fully qualified domain name of the instance to be health checked.
+	FullyQualifiedDomainName *string `type:"string"`
+
+	// IP Address of the instance being checked.
+	IPAddress *string `type:"string"`
+
+	// Port on which connection will be opened to the instance to health check.
+	// For HTTP and HTTP_STR_MATCH this defaults to 80 if the port is not specified.
+	// For HTTPS and HTTPS_STR_MATCH this defaults to 443 if the port is not specified.
+	Port *int64 `type:"integer"`
+
+	// The number of seconds between the time that Route 53 gets a response from
+	// your endpoint and the time that it sends the next health-check request.
+	//
+	// Each Route 53 health checker makes requests at this interval. Valid values
+	// are 10 and 30. The default value is 30.
+	RequestInterval *int64 `type:"integer"`
+
+	// Path to ping on the instance to check the health. Required for HTTP, HTTPS,
+	// HTTP_STR_MATCH, and HTTPS_STR_MATCH health checks, HTTP request is issued
+	// to the instance on the given port and path.
+	ResourcePath *string `type:"string"`
+
+	// A string to search for in the body of a health check response. Required for
+	// HTTP_STR_MATCH and HTTPS_STR_MATCH health checks.
+	SearchString *string `type:"string"`
+
+	// The type of health check to be performed. Currently supported types are TCP,
+	// HTTP, HTTPS, HTTP_STR_MATCH, and HTTPS_STR_MATCH.
+	Type *string `type:"string" required:"true"`
+
+	metadataHealthCheckConfig `json:"-", xml:"-"`
+}
+
+type metadataHealthCheckConfig struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains the IP address of a Route 53 health checker
+// and the reason for the health check status.
+type HealthCheckObservation struct {
+	// The IP address of the Route 53 health checker that performed the health check.
+	IPAddress *string `type:"string"`
+
+	// A complex type that contains information about the health check status for
+	// the current observation.
+	StatusReport *StatusReport `type:"structure"`
+
+	metadataHealthCheckObservation `json:"-", xml:"-"`
+}
+
+type metadataHealthCheckObservation struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contain information about the specified hosted zone.
+type HostedZone struct {
+	// A unique string that identifies the request to create the hosted zone.
+	CallerReference *string `type:"string" required:"true"`
+
+	// A complex type that contains the Comment element.
+	Config *HostedZoneConfig `type:"structure"`
+
+	// The ID of the specified hosted zone.
+	ID *string `locationName:"Id" type:"string" required:"true"`
+
+	// The name of the domain. This must be a fully-specified domain, for example,
+	// www.example.com. The trailing dot is optional; Route 53 assumes that the
+	// domain name is fully qualified. This means that Route 53 treats www.example.com
+	// (without a trailing dot) and www.example.com. (with a trailing dot) as identical.
+	//
+	// This is the name you have registered with your DNS registrar. You should
+	// ask your registrar to change the authoritative name servers for your domain
+	// to the set of NameServers elements returned in DelegationSet.
+	Name *string `type:"string" required:"true"`
+
+	// Total number of resource record sets in the hosted zone.
+	ResourceRecordSetCount *int64 `type:"long"`
+
+	metadataHostedZone `json:"-", xml:"-"`
+}
+
+type metadataHostedZone struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains an optional comment about your hosted zone.
+// If you don't want to specify a comment, you can omit the HostedZoneConfig
+// and Comment elements from the XML document.
+type HostedZoneConfig struct {
+	// An optional comment about your hosted zone. If you don't want to specify
+	// a comment, you can omit the HostedZoneConfig and Comment elements from the
+	// XML document.
+	Comment *string `type:"string"`
+
+	// A value that indicates whether this is a private hosted zone. The value is
+	// returned in the response; do not specify it in the request.
+	PrivateZone *bool `type:"boolean"`
+
+	metadataHostedZoneConfig `json:"-", xml:"-"`
+}
+
+type metadataHostedZoneConfig struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// The input for a ListGeoLocations request.
+type ListGeoLocationsInput struct {
+	// The maximum number of geo locations you want in the response body.
+	MaxItems *string `location:"querystring" locationName:"maxitems" type:"string"`
+
+	// The first continent code in the lexicographic ordering of geo locations that
+	// you want the ListGeoLocations request to list. For non-continent geo locations,
+	// this should be null.
+	//
+	// Valid values: AF | AN | AS | EU | OC | NA | SA
+	//
+	// Constraint: Specifying ContinentCode with either CountryCode or SubdivisionCode
+	// returns an InvalidInput error.
+	StartContinentCode *string `location:"querystring" locationName:"startcontinentcode" type:"string"`
+
+	// The first country code in the lexicographic ordering of geo locations that
+	// you want the ListGeoLocations request to list.
+	//
+	// The default geo location uses a * for the country code. All other country
+	// codes follow the ISO 3166 two-character code.
+	StartCountryCode *string `location:"querystring" locationName:"startcountrycode" type:"string"`
+
+	// The first subdivision code in the lexicographic ordering of geo locations
+	// that you want the ListGeoLocations request to list.
+	//
+	// Constraint: Specifying SubdivisionCode without CountryCode returns an InvalidInput
+	// error.
+	StartSubdivisionCode *string `location:"querystring" locationName:"startsubdivisioncode" type:"string"`
+
+	metadataListGeoLocationsInput `json:"-", xml:"-"`
+}
+
+type metadataListGeoLocationsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains information about the geo locations that are
+// returned by the request and information about the response.
+type ListGeoLocationsOutput struct {
+	// A complex type that contains information about the geo locations that are
+	// returned by the request.
+	GeoLocationDetailsList []*GeoLocationDetails `locationNameList:"GeoLocationDetails" type:"list" required:"true"`
+
+	// A flag that indicates whether there are more geo locations to be listed.
+	// If your results were truncated, you can make a follow-up request for the
+	// next page of results by using the values included in the ListGeoLocationsResponse$NextContinentCode,
+	// ListGeoLocationsResponse$NextCountryCode and ListGeoLocationsResponse$NextSubdivisionCode
+	// elements.
+	//
+	// Valid Values: true | false
+	IsTruncated *bool `type:"boolean" required:"true"`
+
+	// The maximum number of records you requested. The maximum value of MaxItems
+	// is 100.
+	MaxItems *string `type:"string" required:"true"`
+
+	// If the results were truncated, the continent code of the next geo location
+	// in the list. This element is present only if ListGeoLocationsResponse$IsTruncated
+	// is true and the next geo location to list is a continent location.
+	NextContinentCode *string `type:"string"`
+
+	// If the results were truncated, the country code of the next geo location
+	// in the list. This element is present only if ListGeoLocationsResponse$IsTruncated
+	// is true and the next geo location to list is not a continent location.
+	NextCountryCode *string `type:"string"`
+
+	// If the results were truncated, the subdivision code of the next geo location
+	// in the list. This element is present only if ListGeoLocationsResponse$IsTruncated
+	// is true and the next geo location has a subdivision.
+	NextSubdivisionCode *string `type:"string"`
+
+	metadataListGeoLocationsOutput `json:"-", xml:"-"`
+}
+
+type metadataListGeoLocationsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// To retrieve a list of your health checks, send a GET request to the 2013-04-01/healthcheck
+// resource. The response to this request includes a HealthChecks element with
+// zero or more HealthCheck child elements. By default, the list of health checks
+// is displayed on a single page. You can control the length of the page that
+// is displayed by using the MaxItems parameter. You can use the Marker parameter
+// to control the health check that the list begins with.
+//
+//  Route 53 returns a maximum of 100 items. If you set MaxItems to a value
+// greater than 100, Route 53 returns only the first 100.
+type ListHealthChecksInput struct {
+	// If the request returned more than one page of results, submit another request
+	// and specify the value of NextMarker from the last response in the marker
+	// parameter to get the next page of results.
+	Marker *string `location:"querystring" locationName:"marker" type:"string"`
+
+	// Specify the maximum number of health checks to return per page of results.
+	MaxItems *string `location:"querystring" locationName:"maxitems" type:"string"`
+
+	metadataListHealthChecksInput `json:"-", xml:"-"`
+}
+
+type metadataListHealthChecksInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains the response for the request.
+type ListHealthChecksOutput struct {
+	// A complex type that contains information about the health checks associated
+	// with the current AWS account.
+	HealthChecks []*HealthCheck `locationNameList:"HealthCheck" type:"list" required:"true"`
+
+	// A flag indicating whether there are more health checks to be listed. If your
+	// results were truncated, you can make a follow-up request for the next page
+	// of results by using the Marker element.
+	//
+	// Valid Values: true | false
+	IsTruncated *bool `type:"boolean" required:"true"`
+
+	// If the request returned more than one page of results, submit another request
+	// and specify the value of NextMarker from the last response in the marker
+	// parameter to get the next page of results.
+	Marker *string `type:"string" required:"true"`
+
+	// The maximum number of health checks to be included in the response body.
+	// If the number of health checks associated with this AWS account exceeds MaxItems,
+	// the value of ListHealthChecksResponse$IsTruncated in the response is true.
+	// Call ListHealthChecks again and specify the value of ListHealthChecksResponse$NextMarker
+	// in the ListHostedZonesRequest$Marker element to get the next page of results.
+	MaxItems *string `type:"string" required:"true"`
+
+	// Indicates where to continue listing health checks. If ListHealthChecksResponse$IsTruncated
+	// is true, make another request to ListHealthChecks and include the value of
+	// the NextMarker element in the Marker element to get the next page of results.
+	NextMarker *string `type:"string"`
+
+	metadataListHealthChecksOutput `json:"-", xml:"-"`
+}
+
+type metadataListHealthChecksOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// To retrieve a list of your hosted zones in lexicographic order, send a GET
+// request to the 2013-04-01/hostedzonesbyname resource. The response to this
+// request includes a HostedZones element with zero or more HostedZone child
+// elements lexicographically ordered by DNS name. By default, the list of hosted
+// zones is displayed on a single page. You can control the length of the page
+// that is displayed by using the MaxItems parameter. You can use the DNSName
+// and HostedZoneId parameters to control the hosted zone that the list begins
+// with.
+//
+// For more information about listing hosted zones, see Listing the Hosted
+// Zones for an AWS Account (http://docs.amazonwebservices.com/Route53/latest/DeveloperGuide/ListInfoOnHostedZone.html)
+// in the Amazon Route 53 Developer Guide.
+type ListHostedZonesByNameInput struct {
+	// The first name in the lexicographic ordering of domain names that you want
+	// the ListHostedZonesByNameRequest request to list.
+	//
+	// If the request returned more than one page of results, submit another request
+	// and specify the value of NextDNSName and NextHostedZoneId from the last response
+	// in the DNSName and HostedZoneId parameters to get the next page of results.
+	DNSName *string `location:"querystring" locationName:"dnsname" type:"string"`
+
+	// If the request returned more than one page of results, submit another request
+	// and specify the value of NextDNSName and NextHostedZoneId from the last response
+	// in the DNSName and HostedZoneId parameters to get the next page of results.
+	HostedZoneID *string `location:"querystring" locationName:"hostedzoneid" type:"string"`
+
+	// Specify the maximum number of hosted zones to return per page of results.
+	MaxItems *string `location:"querystring" locationName:"maxitems" type:"string"`
+
+	metadataListHostedZonesByNameInput `json:"-", xml:"-"`
+}
+
+type metadataListHostedZonesByNameInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains the response for the request.
+type ListHostedZonesByNameOutput struct {
+	// The DNSName value sent in the request.
+	DNSName *string `type:"string"`
+
+	// The HostedZoneId value sent in the request.
+	HostedZoneID *string `locationName:"HostedZoneId" type:"string"`
+
+	// A complex type that contains information about the hosted zones associated
+	// with the current AWS account.
+	HostedZones []*HostedZone `locationNameList:"HostedZone" type:"list" required:"true"`
+
+	// A flag indicating whether there are more hosted zones to be listed. If your
+	// results were truncated, you can make a follow-up request for the next page
+	// of results by using the NextDNSName and NextHostedZoneId elements.
+	//
+	// Valid Values: true | false
+	IsTruncated *bool `type:"boolean" required:"true"`
+
+	// The maximum number of hosted zones to be included in the response body. If
+	// the number of hosted zones associated with this AWS account exceeds MaxItems,
+	// the value of ListHostedZonesByNameResponse$IsTruncated in the response is
+	// true. Call ListHostedZonesByName again and specify the value of ListHostedZonesByNameResponse$NextDNSName
+	// and ListHostedZonesByNameResponse$NextHostedZoneId elements respectively
+	// to get the next page of results.
+	MaxItems *string `type:"string" required:"true"`
+
+	// If ListHostedZonesByNameResponse$IsTruncated is true, there are more hosted
+	// zones associated with the current AWS account. To get the next page of results,
+	// make another request to ListHostedZonesByName. Specify the value of ListHostedZonesByNameResponse$NextDNSName
+	// in the ListHostedZonesByNameRequest$DNSName element and ListHostedZonesByNameResponse$NextHostedZoneId
+	// in the ListHostedZonesByNameRequest$HostedZoneId element.
+	NextDNSName *string `type:"string"`
+
+	// If ListHostedZonesByNameResponse$IsTruncated is true, there are more hosted
+	// zones associated with the current AWS account. To get the next page of results,
+	// make another request to ListHostedZonesByName. Specify the value of ListHostedZonesByNameResponse$NextDNSName
+	// in the ListHostedZonesByNameRequest$DNSName element and ListHostedZonesByNameResponse$NextHostedZoneId
+	// in the ListHostedZonesByNameRequest$HostedZoneId element.
+	NextHostedZoneID *string `locationName:"NextHostedZoneId" type:"string"`
+
+	metadataListHostedZonesByNameOutput `json:"-", xml:"-"`
+}
+
+type metadataListHostedZonesByNameOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// To retrieve a list of your hosted zones, send a GET request to the 2013-04-01/hostedzone
+// resource. The response to this request includes a HostedZones element with
+// zero or more HostedZone child elements. By default, the list of hosted zones
+// is displayed on a single page. You can control the length of the page that
+// is displayed by using the MaxItems parameter. You can use the Marker parameter
+// to control the hosted zone that the list begins with. For more information
+// about listing hosted zones, see Listing the Hosted Zones for an AWS Account
+// (http://docs.amazonwebservices.com/Route53/latest/DeveloperGuide/ListInfoOnHostedZone.html)
+// in the Amazon Route 53 Developer Guide.
+//
+//  Route 53 returns a maximum of 100 items. If you set MaxItems to a value
+// greater than 100, Route 53 returns only the first 100.
+type ListHostedZonesInput struct {
+	DelegationSetID *string `location:"querystring" locationName:"delegationsetid" type:"string"`
+
+	// If the request returned more than one page of results, submit another request
+	// and specify the value of NextMarker from the last response in the marker
+	// parameter to get the next page of results.
+	Marker *string `location:"querystring" locationName:"marker" type:"string"`
+
+	// Specify the maximum number of hosted zones to return per page of results.
+	MaxItems *string `location:"querystring" locationName:"maxitems" type:"string"`
+
+	metadataListHostedZonesInput `json:"-", xml:"-"`
+}
+
+type metadataListHostedZonesInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains the response for the request.
+type ListHostedZonesOutput struct {
+	// A complex type that contains information about the hosted zones associated
+	// with the current AWS account.
+	HostedZones []*HostedZone `locationNameList:"HostedZone" type:"list" required:"true"`
+
+	// A flag indicating whether there are more hosted zones to be listed. If your
+	// results were truncated, you can make a follow-up request for the next page
+	// of results by using the Marker element.
+	//
+	// Valid Values: true | false
+	IsTruncated *bool `type:"boolean" required:"true"`
+
+	// If the request returned more than one page of results, submit another request
+	// and specify the value of NextMarker from the last response in the marker
+	// parameter to get the next page of results.
+	Marker *string `type:"string" required:"true"`
+
+	// The maximum number of hosted zones to be included in the response body. If
+	// the number of hosted zones associated with this AWS account exceeds MaxItems,
+	// the value of ListHostedZonesResponse$IsTruncated in the response is true.
+	// Call ListHostedZones again and specify the value of ListHostedZonesResponse$NextMarker
+	// in the ListHostedZonesRequest$Marker element to get the next page of results.
+	MaxItems *string `type:"string" required:"true"`
+
+	// Indicates where to continue listing hosted zones. If ListHostedZonesResponse$IsTruncated
+	// is true, make another request to ListHostedZones and include the value of
+	// the NextMarker element in the Marker element to get the next page of results.
+	NextMarker *string `type:"string"`
+
+	metadataListHostedZonesOutput `json:"-", xml:"-"`
+}
+
+type metadataListHostedZonesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// The input for a ListResourceRecordSets request.
+type ListResourceRecordSetsInput struct {
+	// The ID of the hosted zone that contains the resource record sets that you
+	// want to get.
+	HostedZoneID *string `location:"uri" locationName:"Id" type:"string" required:"true"`
+
+	// The maximum number of records you want in the response body.
+	MaxItems *string `location:"querystring" locationName:"maxitems" type:"string"`
+
+	// Weighted resource record sets only: If results were truncated for a given
+	// DNS name and type, specify the value of ListResourceRecordSetsResponse$NextRecordIdentifier
+	// from the previous response to get the next resource record set that has the
+	// current DNS name and type.
+	StartRecordIdentifier *string `location:"querystring" locationName:"identifier" type:"string"`
+
+	// The first name in the lexicographic ordering of domain names that you want
+	// the ListResourceRecordSets request to list.
+	StartRecordName *string `location:"querystring" locationName:"name" type:"string"`
+
+	// The DNS type at which to begin the listing of resource record sets.
+	//
+	// Valid values: A | AAAA | CNAME | MX | NS | PTR | SOA | SPF | SRV | TXT
+	//
+	// Values for Weighted Resource Record Sets: A | AAAA | CNAME | TXT
+	//
+	//  Values for Regional Resource Record Sets: A | AAAA | CNAME | TXT
+	//
+	// Values for Alias Resource Record Sets: A | AAAA
+	//
+	// Constraint: Specifying type without specifying name returns an InvalidInput
+	// error.
+	StartRecordType *string `location:"querystring" locationName:"type" type:"string"`
+
+	metadataListResourceRecordSetsInput `json:"-", xml:"-"`
+}
+
+type metadataListResourceRecordSetsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains information about the resource record sets that
+// are returned by the request and information about the response.
+type ListResourceRecordSetsOutput struct {
+	// A flag that indicates whether there are more resource record sets to be listed.
+	// If your results were truncated, you can make a follow-up request for the
+	// next page of results by using the ListResourceRecordSetsResponse$NextRecordName
+	// element.
+	//
+	// Valid Values: true | false
+	IsTruncated *bool `type:"boolean" required:"true"`
+
+	// The maximum number of records you requested. The maximum value of MaxItems
+	// is 100.
+	MaxItems *string `type:"string" required:"true"`
+
+	// Weighted resource record sets only: If results were truncated for a given
+	// DNS name and type, the value of SetIdentifier for the next resource record
+	// set that has the current DNS name and type.
+	NextRecordIdentifier *string `type:"string"`
+
+	// If the results were truncated, the name of the next record in the list. This
+	// element is present only if ListResourceRecordSetsResponse$IsTruncated is
+	// true.
+	NextRecordName *string `type:"string"`
+
+	// If the results were truncated, the type of the next record in the list. This
+	// element is present only if ListResourceRecordSetsResponse$IsTruncated is
+	// true.
+	NextRecordType *string `type:"string"`
+
+	// A complex type that contains information about the resource record sets that
+	// are returned by the request.
+	ResourceRecordSets []*ResourceRecordSet `locationNameList:"ResourceRecordSet" type:"list" required:"true"`
+
+	metadataListResourceRecordSetsOutput `json:"-", xml:"-"`
+}
+
+type metadataListResourceRecordSetsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// To retrieve a list of your reusable delegation sets, send a GET request to
+// the 2013-04-01/delegationset resource. The response to this request includes
+// a DelegationSets element with zero or more DelegationSet child elements.
+// By default, the list of reusable delegation sets is displayed on a single
+// page. You can control the length of the page that is displayed by using the
+// MaxItems parameter. You can use the Marker parameter to control the delegation
+// set that the list begins with.
+//
+//  Route 53 returns a maximum of 100 items. If you set MaxItems to a value
+// greater than 100, Route 53 returns only the first 100.
+type ListReusableDelegationSetsInput struct {
+	// If the request returned more than one page of results, submit another request
+	// and specify the value of NextMarker from the last response in the marker
+	// parameter to get the next page of results.
+	Marker *string `location:"querystring" locationName:"marker" type:"string"`
+
+	// Specify the maximum number of reusable delegation sets to return per page
+	// of results.
+	MaxItems *string `location:"querystring" locationName:"maxitems" type:"string"`
+
+	metadataListReusableDelegationSetsInput `json:"-", xml:"-"`
+}
+
+type metadataListReusableDelegationSetsInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains the response for the request.
+type ListReusableDelegationSetsOutput struct {
+	// A complex type that contains information about the reusable delegation sets
+	// associated with the current AWS account.
+	DelegationSets []*DelegationSet `locationNameList:"DelegationSet" type:"list" required:"true"`
+
+	// A flag indicating whether there are more reusable delegation sets to be listed.
+	// If your results were truncated, you can make a follow-up request for the
+	// next page of results by using the Marker element.
+	//
+	// Valid Values: true | false
+	IsTruncated *bool `type:"boolean" required:"true"`
+
+	// If the request returned more than one page of results, submit another request
+	// and specify the value of NextMarker from the last response in the marker
+	// parameter to get the next page of results.
+	Marker *string `type:"string" required:"true"`
+
+	// The maximum number of reusable delegation sets to be included in the response
+	// body. If the number of reusable delegation sets associated with this AWS
+	// account exceeds MaxItems, the value of ListReusablDelegationSetsResponse$IsTruncated
+	// in the response is true. Call ListReusableDelegationSets again and specify
+	// the value of ListReusableDelegationSetsResponse$NextMarker in the ListReusableDelegationSetsRequest$Marker
+	// element to get the next page of results.
+	MaxItems *string `type:"string" required:"true"`
+
+	// Indicates where to continue listing reusable delegation sets. If ListReusableDelegationSetsResponse$IsTruncated
+	// is true, make another request to ListReusableDelegationSets and include the
+	// value of the NextMarker element in the Marker element to get the next page
+	// of results.
+	NextMarker *string `type:"string"`
+
+	metadataListReusableDelegationSetsOutput `json:"-", xml:"-"`
+}
+
+type metadataListReusableDelegationSetsOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type containing information about a request for a list of the tags
+// that are associated with an individual resource.
+type ListTagsForResourceInput struct {
+	// The ID of the resource for which you want to retrieve tags.
+	ResourceID *string `location:"uri" locationName:"ResourceId" type:"string" required:"true"`
+
+	// The type of the resource.
+	//
+	// - The resource type for health checks is healthcheck.
+	//
+	// - The resource type for hosted zones is hostedzone.
+	ResourceType *string `location:"uri" locationName:"ResourceType" type:"string" required:"true"`
+
+	metadataListTagsForResourceInput `json:"-", xml:"-"`
+}
+
+type metadataListTagsForResourceInput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type containing tags for the specified resource.
+type ListTagsForResourceOutput struct {
+	// A ResourceTagSet containing tags associated with the specified resource.
+	ResourceTagSet *ResourceTagSet `type:"structure" required:"true"`
+
+	metadataListTagsForResourceOutput `json:"-", xml:"-"`
+}
+
+type metadataListTagsForResourceOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type containing information about a request for a list of the tags
+// that are associated with up to 10 specified resources.
+type ListTagsForResourcesInput struct {
+	// A complex type that contains the ResourceId element for each resource for
+	// which you want to get a list of tags.
+	ResourceIDs []*string `locationName:"ResourceIds" locationNameList:"ResourceId" type:"list" required:"true"`
+
+	// The type of the resources.
+	//
+	// - The resource type for health checks is healthcheck.
+	//
+	// - The resource type for hosted zones is hostedzone.
+	ResourceType *string `location:"uri" locationName:"ResourceType" type:"string" required:"true"`
+
+	metadataListTagsForResourcesInput `json:"-", xml:"-"`
+}
+
+type metadataListTagsForResourcesInput struct {
+	SDKShapeTraits bool `locationName:"ListTagsForResourcesRequest" type:"structure" xmlURI:"https://route53.amazonaws.com/doc/2013-04-01/"`
+}
+
+// A complex type containing tags for the specified resources.
+type ListTagsForResourcesOutput struct {
+	// A list of ResourceTagSets containing tags associated with the specified resources.
+	ResourceTagSets []*ResourceTagSet `locationNameList:"ResourceTagSet" type:"list" required:"true"`
+
+	metadataListTagsForResourcesOutput `json:"-", xml:"-"`
+}
+
+type metadataListTagsForResourcesOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains the value of the Value element for the current
+// resource record set.
+type ResourceRecord struct {
+	// The value of the Value element for the current resource record set.
+	Value *string `type:"string" required:"true"`
+
+	metadataResourceRecord `json:"-", xml:"-"`
+}
+
+type metadataResourceRecord struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains information about the current resource record
+// set.
+type ResourceRecordSet struct {
+	// Alias resource record sets only: Information about the AWS resource to which
+	// you are redirecting traffic.
+	AliasTarget *AliasTarget `type:"structure"`
+
+	// Failover resource record sets only: Among resource record sets that have
+	// the same combination of DNS name and type, a value that indicates whether
+	// the current resource record set is a primary or secondary resource record
+	// set. A failover set may contain at most one resource record set marked as
+	// primary and one resource record set marked as secondary. A resource record
+	// set marked as primary will be returned if any of the following are true:
+	// (1) an associated health check is passing, (2) if the resource record set
+	// is an alias with the evaluate target health and at least one target resource
+	// record set is healthy, (3) both the primary and secondary resource record
+	// set are failing health checks or (4) there is no secondary resource record
+	// set. A secondary resource record set will be returned if: (1) the primary
+	// is failing a health check and either the secondary is passing a health check
+	// or has no associated health check, or (2) there is no primary resource record
+	// set.
+	//
+	// Valid values: PRIMARY | SECONDARY
+	Failover *string `type:"string"`
+
+	// Geo location resource record sets only: Among resource record sets that have
+	// the same combination of DNS name and type, a value that specifies the geo
+	// location for the current resource record set.
+	GeoLocation *GeoLocation `type:"structure"`
+
+	// Health Check resource record sets only, not required for alias resource record
+	// sets: An identifier that is used to identify health check associated with
+	// the resource record set.
+	HealthCheckID *string `locationName:"HealthCheckId" type:"string"`
+
+	// The domain name of the current resource record set.
+	Name *string `type:"string" required:"true"`
+
+	// Latency-based resource record sets only: Among resource record sets that
+	// have the same combination of DNS name and type, a value that specifies the
+	// AWS region for the current resource record set.
+	Region *string `type:"string"`
+
+	// A complex type that contains the resource records for the current resource
+	// record set.
+	ResourceRecords []*ResourceRecord `locationNameList:"ResourceRecord" type:"list"`
+
+	// Weighted, Latency, Geo, and Failover resource record sets only: An identifier
+	// that differentiates among multiple resource record sets that have the same
+	// combination of DNS name and type.
+	SetIdentifier *string `type:"string"`
+
+	// The cache time to live for the current resource record set.
+	TTL *int64 `type:"long"`
+
+	// The type of the current resource record set.
+	Type *string `type:"string" required:"true"`
+
+	// Weighted resource record sets only: Among resource record sets that have
+	// the same combination of DNS name and type, a value that determines what portion
+	// of traffic for the current resource record set is routed to the associated
+	// location.
+	Weight *int64 `type:"long"`
+
+	metadataResourceRecordSet `json:"-", xml:"-"`
+}
+
+type metadataResourceRecordSet struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type containing a resource and its associated tags.
+type ResourceTagSet struct {
+	// The ID for the specified resource.
+	ResourceID *string `locationName:"ResourceId" type:"string"`
+
+	// The type of the resource.
+	//
+	// - The resource type for health checks is healthcheck.
+	//
+	// - The resource type for hosted zones is hostedzone.
+	ResourceType *string `type:"string"`
+
+	// The tags associated with the specified resource.
+	Tags []*Tag `locationNameList:"Tag" type:"list"`
+
+	metadataResourceTagSet `json:"-", xml:"-"`
+}
+
+type metadataResourceTagSet struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains information about the health check status for
+// the current observation.
+type StatusReport struct {
+	// The date and time the health check status was observed, in the format YYYY-MM-DDThh:mm:ssZ,
+	// as specified in the ISO 8601 standard (for example, 2009-11-19T19:37:58Z).
+	// The Z after the time indicates that the time is listed in Coordinated Universal
+	// Time (UTC), which is synonymous with Greenwich Mean Time in this context.
+	CheckedTime *time.Time `type:"timestamp" timestampFormat:"iso8601"`
+
+	// The observed health check status.
+	Status *string `type:"string"`
+
+	metadataStatusReport `json:"-", xml:"-"`
+}
+
+type metadataStatusReport struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A single tag containing a key and value.
+type Tag struct {
+	// The key for a Tag.
+	Key *string `type:"string"`
+
+	// The value for a Tag.
+	Value *string `type:"string"`
+
+	metadataTag `json:"-", xml:"-"`
+}
+
+type metadataTag struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// >A complex type that contains information about the request to update a health
+// check.
+type UpdateHealthCheckInput struct {
+	// The number of consecutive health checks that an endpoint must pass or fail
+	// for Route 53 to change the current status of the endpoint from unhealthy
+	// to healthy or vice versa.
+	//
+	// Valid values are integers between 1 and 10. For more information, see "How
+	// Amazon Route 53 Determines Whether an Endpoint Is Healthy" in the Amazon
+	// Route 53 Developer Guide.
+	//
+	// Specify this value only if you want to change it.
+	FailureThreshold *int64 `type:"integer"`
+
+	// Fully qualified domain name of the instance to be health checked.
+	//
+	// Specify this value only if you want to change it.
+	FullyQualifiedDomainName *string `type:"string"`
+
+	// The ID of the health check to update.
+	HealthCheckID *string `location:"uri" locationName:"HealthCheckId" type:"string" required:"true"`
+
+	// Optional. When you specify a health check version, Route 53 compares this
+	// value with the current value in the health check, which prevents you from
+	// updating the health check when the versions don't match. Using HealthCheckVersion
+	// lets you prevent overwriting another change to the health check.
+	HealthCheckVersion *int64 `type:"long"`
+
+	// The IP address of the resource that you want to check.
+	//
+	// Specify this value only if you want to change it.
+	IPAddress *string `type:"string"`
+
+	// The port on which you want Route 53 to open a connection to perform health
+	// checks.
+	//
+	// Specify this value only if you want to change it.
+	Port *int64 `type:"integer"`
+
+	// The path that you want Amazon Route 53 to request when performing health
+	// checks. The path can be any value for which your endpoint will return an
+	// HTTP status code of 2xx or 3xx when the endpoint is healthy, for example
+	// the file /docs/route53-health-check.html.
+	//
+	// Specify this value only if you want to change it.
+	ResourcePath *string `type:"string"`
+
+	// If the value of Type is HTTP_STR_MATCH or HTTP_STR_MATCH, the string that
+	// you want Route 53 to search for in the response body from the specified resource.
+	// If the string appears in the response body, Route 53 considers the resource
+	// healthy.
+	//
+	// Specify this value only if you want to change it.
+	SearchString *string `type:"string"`
+
+	metadataUpdateHealthCheckInput `json:"-", xml:"-"`
+}
+
+type metadataUpdateHealthCheckInput struct {
+	SDKShapeTraits bool `locationName:"UpdateHealthCheckRequest" type:"structure" xmlURI:"https://route53.amazonaws.com/doc/2013-04-01/"`
+}
+
+type UpdateHealthCheckOutput struct {
+	// A complex type that contains identifying information about the health check.
+	HealthCheck *HealthCheck `type:"structure" required:"true"`
+
+	metadataUpdateHealthCheckOutput `json:"-", xml:"-"`
+}
+
+type metadataUpdateHealthCheckOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+// A complex type that contains information about the request to update a hosted
+// zone comment.
+type UpdateHostedZoneCommentInput struct {
+	// A comment about your hosted zone.
+	Comment *string `type:"string"`
+
+	// The ID of the hosted zone you want to update.
+	ID *string `location:"uri" locationName:"Id" type:"string" required:"true"`
+
+	metadataUpdateHostedZoneCommentInput `json:"-", xml:"-"`
+}
+
+type metadataUpdateHostedZoneCommentInput struct {
+	SDKShapeTraits bool `locationName:"UpdateHostedZoneCommentRequest" type:"structure" xmlURI:"https://route53.amazonaws.com/doc/2013-04-01/"`
+}
+
+// A complex type containing information about the specified hosted zone after
+// the update.
+type UpdateHostedZoneCommentOutput struct {
+	// A complex type that contain information about the specified hosted zone.
+	HostedZone *HostedZone `type:"structure" required:"true"`
+
+	metadataUpdateHostedZoneCommentOutput `json:"-", xml:"-"`
+}
+
+type metadataUpdateHostedZoneCommentOutput struct {
+	SDKShapeTraits bool `type:"structure"`
+}
+
+type VPC struct {
+	// A VPC ID
+	VPCID *string `locationName:"VPCId" type:"string"`
+
+	VPCRegion *string `type:"string"`
+
+	metadataVPC `json:"-", xml:"-"`
+}
+
+type metadataVPC struct {
+	SDKShapeTraits bool `type:"structure"`
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/route53/customizations.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/route53/customizations.go
new file mode 100644
index 000000000..341e20d81
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/route53/customizations.go
@@ -0,0 +1,20 @@
+package route53
+
+import (
+	"regexp"
+
+	"github.com/awslabs/aws-sdk-go/aws"
+)
+
+func init() {
+	initService = func(s *aws.Service) {
+		s.Handlers.Build.PushBack(sanitizeURL)
+	}
+}
+
+var reSanitizeURL = regexp.MustCompile(`\/%2F\w+%2F`)
+
+func sanitizeURL(r *aws.Request) {
+	r.HTTPRequest.URL.Opaque =
+		reSanitizeURL.ReplaceAllString(r.HTTPRequest.URL.Opaque, "/")
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/route53/customizations_test.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/route53/customizations_test.go
new file mode 100644
index 000000000..f0fe7e954
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/route53/customizations_test.go
@@ -0,0 +1,20 @@
+package route53_test
+
+import (
+	"testing"
+
+	"github.com/awslabs/aws-sdk-go/aws"
+	"github.com/awslabs/aws-sdk-go/internal/util/utilassert"
+	"github.com/awslabs/aws-sdk-go/service/route53"
+)
+
+func TestBuildCorrectURI(t *testing.T) {
+	svc := route53.New(nil)
+	req, _ := svc.GetHostedZoneRequest(&route53.GetHostedZoneInput{
+		ID: aws.String("/hostedzone/ABCDEFG"),
+	})
+
+	req.Build()
+
+	utilassert.Match(t, `\/hostedzone\/ABCDEFG$`, req.HTTPRequest.URL.String())
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/route53/examples_test.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/route53/examples_test.go
new file mode 100644
index 000000000..5584c5d6b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/route53/examples_test.go
@@ -0,0 +1,714 @@
+package route53_test
+
+import (
+	"bytes"
+	"fmt"
+	"time"
+
+	"github.com/awslabs/aws-sdk-go/aws"
+	"github.com/awslabs/aws-sdk-go/aws/awsutil"
+	"github.com/awslabs/aws-sdk-go/service/route53"
+)
+
+var _ time.Duration
+var _ bytes.Buffer
+
+func ExampleRoute53_AssociateVPCWithHostedZone() {
+	svc := route53.New(nil)
+
+	params := &route53.AssociateVPCWithHostedZoneInput{
+		HostedZoneID: aws.String("ResourceId"), // Required
+		VPC: &route53.VPC{ // Required
+			VPCID:     aws.String("VPCId"),
+			VPCRegion: aws.String("VPCRegion"),
+		},
+		Comment: aws.String("AssociateVPCComment"),
+	}
+	resp, err := svc.AssociateVPCWithHostedZone(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_ChangeResourceRecordSets() {
+	svc := route53.New(nil)
+
+	params := &route53.ChangeResourceRecordSetsInput{
+		ChangeBatch: &route53.ChangeBatch{ // Required
+			Changes: []*route53.Change{ // Required
+				&route53.Change{ // Required
+					Action: aws.String("ChangeAction"), // Required
+					ResourceRecordSet: &route53.ResourceRecordSet{ // Required
+						Name: aws.String("DNSName"), // Required
+						Type: aws.String("RRType"),  // Required
+						AliasTarget: &route53.AliasTarget{
+							DNSName:              aws.String("DNSName"),    // Required
+							EvaluateTargetHealth: aws.Boolean(true),        // Required
+							HostedZoneID:         aws.String("ResourceId"), // Required
+						},
+						Failover: aws.String("ResourceRecordSetFailover"),
+						GeoLocation: &route53.GeoLocation{
+							ContinentCode:   aws.String("GeoLocationContinentCode"),
+							CountryCode:     aws.String("GeoLocationCountryCode"),
+							SubdivisionCode: aws.String("GeoLocationSubdivisionCode"),
+						},
+						HealthCheckID: aws.String("HealthCheckId"),
+						Region:        aws.String("ResourceRecordSetRegion"),
+						ResourceRecords: []*route53.ResourceRecord{
+							&route53.ResourceRecord{ // Required
+								Value: aws.String("RData"), // Required
+							},
+							// More values...
+						},
+						SetIdentifier: aws.String("ResourceRecordSetIdentifier"),
+						TTL:           aws.Long(1),
+						Weight:        aws.Long(1),
+					},
+				},
+				// More values...
+			},
+			Comment: aws.String("ResourceDescription"),
+		},
+		HostedZoneID: aws.String("ResourceId"), // Required
+	}
+	resp, err := svc.ChangeResourceRecordSets(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_ChangeTagsForResource() {
+	svc := route53.New(nil)
+
+	params := &route53.ChangeTagsForResourceInput{
+		ResourceID:   aws.String("TagResourceId"),   // Required
+		ResourceType: aws.String("TagResourceType"), // Required
+		AddTags: []*route53.Tag{
+			&route53.Tag{ // Required
+				Key:   aws.String("TagKey"),
+				Value: aws.String("TagValue"),
+			},
+			// More values...
+		},
+		RemoveTagKeys: []*string{
+			aws.String("TagKey"), // Required
+			// More values...
+		},
+	}
+	resp, err := svc.ChangeTagsForResource(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_CreateHealthCheck() {
+	svc := route53.New(nil)
+
+	params := &route53.CreateHealthCheckInput{
+		CallerReference: aws.String("HealthCheckNonce"), // Required
+		HealthCheckConfig: &route53.HealthCheckConfig{ // Required
+			Type:                     aws.String("HealthCheckType"), // Required
+			FailureThreshold:         aws.Long(1),
+			FullyQualifiedDomainName: aws.String("FullyQualifiedDomainName"),
+			IPAddress:                aws.String("IPAddress"),
+			Port:                     aws.Long(1),
+			RequestInterval:          aws.Long(1),
+			ResourcePath:             aws.String("ResourcePath"),
+			SearchString:             aws.String("SearchString"),
+		},
+	}
+	resp, err := svc.CreateHealthCheck(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_CreateHostedZone() {
+	svc := route53.New(nil)
+
+	params := &route53.CreateHostedZoneInput{
+		CallerReference: aws.String("Nonce"),   // Required
+		Name:            aws.String("DNSName"), // Required
+		DelegationSetID: aws.String("ResourceId"),
+		HostedZoneConfig: &route53.HostedZoneConfig{
+			Comment:     aws.String("ResourceDescription"),
+			PrivateZone: aws.Boolean(true),
+		},
+		VPC: &route53.VPC{
+			VPCID:     aws.String("VPCId"),
+			VPCRegion: aws.String("VPCRegion"),
+		},
+	}
+	resp, err := svc.CreateHostedZone(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_CreateReusableDelegationSet() {
+	svc := route53.New(nil)
+
+	params := &route53.CreateReusableDelegationSetInput{
+		CallerReference: aws.String("Nonce"), // Required
+		HostedZoneID:    aws.String("ResourceId"),
+	}
+	resp, err := svc.CreateReusableDelegationSet(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_DeleteHealthCheck() {
+	svc := route53.New(nil)
+
+	params := &route53.DeleteHealthCheckInput{
+		HealthCheckID: aws.String("HealthCheckId"), // Required
+	}
+	resp, err := svc.DeleteHealthCheck(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_DeleteHostedZone() {
+	svc := route53.New(nil)
+
+	params := &route53.DeleteHostedZoneInput{
+		ID: aws.String("ResourceId"), // Required
+	}
+	resp, err := svc.DeleteHostedZone(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_DeleteReusableDelegationSet() {
+	svc := route53.New(nil)
+
+	params := &route53.DeleteReusableDelegationSetInput{
+		ID: aws.String("ResourceId"), // Required
+	}
+	resp, err := svc.DeleteReusableDelegationSet(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_DisassociateVPCFromHostedZone() {
+	svc := route53.New(nil)
+
+	params := &route53.DisassociateVPCFromHostedZoneInput{
+		HostedZoneID: aws.String("ResourceId"), // Required
+		VPC: &route53.VPC{ // Required
+			VPCID:     aws.String("VPCId"),
+			VPCRegion: aws.String("VPCRegion"),
+		},
+		Comment: aws.String("DisassociateVPCComment"),
+	}
+	resp, err := svc.DisassociateVPCFromHostedZone(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_GetChange() {
+	svc := route53.New(nil)
+
+	params := &route53.GetChangeInput{
+		ID: aws.String("ResourceId"), // Required
+	}
+	resp, err := svc.GetChange(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_GetCheckerIPRanges() {
+	svc := route53.New(nil)
+
+	var params *route53.GetCheckerIPRangesInput
+	resp, err := svc.GetCheckerIPRanges(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_GetGeoLocation() {
+	svc := route53.New(nil)
+
+	params := &route53.GetGeoLocationInput{
+		ContinentCode:   aws.String("GeoLocationContinentCode"),
+		CountryCode:     aws.String("GeoLocationCountryCode"),
+		SubdivisionCode: aws.String("GeoLocationSubdivisionCode"),
+	}
+	resp, err := svc.GetGeoLocation(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_GetHealthCheck() {
+	svc := route53.New(nil)
+
+	params := &route53.GetHealthCheckInput{
+		HealthCheckID: aws.String("HealthCheckId"), // Required
+	}
+	resp, err := svc.GetHealthCheck(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_GetHealthCheckCount() {
+	svc := route53.New(nil)
+
+	var params *route53.GetHealthCheckCountInput
+	resp, err := svc.GetHealthCheckCount(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_GetHealthCheckLastFailureReason() {
+	svc := route53.New(nil)
+
+	params := &route53.GetHealthCheckLastFailureReasonInput{
+		HealthCheckID: aws.String("HealthCheckId"), // Required
+	}
+	resp, err := svc.GetHealthCheckLastFailureReason(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_GetHealthCheckStatus() {
+	svc := route53.New(nil)
+
+	params := &route53.GetHealthCheckStatusInput{
+		HealthCheckID: aws.String("HealthCheckId"), // Required
+	}
+	resp, err := svc.GetHealthCheckStatus(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_GetHostedZone() {
+	svc := route53.New(nil)
+
+	params := &route53.GetHostedZoneInput{
+		ID: aws.String("ResourceId"), // Required
+	}
+	resp, err := svc.GetHostedZone(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_GetHostedZoneCount() {
+	svc := route53.New(nil)
+
+	var params *route53.GetHostedZoneCountInput
+	resp, err := svc.GetHostedZoneCount(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_GetReusableDelegationSet() {
+	svc := route53.New(nil)
+
+	params := &route53.GetReusableDelegationSetInput{
+		ID: aws.String("ResourceId"), // Required
+	}
+	resp, err := svc.GetReusableDelegationSet(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_ListGeoLocations() {
+	svc := route53.New(nil)
+
+	params := &route53.ListGeoLocationsInput{
+		MaxItems:             aws.String("PageMaxItems"),
+		StartContinentCode:   aws.String("GeoLocationContinentCode"),
+		StartCountryCode:     aws.String("GeoLocationCountryCode"),
+		StartSubdivisionCode: aws.String("GeoLocationSubdivisionCode"),
+	}
+	resp, err := svc.ListGeoLocations(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_ListHealthChecks() {
+	svc := route53.New(nil)
+
+	params := &route53.ListHealthChecksInput{
+		Marker:   aws.String("PageMarker"),
+		MaxItems: aws.String("PageMaxItems"),
+	}
+	resp, err := svc.ListHealthChecks(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_ListHostedZones() {
+	svc := route53.New(nil)
+
+	params := &route53.ListHostedZonesInput{
+		DelegationSetID: aws.String("ResourceId"),
+		Marker:          aws.String("PageMarker"),
+		MaxItems:        aws.String("PageMaxItems"),
+	}
+	resp, err := svc.ListHostedZones(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_ListHostedZonesByName() {
+	svc := route53.New(nil)
+
+	params := &route53.ListHostedZonesByNameInput{
+		DNSName:      aws.String("DNSName"),
+		HostedZoneID: aws.String("ResourceId"),
+		MaxItems:     aws.String("PageMaxItems"),
+	}
+	resp, err := svc.ListHostedZonesByName(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_ListResourceRecordSets() {
+	svc := route53.New(nil)
+
+	params := &route53.ListResourceRecordSetsInput{
+		HostedZoneID:          aws.String("ResourceId"), // Required
+		MaxItems:              aws.String("PageMaxItems"),
+		StartRecordIdentifier: aws.String("ResourceRecordSetIdentifier"),
+		StartRecordName:       aws.String("DNSName"),
+		StartRecordType:       aws.String("RRType"),
+	}
+	resp, err := svc.ListResourceRecordSets(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_ListReusableDelegationSets() {
+	svc := route53.New(nil)
+
+	params := &route53.ListReusableDelegationSetsInput{
+		Marker:   aws.String("PageMarker"),
+		MaxItems: aws.String("PageMaxItems"),
+	}
+	resp, err := svc.ListReusableDelegationSets(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_ListTagsForResource() {
+	svc := route53.New(nil)
+
+	params := &route53.ListTagsForResourceInput{
+		ResourceID:   aws.String("TagResourceId"),   // Required
+		ResourceType: aws.String("TagResourceType"), // Required
+	}
+	resp, err := svc.ListTagsForResource(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_ListTagsForResources() {
+	svc := route53.New(nil)
+
+	params := &route53.ListTagsForResourcesInput{
+		ResourceIDs: []*string{ // Required
+			aws.String("TagResourceId"), // Required
+			// More values...
+		},
+		ResourceType: aws.String("TagResourceType"), // Required
+	}
+	resp, err := svc.ListTagsForResources(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_UpdateHealthCheck() {
+	svc := route53.New(nil)
+
+	params := &route53.UpdateHealthCheckInput{
+		HealthCheckID:            aws.String("HealthCheckId"), // Required
+		FailureThreshold:         aws.Long(1),
+		FullyQualifiedDomainName: aws.String("FullyQualifiedDomainName"),
+		HealthCheckVersion:       aws.Long(1),
+		IPAddress:                aws.String("IPAddress"),
+		Port:                     aws.Long(1),
+		ResourcePath:             aws.String("ResourcePath"),
+		SearchString:             aws.String("SearchString"),
+	}
+	resp, err := svc.UpdateHealthCheck(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleRoute53_UpdateHostedZoneComment() {
+	svc := route53.New(nil)
+
+	params := &route53.UpdateHostedZoneCommentInput{
+		ID:      aws.String("ResourceId"), // Required
+		Comment: aws.String("ResourceDescription"),
+	}
+	resp, err := svc.UpdateHostedZoneComment(params)
+
+	if awserr := aws.Error(err); awserr != nil {
+		// A service error occurred.
+		fmt.Println("Error:", awserr.Code, awserr.Message)
+	} else if err != nil {
+		// A non-service error occurred.
+		panic(err)
+	}
+
+	// Pretty-print the response data.
+	fmt.Println(awsutil.StringValue(resp))
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/route53/service.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/route53/service.go
new file mode 100644
index 000000000..a2f792798
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/route53/service.go
@@ -0,0 +1,59 @@
+package route53
+
+import (
+	"github.com/awslabs/aws-sdk-go/aws"
+	"github.com/awslabs/aws-sdk-go/internal/protocol/restxml"
+	"github.com/awslabs/aws-sdk-go/internal/signer/v4"
+)
+
+// Route53 is a client for Route 53.
+type Route53 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 Route53 client.
+func New(config *aws.Config) *Route53 {
+	if config == nil {
+		config = &aws.Config{}
+	}
+
+	service := &aws.Service{
+		Config:      aws.DefaultConfig.Merge(config),
+		ServiceName: "route53",
+		APIVersion:  "2013-04-01",
+	}
+	service.Initialize()
+
+	// Handlers
+	service.Handlers.Sign.PushBack(v4.Sign)
+	service.Handlers.Build.PushBack(restxml.Build)
+	service.Handlers.Unmarshal.PushBack(restxml.Unmarshal)
+	service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta)
+	service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError)
+
+	// Run custom service initialization if present
+	if initService != nil {
+		initService(service)
+	}
+
+	return &Route53{service}
+}
+
+// newRequest creates a new request for a Route53 operation and runs any
+// custom request initialization.
+func (c *Route53) 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
+}
-- 
cgit v1.2.3-1-g7c22