Upgrade AWS SDK to the latest version

vendor/github.com/aws/aws-sdk-go/private/model/api/api.go

@@ -23,6 +23,7 @@ type API struct {
 	Shapes        map[string]*Shape
 	Waiters       []Waiter
 	Documentation string
+	Examples      Examples
 
 	// Set to true to avoid removing unused shapes
 	NoRemoveUnusedShapes bool
@@ -290,36 +291,93 @@ func (a *API) APIGoCode() string {
 }
 
 var noCrossLinkServices = map[string]struct{}{
-	"apigateway":        struct{}{},
-	"budgets":           struct{}{},
-	"cloudsearch":       struct{}{},
-	"cloudsearchdomain": struct{}{},
-	"discovery":         struct{}{},
-	"elastictranscoder": struct{}{},
-	"es":                struct{}{},
-	"glacier":           struct{}{},
-	"importexport":      struct{}{},
-	"iot":               struct{}{},
-	"iot-data":          struct{}{},
-	"lambda":            struct{}{},
-	"machinelearning":   struct{}{},
-	"rekognition":       struct{}{},
-	"sdb":               struct{}{},
-	"swf":               struct{}{},
+	"apigateway":        {},
+	"budgets":           {},
+	"cloudsearch":       {},
+	"cloudsearchdomain": {},
+	"elastictranscoder": {},
+	"es":                {},
+	"glacier":           {},
+	"importexport":      {},
+	"iot":               {},
+	"iot-data":          {},
+	"machinelearning":   {},
+	"rekognition":       {},
+	"sdb":               {},
+	"swf":               {},
 }
 
-func GetCrosslinkURL(baseURL, name, uid string, params ...string) string {
-	_, ok := noCrossLinkServices[strings.ToLower(name)]
-	if uid != "" && baseURL != "" && !ok {
-		return strings.Join(append([]string{baseURL, "goto", "WebAPI", uid}, params...), "/")
+// GetCrosslinkURL returns the crosslinking URL for the shape based on the name and
+// uid provided. Empty string is returned if no crosslink link could be determined.
+func GetCrosslinkURL(baseURL, uid string, params ...string) string {
+	if uid == "" || baseURL == "" {
+		return ""
 	}
-	return ""
+
+	if _, ok := noCrossLinkServices[strings.ToLower(serviceIDFromUID(uid))]; ok {
+		return ""
+	}
+
+	return strings.Join(append([]string{baseURL, "goto", "WebAPI", uid}, params...), "/")
 }
 
+func serviceIDFromUID(uid string) string {
+	found := 0
+	i := len(uid) - 1
+	for ; i >= 0; i-- {
+		if uid[i] == '-' {
+			found++
+		}
+		// Terminate after the date component is found, e.g. es-2017-11-11
+		if found == 3 {
+			break
+		}
+	}
+
+	return uid[0:i]
+}
+
+// APIName returns the API's service name.
 func (a *API) APIName() string {
 	return a.name
 }
 
+var tplServiceDoc = template.Must(template.New("service docs").Funcs(template.FuncMap{
+	"GetCrosslinkURL": GetCrosslinkURL,
+}).
+	Parse(`
+// Package {{ .PackageName }} provides the client and types for making API
+// requests to {{ .Metadata.ServiceFullName }}.
+{{ if .Documentation -}}
+//
+{{ .Documentation }}
+{{ end -}}
+{{ $crosslinkURL := GetCrosslinkURL $.BaseCrosslinkURL $.Metadata.UID -}}
+{{ if $crosslinkURL -}}
+//
+// See {{ $crosslinkURL }} for more information on this service.
+{{ end -}}
+//
+// See {{ .PackageName }} package documentation for more information.
+// https://docs.aws.amazon.com/sdk-for-go/api/service/{{ .PackageName }}/
+//
+// Using the Client
+//
+// To {{ .Metadata.ServiceFullName }} with the SDK use the New function to create
+// a new service client. With that client you can make API requests to the service.
+// These clients are safe to use concurrently.
+//
+// See the SDK's documentation for more information on how to use the SDK.
+// https://docs.aws.amazon.com/sdk-for-go/api/
+// 
+// See aws.Config documentation for more information on configuring SDK clients.
+// https://docs.aws.amazon.com/sdk-for-go/api/aws/#Config
+//
+// See the {{ .Metadata.ServiceFullName }} client {{ .StructName }} for more
+// information on creating client for this service.
+// https://docs.aws.amazon.com/sdk-for-go/api/service/{{ .PackageName }}/#New
+`))
+
 // A tplService defines the template for the service generated code.
 var tplService = template.Must(template.New("service").Funcs(template.FuncMap{
 	"ServiceNameValue": func(a *API) string {
@@ -328,7 +386,6 @@ var tplService = template.Must(template.New("service").Funcs(template.FuncMap{
 		}
 		return "ServiceName"
 	},
-	"GetCrosslinkURL": GetCrosslinkURL,
 	"EndpointsIDConstValue": func(a *API) string {
 		if a.NoConstServiceNames {
 			return fmt.Sprintf("%q", a.Metadata.EndpointPrefix)
@@ -346,12 +403,12 @@ var tplService = template.Must(template.New("service").Funcs(template.FuncMap{
 		return "EndpointsID"
 	},
 }).Parse(`
-{{ .Documentation }}// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
-{{ $crosslinkURL := GetCrosslinkURL $.BaseCrosslinkURL $.APIName $.Metadata.UID -}}
-{{ if ne $crosslinkURL "" -}} 
-// Please also see {{ $crosslinkURL }}
-{{ end -}}
+// {{ .StructName }} provides the API operation methods for making requests to
+// {{ .Metadata.ServiceFullName }}. See this package's package overview docs
+// for details on the service.
+//
+// {{ .StructName }} methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type {{ .StructName }} struct {
 	*client.Client
 }
@@ -457,6 +514,20 @@ func (c *{{ .StructName }}) newRequest(op *request.Operation, params, data inter
 }
 `))
 
+// ServicePackageDoc generates the contents of the doc file for the service.
+//
+// Will also read in the custom doc templates for the service if found.
+func (a *API) ServicePackageDoc() string {
+	a.imports = map[string]bool{}
+
+	var buf bytes.Buffer
+	if err := tplServiceDoc.Execute(&buf, a); err != nil {
+		panic(err)
+	}
+
+	return buf.String()
+}
+
 // ServiceGoCode renders service go code. Returning it as a string.
 func (a *API) ServiceGoCode() string {
 	a.resetImports()
@@ -501,7 +572,7 @@ func (a *API) ExampleGoCode() string {
 		"github.com/aws/aws-sdk-go/aws/session",
 		path.Join(a.SvcClientImportPath, a.PackageName()),
 	)
-	for k, _ := range imports {
+	for k := range imports {
 		code += fmt.Sprintf("%q\n", k)
 	}
 	code += ")\n\n"
@@ -519,7 +590,7 @@ var tplInterface = template.Must(template.New("interface").Parse(`
 //
 // The best way to use this interface is so the SDK's service client's calls
 // can be stubbed out for unit testing your code with the SDK without needing
-// to inject custom request handlers into the the SDK's request pipeline.
+// to inject custom request handlers into the SDK's request pipeline.
 //
 //    // myFunc uses an SDK service client to make a request to
 //    // {{.Metadata.ServiceFullName}}. {{ $opts := .OperationList }}{{ $opt := index $opts 0 }}

vendor/github.com/aws/aws-sdk-go/private/model/api/api_test.go

@@ -4,8 +4,6 @@ package api
 
 import (
 	"testing"
-
-	"github.com/stretchr/testify/assert"
 )
 
 func TestStructNameWithFullName(t *testing.T) {
@@ -14,7 +12,9 @@ func TestStructNameWithFullName(t *testing.T) {
 			ServiceFullName: "Amazon Service Name-100",
 		},
 	}
-	assert.Equal(t, a.StructName(), "ServiceName100")
+	if a.StructName() != "ServiceName100" {
+		t.Errorf("API struct name should have been %s, but received %s", "ServiceName100", a.StructName())
+	}
 }
 
 func TestStructNameWithAbbreviation(t *testing.T) {
@@ -24,21 +24,31 @@ func TestStructNameWithAbbreviation(t *testing.T) {
 			ServiceAbbreviation: "AWS SN100",
 		},
 	}
-	assert.Equal(t, a.StructName(), "SN100")
+	if a.StructName() != "SN100" {
+		t.Errorf("API struct name should have been %s, but received %s", "SN100", a.StructName())
+	}
 }
 
 func TestStructNameForExceptions(t *testing.T) {
+	serviceAliases = map[string]string{}
+	serviceAliases["elasticloadbalancing"] = "ELB"
+	serviceAliases["config"] = "ConfigService"
+
 	a := API{
 		Metadata: Metadata{
 			ServiceFullName: "Elastic Load Balancing",
 		},
 	}
-	assert.Equal(t, a.StructName(), "ELB")
+	if a.StructName() != "ELB" {
+		t.Errorf("API struct name should have been %s, but received %s", "ELB", a.StructName())
+	}
 
 	a = API{
 		Metadata: Metadata{
 			ServiceFullName: "AWS Config",
 		},
 	}
-	assert.Equal(t, a.StructName(), "ConfigService")
+	if a.StructName() != "ConfigService" {
+		t.Errorf("API struct name should have been %s, but received %s", "ConfigService", a.StructName())
+	}
 }

vendor/github.com/aws/aws-sdk-go/private/model/api/customization_passes.go

@@ -3,7 +3,6 @@
 package api
 
 import (
-	"fmt"
 	"io/ioutil"
 	"path/filepath"
 	"strings"
@@ -17,11 +16,11 @@ type service struct {
 }
 
 var mergeServices = map[string]service{
-	"dynamodbstreams": service{
+	"dynamodbstreams": {
 		dstName: "dynamodb",
 		srcName: "streams.dynamodb",
 	},
-	"wafregional": service{
+	"wafregional": {
 		dstName:        "waf",
 		srcName:        "waf-regional",
 		serviceVersion: "2015-08-24",
@@ -41,41 +40,13 @@ func (a *API) customizationPasses() {
 		"iotdataplane":      disableEndpointResolving,
 	}
 
-	for k, _ := range mergeServices {
+	for k := range mergeServices {
 		svcCustomizations[k] = mergeServicesCustomizations
 	}
 
 	if fn := svcCustomizations[a.PackageName()]; fn != nil {
 		fn(a)
 	}
-
-	blobDocStringCustomizations(a)
-}
-
-const base64MarshalDocStr = "// %s is automatically base64 encoded/decoded by the SDK.\n"
-
-func blobDocStringCustomizations(a *API) {
-	for _, s := range a.Shapes {
-		payloadMemberName := s.Payload
-
-		for refName, ref := range s.MemberRefs {
-			if refName == payloadMemberName {
-				// Payload members have their own encoding and may
-				// be raw bytes or io.Reader
-				continue
-			}
-			if ref.Shape.Type == "blob" {
-				docStr := fmt.Sprintf(base64MarshalDocStr, refName)
-				if len(strings.TrimSpace(ref.Shape.Documentation)) != 0 {
-					ref.Shape.Documentation += "//\n" + docStr
-				} else if len(strings.TrimSpace(ref.Documentation)) != 0 {
-					ref.Documentation += "//\n" + docStr
-				} else {
-					ref.Documentation = docStr
-				}
-			}
-		}
-	}
 }
 
 // s3Customizations customizes the API generation to replace values specific to S3.
@@ -88,6 +59,12 @@ func s3Customizations(a *API) {
 			delete(s.MemberRefs, "ContentMD5")
 		}
 
+		for _, refName := range []string{"Bucket", "SSECustomerKey", "CopySourceSSECustomerKey"} {
+			if ref, ok := s.MemberRefs[refName]; ok {
+				ref.GenerateGetter = true
+			}
+		}
+
 		// Expires should be a string not time.Time since the format is not
 		// enforced by S3, and any value can be set to this field outside of the SDK.
 		if strings.HasSuffix(name, "Output") {
@@ -104,6 +81,25 @@ func s3Customizations(a *API) {
 			}
 		}
 	}
+	s3CustRemoveHeadObjectModeledErrors(a)
+}
+
+// S3 HeadObject API call incorrect models NoSuchKey as valid
+// error code that can be returned. This operation does not
+// return error codes, all error codes are derived from HTTP
+// status codes.
+//
+// aws/aws-sdk-go#1208
+func s3CustRemoveHeadObjectModeledErrors(a *API) {
+	op, ok := a.Operations["HeadObject"]
+	if !ok {
+		return
+	}
+	op.Documentation += `
+//
+// See http://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html#RESTErrorResponses
+// for more information on returned errors.`
+	op.ErrorRefs = []ShapeRef{}
 }
 
 // cloudfrontCustomizations customized the API generation to replace values

vendor/github.com/aws/aws-sdk-go/private/model/api/docstring.go

@@ -46,13 +46,9 @@ func (a *API) AttachDocs(filename string) {
 
 func (d *apiDocumentation) setup() {
 	d.API.Documentation = docstring(d.Service)
-	if d.Service == "" {
-		d.API.Documentation =
-			fmt.Sprintf("// %s is a client for %s.\n", d.API.StructName(), d.API.NiceName())
-	}
 
 	for op, doc := range d.Operations {
-		d.API.Operations[op].Documentation = strings.TrimSpace(docstring(doc))
+		d.API.Operations[op].Documentation = docstring(doc)
 	}
 
 	for shape, info := range d.Shapes {
@@ -66,6 +62,10 @@ func (d *apiDocumentation) setup() {
 			}
 
 			parts := strings.Split(ref, "$")
+			if len(parts) != 2 {
+				fmt.Fprintf(os.Stderr, "Shape Doc %s has unexpected reference format, %q\n", shape, ref)
+				continue
+			}
 			if sh := d.API.Shapes[parts[0]]; sh != nil {
 				if m := sh.MemberRefs[parts[1]]; m != nil {
 					m.Documentation = docstring(doc)
@@ -78,24 +78,41 @@ func (d *apiDocumentation) setup() {
 var reNewline = regexp.MustCompile(`\r?\n`)
 var reMultiSpace = regexp.MustCompile(`\s+`)
 var reComments = regexp.MustCompile(`<!--.*?-->`)
-var reFullname = regexp.MustCompile(`\s*<fullname?>.+?<\/fullname?>\s*`)
+var reFullnameBlock = regexp.MustCompile(`<fullname>(.+?)<\/fullname>`)
+var reFullname = regexp.MustCompile(`<fullname>(.*?)</fullname>`)
 var reExamples = regexp.MustCompile(`<examples?>.+?<\/examples?>`)
 var reEndNL = regexp.MustCompile(`\n+$`)
 
 // docstring rewrites a string to insert godocs formatting.
 func docstring(doc string) string {
+	doc = strings.TrimSpace(doc)
+	if doc == "" {
+		return ""
+	}
+
 	doc = reNewline.ReplaceAllString(doc, "")
 	doc = reMultiSpace.ReplaceAllString(doc, " ")
 	doc = reComments.ReplaceAllString(doc, "")
+
+	var fullname string
+	parts := reFullnameBlock.FindStringSubmatch(doc)
+	if len(parts) > 1 {
+		fullname = parts[1]
+	}
+	// Remove full name block from doc string
 	doc = reFullname.ReplaceAllString(doc, "")
+
 	doc = reExamples.ReplaceAllString(doc, "")
 	doc = generateDoc(doc)
 	doc = reEndNL.ReplaceAllString(doc, "")
-	if doc == "" {
-		return "\n"
+	doc = html.UnescapeString(doc)
+
+	// Replace doc with full name if doc is empty.
+	doc = strings.TrimSpace(doc)
+	if len(doc) == 0 {
+		doc = fullname
 	}
 
-	doc = html.UnescapeString(doc)
 	return commentify(doc)
 }
 
@@ -116,16 +133,26 @@ var style = map[string]string{
 
 // commentify converts a string to a Go comment
 func commentify(doc string) string {
+	if len(doc) == 0 {
+		return ""
+	}
+
 	lines := strings.Split(doc, "\n")
-	out := []string{}
-	for i, line := range lines {
+	out := make([]string, 0, len(lines))
+	for i := 0; i < len(lines); i++ {
+		line := lines[i]
+
 		if i > 0 && line == "" && lines[i-1] == "" {
 			continue
 		}
-		out = append(out, "// "+line)
+		out = append(out, line)
 	}
 
-	return strings.Join(out, "\n") + "\n"
+	if len(out) > 0 {
+		out[0] = "// " + out[0]
+		return strings.Join(out, "\n// ")
+	}
+	return ""
 }
 
 // wrap returns a rewritten version of text to have line breaks

vendor/github.com/aws/aws-sdk-go/private/model/api/docstring_test.go

@@ -1,11 +1,9 @@
-// +build codegen
+// +build 1.6,codegen
 
 package api
 
 import (
 	"testing"
-
-	"github.com/stretchr/testify/assert"
 )
 
 func TestNonHTMLDocGen(t *testing.T) {
@@ -13,7 +11,9 @@ func TestNonHTMLDocGen(t *testing.T) {
 	expected := "// Testing 1 2 3\n"
 	doc = docstring(doc)
 
-	assert.Equal(t, expected, doc)
+	if expected != doc {
+		t.Errorf("Expected %s, but received %s", expected, doc)
+	}
 }
 
 func TestListsHTMLDocGen(t *testing.T) {
@@ -21,24 +21,32 @@ func TestListsHTMLDocGen(t *testing.T) {
 	expected := "//    * Testing 1 2 3\n//    * FooBar\n"
 	doc = docstring(doc)
 
-	assert.Equal(t, expected, doc)
+	if expected != doc {
+		t.Errorf("Expected %s, but received %s", expected, doc)
+	}
 
 	doc = "<ul> <li>Testing 1 2 3</li> <li>FooBar</li> </ul>"
 	expected = "//    * Testing 1 2 3\n//    * FooBar\n"
 	doc = docstring(doc)
 
-	assert.Equal(t, expected, doc)
+	if expected != doc {
+		t.Errorf("Expected %s, but received %s", expected, doc)
+	}
 
 	// Test leading spaces
 	doc = " <ul> <li>Testing 1 2 3</li> <li>FooBar</li> </ul>"
 	doc = docstring(doc)
-	assert.Equal(t, expected, doc)
+	if expected != doc {
+		t.Errorf("Expected %s, but received %s", expected, doc)
+	}
 
 	// Paragraph check
 	doc = "<ul> <li> <p>Testing 1 2 3</p> </li><li> <p>FooBar</p></li></ul>"
 	expected = "//    * Testing 1 2 3\n// \n//    * FooBar\n"
 	doc = docstring(doc)
-	assert.Equal(t, expected, doc)
+	if expected != doc {
+		t.Errorf("Expected %s, but received %s", expected, doc)
+	}
 }
 
 func TestInlineCodeHTMLDocGen(t *testing.T) {
@@ -46,7 +54,9 @@ func TestInlineCodeHTMLDocGen(t *testing.T) {
 	expected := "//    * Testing: 1 2 3\n//    * FooBar\n"
 	doc = docstring(doc)
 
-	assert.Equal(t, expected, doc)
+	if expected != doc {
+		t.Errorf("Expected %s, but received %s", expected, doc)
+	}
 }
 
 func TestInlineCodeInParagraphHTMLDocGen(t *testing.T) {
@@ -54,7 +64,9 @@ func TestInlineCodeInParagraphHTMLDocGen(t *testing.T) {
 	expected := "// Testing: 1 2 3\n"
 	doc = docstring(doc)
 
-	assert.Equal(t, expected, doc)
+	if expected != doc {
+		t.Errorf("Expected %s, but received %s", expected, doc)
+	}
 }
 
 func TestEmptyPREInlineCodeHTMLDocGen(t *testing.T) {
@@ -62,7 +74,9 @@ func TestEmptyPREInlineCodeHTMLDocGen(t *testing.T) {
 	expected := "//    Testing\n"
 	doc = docstring(doc)
 
-	assert.Equal(t, expected, doc)
+	if expected != doc {
+		t.Errorf("Expected %s, but received %s", expected, doc)
+	}
 }
 
 func TestParagraph(t *testing.T) {
@@ -70,7 +84,9 @@ func TestParagraph(t *testing.T) {
 	expected := "// Testing 1 2 3\n"
 	doc = docstring(doc)
 
-	assert.Equal(t, expected, doc)
+	if expected != doc {
+		t.Errorf("Expected %s, but received %s", expected, doc)
+	}
 }
 
 func TestComplexListParagraphCode(t *testing.T) {
@@ -78,5 +94,7 @@ func TestComplexListParagraphCode(t *testing.T) {
 	expected := "//    * FOO Bar\n// \n//    * Xyz ABC\n"
 	doc = docstring(doc)
 
-	assert.Equal(t, expected, doc)
+	if expected != doc {
+		t.Errorf("Expected %s, but received %s", expected, doc)
+	}
 }

vendor/github.com/aws/aws-sdk-go/private/model/api/example.go

@@ -0,0 +1,318 @@
+// +build codegen
+
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+	"text/template"
+
+	"github.com/aws/aws-sdk-go/private/util"
+)
+
+type Examples map[string][]Example
+
+// ExamplesDefinition is the structural representation of the examples-1.json file
+type ExamplesDefinition struct {
+	*API     `json:"-"`
+	Examples Examples `json:"examples"`
+}
+
+// Example is a single entry within the examples-1.json file.
+type Example struct {
+	API           *API                   `json:"-"`
+	Operation     *Operation             `json:"-"`
+	OperationName string                 `json:"-"`
+	Index         string                 `json:"-"`
+	Builder       examplesBuilder        `json:"-"`
+	VisitedErrors map[string]struct{}    `json:"-"`
+	Title         string                 `json:"title"`
+	Description   string                 `json:"description"`
+	ID            string                 `json:"id"`
+	Comments      Comments               `json:"comments"`
+	Input         map[string]interface{} `json:"input"`
+	Output        map[string]interface{} `json:"output"`
+}
+
+type Comments struct {
+	Input  map[string]interface{} `json:"input"`
+	Output map[string]interface{} `json:"output"`
+}
+
+var exampleFuncMap = template.FuncMap{
+	"commentify":           commentify,
+	"wrap":                 wrap,
+	"generateExampleInput": generateExampleInput,
+	"generateTypes":        generateTypes,
+}
+
+var exampleCustomizations = map[string]template.FuncMap{}
+
+var exampleTmpls = template.Must(template.New("example").Funcs(exampleFuncMap).Parse(`
+{{ generateTypes . }}
+{{ commentify (wrap .Title 80 false) }}
+//
+{{ commentify (wrap .Description 80 false) }}
+func Example{{ .API.StructName }}_{{ .MethodName }}() {
+	svc := {{ .API.PackageName }}.New(session.New())
+	input := &{{ .Operation.InputRef.Shape.GoTypeWithPkgNameElem  }} {
+		{{ generateExampleInput . -}}
+	}
+
+	result, err := svc.{{ .OperationName }}(input)
+	if err != nil {
+		if aerr, ok := err.(awserr.Error); ok {
+			switch aerr.Code() {
+				{{ range $_, $ref := .Operation.ErrorRefs -}}
+					{{ if not ($.HasVisitedError $ref) -}}
+			case {{ .API.PackageName }}.{{ $ref.Shape.ErrorCodeName }}:
+				fmt.Println({{ .API.PackageName }}.{{ $ref.Shape.ErrorCodeName }}, aerr.Error())
+					{{ end -}}
+				{{ end -}}
+			default:
+				fmt.Println(aerr.Error())
+			}
+		} else {
+			// Print the error, cast err to awserr.Error to get the Code and
+			// Message from an error.
+			fmt.Println(err.Error())
+		}
+		return
+	}
+
+	fmt.Println(result)
+}
+`))
+
+// Names will return the name of the example. This will also be the name of the operation
+// that is to be tested.
+func (exs Examples) Names() []string {
+	names := make([]string, 0, len(exs))
+	for k := range exs {
+		names = append(names, k)
+	}
+
+	sort.Strings(names)
+	return names
+}
+
+func (exs Examples) GoCode() string {
+	buf := bytes.NewBuffer(nil)
+	for _, opName := range exs.Names() {
+		examples := exs[opName]
+		for _, ex := range examples {
+			buf.WriteString(util.GoFmt(ex.GoCode()))
+			buf.WriteString("\n")
+		}
+	}
+	return buf.String()
+}
+
+// ExampleCode will generate the example code for the given Example shape.
+// TODO: Can delete
+func (ex Example) GoCode() string {
+	var buf bytes.Buffer
+	m := exampleFuncMap
+	if fMap, ok := exampleCustomizations[ex.API.PackageName()]; ok {
+		m = fMap
+	}
+	tmpl := exampleTmpls.Funcs(m)
+	if err := tmpl.ExecuteTemplate(&buf, "example", &ex); err != nil {
+		panic(err)
+	}
+
+	return strings.TrimSpace(buf.String())
+}
+
+func generateExampleInput(ex Example) string {
+	if ex.Operation.HasInput() {
+		return ex.Builder.BuildShape(&ex.Operation.InputRef, ex.Input, false)
+	}
+	return ""
+}
+
+// generateTypes will generate no types for default examples, but customizations may
+// require their own defined types.
+func generateTypes(ex Example) string {
+	return ""
+}
+
+// correctType will cast the value to the correct type when printing the string.
+// This is due to the json decoder choosing numbers to be floats, but the shape may
+// actually be an int. To counter this, we pass the shape's type and properly do the
+// casting here.
+func correctType(memName string, t string, value interface{}) string {
+	if value == nil {
+		return ""
+	}
+
+	v := ""
+	switch value.(type) {
+	case string:
+		v = value.(string)
+	case int:
+		v = fmt.Sprintf("%d", value.(int))
+	case float64:
+		if t == "integer" || t == "long" || t == "int64" {
+			v = fmt.Sprintf("%d", int(value.(float64)))
+		} else {
+			v = fmt.Sprintf("%f", value.(float64))
+		}
+	case bool:
+		v = fmt.Sprintf("%t", value.(bool))
+	}
+
+	return convertToCorrectType(memName, t, v)
+}
+
+func convertToCorrectType(memName, t, v string) string {
+	return fmt.Sprintf("%s: %s,\n", memName, getValue(t, v))
+}
+
+func getValue(t, v string) string {
+	if t[0] == '*' {
+		t = t[1:]
+	}
+	switch t {
+	case "string":
+		return fmt.Sprintf("aws.String(%q)", v)
+	case "integer", "long", "int64":
+		return fmt.Sprintf("aws.Int64(%s)", v)
+	case "float", "float64", "double":
+		return fmt.Sprintf("aws.Float64(%s)", v)
+	case "boolean":
+		return fmt.Sprintf("aws.Bool(%s)", v)
+	default:
+		panic("Unsupported type: " + t)
+	}
+}
+
+// AttachExamples will create a new ExamplesDefinition from the examples file
+// and reference the API object.
+func (a *API) AttachExamples(filename string) {
+	p := ExamplesDefinition{API: a}
+
+	f, err := os.Open(filename)
+	defer f.Close()
+	if err != nil {
+		panic(err)
+	}
+	err = json.NewDecoder(f).Decode(&p)
+	if err != nil {
+		panic(err)
+	}
+
+	p.setup()
+}
+
+var examplesBuilderCustomizations = map[string]examplesBuilder{
+	"wafregional": wafregionalExamplesBuilder{},
+}
+
+func (p *ExamplesDefinition) setup() {
+	var builder examplesBuilder
+	ok := false
+	if builder, ok = examplesBuilderCustomizations[p.API.PackageName()]; !ok {
+		builder = defaultExamplesBuilder{}
+	}
+
+	keys := p.Examples.Names()
+	for _, n := range keys {
+		examples := p.Examples[n]
+		for i, e := range examples {
+			n = p.ExportableName(n)
+			e.OperationName = n
+			e.API = p.API
+			e.Index = fmt.Sprintf("shared%02d", i)
+
+			e.Builder = builder
+
+			e.VisitedErrors = map[string]struct{}{}
+			op := p.API.Operations[e.OperationName]
+			e.OperationName = p.ExportableName(e.OperationName)
+			e.Operation = op
+			p.Examples[n][i] = e
+		}
+	}
+
+	p.API.Examples = p.Examples
+}
+
+var exampleHeader = template.Must(template.New("exampleHeader").Parse(`
+import (
+	{{ .Builder.Imports .API }}
+)
+
+var _ time.Duration
+var _ strings.Reader
+var _ aws.Config
+
+func parseTime(layout, value string) *time.Time {
+	t, err := time.Parse(layout, value)
+	if err != nil {
+		panic(err)
+	}
+	return &t
+}
+
+`))
+
+type exHeader struct {
+	Builder examplesBuilder
+	API     *API
+}
+
+// ExamplesGoCode will return a code representation of the entry within the
+// examples.json file.
+func (a *API) ExamplesGoCode() string {
+	var buf bytes.Buffer
+	var builder examplesBuilder
+	ok := false
+	if builder, ok = examplesBuilderCustomizations[a.PackageName()]; !ok {
+		builder = defaultExamplesBuilder{}
+	}
+
+	if err := exampleHeader.ExecuteTemplate(&buf, "exampleHeader", &exHeader{builder, a}); err != nil {
+		panic(err)
+	}
+
+	code := a.Examples.GoCode()
+	if len(code) == 0 {
+		return ""
+	}
+
+	buf.WriteString(code)
+	return buf.String()
+}
+
+// TODO: In the operation docuentation where we list errors, this needs to be done
+// there as well.
+func (ex *Example) HasVisitedError(errRef *ShapeRef) bool {
+	errName := errRef.Shape.ErrorCodeName()
+	_, ok := ex.VisitedErrors[errName]
+	ex.VisitedErrors[errName] = struct{}{}
+	return ok
+}
+
+func parseTimeString(ref *ShapeRef, memName, v string) string {
+	if ref.Location == "header" {
+		return fmt.Sprintf("%s: parseTime(%q, %q),\n", memName, "Mon, 2 Jan 2006 15:04:05 GMT", v)
+	} else {
+		switch ref.API.Metadata.Protocol {
+		case "json", "rest-json":
+			return fmt.Sprintf("%s: parseTime(%q, %q),\n", memName, "2006-01-02T15:04:05Z", v)
+		case "rest-xml", "ec2", "query":
+			return fmt.Sprintf("%s: parseTime(%q, %q),\n", memName, "2006-01-02T15:04:05Z", v)
+		default:
+			panic("Unsupported time type: " + ref.API.Metadata.Protocol)
+		}
+	}
+}
+
+func (ex *Example) MethodName() string {
+	return fmt.Sprintf("%s_%s", ex.OperationName, ex.Index)
+}

vendor/github.com/aws/aws-sdk-go/private/model/api/example_test.go

@@ -0,0 +1,206 @@
+// +build 1.6,codegen
+
+package api
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func buildAPI() *API {
+	a := &API{}
+
+	stringShape := &Shape{
+		API:       a,
+		ShapeName: "string",
+		Type:      "string",
+	}
+	stringShapeRef := &ShapeRef{
+		API:       a,
+		ShapeName: "string",
+		Shape:     stringShape,
+	}
+
+	intShape := &Shape{
+		API:       a,
+		ShapeName: "int",
+		Type:      "int",
+	}
+	intShapeRef := &ShapeRef{
+		API:       a,
+		ShapeName: "int",
+		Shape:     intShape,
+	}
+
+	input := &Shape{
+		API:       a,
+		ShapeName: "FooInput",
+		MemberRefs: map[string]*ShapeRef{
+			"BarShape": stringShapeRef,
+		},
+		Type: "structure",
+	}
+	output := &Shape{
+		API:       a,
+		ShapeName: "FooOutput",
+		MemberRefs: map[string]*ShapeRef{
+			"BazShape": intShapeRef,
+		},
+		Type: "structure",
+	}
+
+	inputRef := ShapeRef{
+		API:       a,
+		ShapeName: "FooInput",
+		Shape:     input,
+	}
+	outputRef := ShapeRef{
+		API:       a,
+		ShapeName: "Foooutput",
+		Shape:     output,
+	}
+
+	operations := map[string]*Operation{
+		"Foo": {
+			API:          a,
+			Name:         "Foo",
+			ExportedName: "Foo",
+			InputRef:     inputRef,
+			OutputRef:    outputRef,
+		},
+	}
+
+	a.Operations = operations
+	a.Shapes = map[string]*Shape{
+		"FooInput":  input,
+		"FooOutput": output,
+	}
+	a.Metadata = Metadata{
+		ServiceAbbreviation: "FooService",
+	}
+
+	a.Setup()
+	return a
+}
+
+func TestExampleGeneration(t *testing.T) {
+	example := `
+{
+  "version": "1.0",
+  "examples": {
+    "Foo": [
+      {
+        "input": {
+          "BarShape": "Hello world"
+        },
+        "output": {
+          "BazShape": 1
+        },
+        "comments": {
+          "input": {
+          },
+          "output": {
+          }
+        },
+        "description": "Foo bar baz qux",
+        "title": "I pity the foo"
+      }
+    ]
+  }
+}
+	`
+	a := buildAPI()
+	def := &ExamplesDefinition{}
+	err := json.Unmarshal([]byte(example), def)
+	if err != nil {
+		t.Error(err)
+	}
+	def.API = a
+
+	def.setup()
+	expected := `
+import (
+	"fmt"
+	"bytes"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/service/fooservice"
+)
+
+var _ time.Duration
+var _ bytes.Buffer
+var _ aws.Config
+
+func parseTime(layout, value string) *time.Time {
+	t, err := time.Parse(layout, value)
+	if err != nil {
+		panic(err)
+	}
+	return &t
+}
+
+// I pity the foo
+//
+// Foo bar baz qux
+func ExampleFooService_Foo_shared00() {
+	svc := fooservice.New(session.New())
+	input := &fooservice.FooInput{
+		BarShape: aws.String("Hello world"),
+	}
+
+	result, err := svc.Foo(input)
+	if err != nil {
+		if aerr, ok := err.(awserr.Error); ok {
+			switch aerr.Code() {
+			default:
+				fmt.Println(aerr.Error())
+			}
+		} else {
+			// Print the error, cast err to awserr.Error to get the Code and
+			// Message from an error.
+			fmt.Println(err.Error())
+		}
+		return
+	}
+
+	fmt.Println(result)
+}
+`
+	if expected != a.ExamplesGoCode() {
+		t.Log([]byte(expected))
+		t.Log([]byte(a.ExamplesGoCode()))
+		t.Errorf("Expected:\n%s\nReceived:\n%s\n", expected, a.ExamplesGoCode())
+	}
+}
+
+func TestBuildShape(t *testing.T) {
+	a := buildAPI()
+	cases := []struct {
+		defs     map[string]interface{}
+		expected string
+	}{
+		{
+			defs: map[string]interface{}{
+				"barShape": "Hello World",
+			},
+			expected: "BarShape: aws.String(\"Hello World\"),\n",
+		},
+		{
+			defs: map[string]interface{}{
+				"BarShape": "Hello World",
+			},
+			expected: "BarShape: aws.String(\"Hello World\"),\n",
+		},
+	}
+
+	for _, c := range cases {
+		ref := a.Operations["Foo"].InputRef
+		shapeStr := defaultExamplesBuilder{}.BuildShape(&ref, c.defs, false)
+		if c.expected != shapeStr {
+			t.Errorf("Expected:\n%s\nReceived:\n%s", c.expected, shapeStr)
+		}
+	}
+}

vendor/github.com/aws/aws-sdk-go/private/model/api/examples_builder.go

@@ -0,0 +1,256 @@
+// +build codegen
+
+package api
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+)
+
+type examplesBuilder interface {
+	BuildShape(*ShapeRef, map[string]interface{}, bool) string
+	BuildList(string, string, *ShapeRef, []interface{}) string
+	BuildComplex(string, string, *ShapeRef, map[string]interface{}) string
+	Imports(*API) string
+}
+
+type defaultExamplesBuilder struct{}
+
+// BuildShape will recursively build the referenced shape based on the json object
+// provided.
+// isMap will dictate how the field name is specified. If isMap is true, we will expect
+// the member name to be quotes like "Foo".
+func (builder defaultExamplesBuilder) BuildShape(ref *ShapeRef, shapes map[string]interface{}, isMap bool) string {
+	order := make([]string, len(shapes))
+	for k := range shapes {
+		order = append(order, k)
+	}
+	sort.Strings(order)
+
+	ret := ""
+	for _, name := range order {
+		if name == "" {
+			continue
+		}
+		shape := shapes[name]
+
+		// If the shape isn't a map, we want to export the value, since every field
+		// defined in our shapes are exported.
+		if len(name) > 0 && !isMap && strings.ToLower(name[0:1]) == name[0:1] {
+			name = strings.Title(name)
+		}
+
+		memName := name
+		if isMap {
+			memName = fmt.Sprintf("%q", memName)
+		}
+
+		switch v := shape.(type) {
+		case map[string]interface{}:
+			ret += builder.BuildComplex(name, memName, ref, v)
+		case []interface{}:
+			ret += builder.BuildList(name, memName, ref, v)
+		default:
+			ret += builder.BuildScalar(name, memName, ref, v)
+		}
+	}
+	return ret
+}
+
+// BuildList will construct a list shape based off the service's definition
+// of that list.
+func (builder defaultExamplesBuilder) BuildList(name, memName string, ref *ShapeRef, v []interface{}) string {
+	ret := ""
+
+	if len(v) == 0 || ref == nil {
+		return ""
+	}
+
+	t := ""
+	dataType := ""
+	format := ""
+	isComplex := false
+	passRef := ref
+	isMap := false
+
+	if ref.Shape.MemberRefs[name] != nil {
+		t = builder.GoType(&ref.Shape.MemberRefs[name].Shape.MemberRef, false)
+		dataType = ref.Shape.MemberRefs[name].Shape.MemberRef.Shape.Type
+		passRef = ref.Shape.MemberRefs[name]
+		if dataType == "map" {
+			t = fmt.Sprintf("map[string]%s", builder.GoType(&ref.Shape.MemberRefs[name].Shape.MemberRef.Shape.ValueRef, false))
+			passRef = &ref.Shape.MemberRefs[name].Shape.MemberRef.Shape.ValueRef
+			isMap = true
+		}
+	} else if ref.Shape.MemberRef.Shape != nil && ref.Shape.MemberRef.Shape.MemberRefs[name] != nil {
+		t = builder.GoType(&ref.Shape.MemberRef.Shape.MemberRefs[name].Shape.MemberRef, false)
+		dataType = ref.Shape.MemberRef.Shape.MemberRefs[name].Shape.MemberRef.Shape.Type
+		passRef = &ref.Shape.MemberRef.Shape.MemberRefs[name].Shape.MemberRef
+	} else {
+		t = builder.GoType(&ref.Shape.MemberRef, false)
+		dataType = ref.Shape.MemberRef.Shape.Type
+		passRef = &ref.Shape.MemberRef
+	}
+
+	switch v[0].(type) {
+	case string:
+		format = "%s"
+	case bool:
+		format = "%t"
+	case float64:
+		if dataType == "integer" || dataType == "int64" {
+			format = "%d"
+		} else {
+			format = "%f"
+		}
+	default:
+		if ref.Shape.MemberRefs[name] != nil {
+		} else {
+			passRef = ref.Shape.MemberRef.Shape.MemberRefs[name]
+
+			// if passRef is nil that means we are either in a map or within a nested array
+			if passRef == nil {
+				passRef = &ref.Shape.MemberRef
+			}
+		}
+		isComplex = true
+	}
+	ret += fmt.Sprintf("%s: []%s {\n", memName, t)
+	for _, elem := range v {
+		if isComplex {
+			ret += fmt.Sprintf("{\n%s\n},\n", builder.BuildShape(passRef, elem.(map[string]interface{}), isMap))
+		} else {
+			if dataType == "integer" || dataType == "int64" || dataType == "long" {
+				elem = int(elem.(float64))
+			}
+			ret += fmt.Sprintf("%s,\n", getValue(t, fmt.Sprintf(format, elem)))
+		}
+	}
+	ret += "},\n"
+	return ret
+}
+
+// BuildScalar will build atomic Go types.
+func (builder defaultExamplesBuilder) BuildScalar(name, memName string, ref *ShapeRef, shape interface{}) string {
+	if ref == nil || ref.Shape == nil {
+		return ""
+	} else if ref.Shape.MemberRefs[name] == nil {
+		if ref.Shape.MemberRef.Shape != nil && ref.Shape.MemberRef.Shape.MemberRefs[name] != nil {
+			return correctType(memName, ref.Shape.MemberRef.Shape.MemberRefs[name].Shape.Type, shape)
+		}
+		if ref.Shape.Type != "structure" && ref.Shape.Type != "map" {
+			return correctType(memName, ref.Shape.Type, shape)
+		}
+		return ""
+	}
+
+	switch v := shape.(type) {
+	case bool:
+		return convertToCorrectType(memName, ref.Shape.MemberRefs[name].Shape.Type, fmt.Sprintf("%t", v))
+	case int:
+		if ref.Shape.MemberRefs[name].Shape.Type == "timestamp" {
+			return parseTimeString(ref, memName, fmt.Sprintf("%d", v))
+		}
+		return convertToCorrectType(memName, ref.Shape.MemberRefs[name].Shape.Type, fmt.Sprintf("%d", v))
+	case float64:
+		dataType := ref.Shape.MemberRefs[name].Shape.Type
+		if dataType == "integer" || dataType == "int64" || dataType == "long" {
+			return convertToCorrectType(memName, ref.Shape.MemberRefs[name].Shape.Type, fmt.Sprintf("%d", int(shape.(float64))))
+		}
+		return convertToCorrectType(memName, ref.Shape.MemberRefs[name].Shape.Type, fmt.Sprintf("%f", v))
+	case string:
+		t := ref.Shape.MemberRefs[name].Shape.Type
+		switch t {
+		case "timestamp":
+			return parseTimeString(ref, memName, fmt.Sprintf("%s", v))
+		case "blob":
+			if (ref.Shape.MemberRefs[name].Streaming || ref.Shape.MemberRefs[name].Shape.Streaming) && ref.Shape.Payload == name {
+				return fmt.Sprintf("%s: aws.ReadSeekCloser(strings.NewReader(%q)),\n", memName, v)
+			}
+
+			return fmt.Sprintf("%s: []byte(%q),\n", memName, v)
+		default:
+			return convertToCorrectType(memName, t, v)
+		}
+	default:
+		panic(fmt.Errorf("Unsupported scalar type: %v", reflect.TypeOf(v)))
+	}
+	return ""
+}
+
+func (builder defaultExamplesBuilder) BuildComplex(name, memName string, ref *ShapeRef, v map[string]interface{}) string {
+	t := ""
+	if ref == nil {
+		return builder.BuildShape(nil, v, true)
+	}
+
+	member := ref.Shape.MemberRefs[name]
+
+	if member != nil && member.Shape != nil {
+		t = ref.Shape.MemberRefs[name].Shape.Type
+	} else {
+		t = ref.Shape.Type
+	}
+
+	switch t {
+	case "structure":
+		passRef := ref.Shape.MemberRefs[name]
+		// passRef will be nil if the entry is a map. In that case
+		// we want to pass the reference, because the previous call
+		// passed the value reference.
+		if passRef == nil {
+			passRef = ref
+		}
+		return fmt.Sprintf(`%s: &%s{
+				%s
+			},
+			`, memName, builder.GoType(passRef, true), builder.BuildShape(passRef, v, false))
+	case "map":
+		return fmt.Sprintf(`%s: %s{
+				%s
+			},
+			`, name, builder.GoType(ref.Shape.MemberRefs[name], false), builder.BuildShape(&ref.Shape.MemberRefs[name].Shape.ValueRef, v, true))
+	}
+
+	return ""
+}
+
+func (builder defaultExamplesBuilder) GoType(ref *ShapeRef, elem bool) string {
+	prefix := ""
+	if ref.Shape.Type == "list" {
+		ref = &ref.Shape.MemberRef
+		prefix = "[]*"
+	}
+
+	name := ref.GoTypeWithPkgName()
+	if elem {
+		name = ref.GoTypeElem()
+		if !strings.Contains(name, ".") {
+			name = strings.Join([]string{ref.API.PackageName(), name}, ".")
+		}
+	}
+
+	if ref.Shape.Type != "structure" && ref.Shape.Type != "list" {
+		return name
+	}
+
+	return prefix + name
+}
+
+func (builder defaultExamplesBuilder) Imports(a *API) string {
+	buf := bytes.NewBuffer(nil)
+	buf.WriteString(`"fmt"
+	"strings"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/aws/aws-sdk-go/aws/session"
+	`)
+
+	buf.WriteString(fmt.Sprintf("\"%s/%s\"", "github.com/aws/aws-sdk-go/service", a.PackageName()))
+	return buf.String()
+}

vendor/github.com/aws/aws-sdk-go/private/model/api/examples_builder_customizations.go

@@ -0,0 +1,28 @@
+// +build codegen
+
+package api
+
+import (
+	"bytes"
+	"fmt"
+)
+
+type wafregionalExamplesBuilder struct {
+	defaultExamplesBuilder
+}
+
+func (builder wafregionalExamplesBuilder) Imports(a *API) string {
+	buf := bytes.NewBuffer(nil)
+	buf.WriteString(`"fmt"
+	"strings"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/service/waf"
+	`)
+
+	buf.WriteString(fmt.Sprintf("\"%s/%s\"", "github.com/aws/aws-sdk-go/service", a.PackageName()))
+	return buf.String()
+}

vendor/github.com/aws/aws-sdk-go/private/model/api/list_of_shame.go

@@ -0,0 +1,495 @@
+package api
+
+// shamelist is used to not rename certain operation's input and output shapes.
+// We need to maintain backwards compatibility with pre-existing services. Since
+// not generating unique input/output shapes is not desired, we will generate
+// unique input/output shapes for new operations.
+var shamelist = map[string]map[string]struct {
+	input  bool
+	output bool
+}{
+	"APIGateway": {
+		"CreateApiKey": {
+			output: true,
+		},
+		"CreateAuthorizer": {
+			output: true,
+		},
+		"CreateBasePathMapping": {
+			output: true,
+		},
+		"CreateDeployment": {
+			output: true,
+		},
+		"CreateDocumentationPart": {
+			output: true,
+		},
+		"CreateDocumentationVersion": {
+			output: true,
+		},
+		"CreateDomainName": {
+			output: true,
+		},
+		"CreateModel": {
+			output: true,
+		},
+		"CreateResource": {
+			output: true,
+		},
+		"CreateRestApi": {
+			output: true,
+		},
+		"CreateStage": {
+			output: true,
+		},
+		"CreateUsagePlan": {
+			output: true,
+		},
+		"CreateUsagePlanKey": {
+			output: true,
+		},
+		"GenerateClientCertificate": {
+			output: true,
+		},
+		"GetAccount": {
+			output: true,
+		},
+		"GetApiKey": {
+			output: true,
+		},
+		"GetAuthorizer": {
+			output: true,
+		},
+		"GetBasePathMapping": {
+			output: true,
+		},
+		"GetClientCertificate": {
+			output: true,
+		},
+		"GetDeployment": {
+			output: true,
+		},
+		"GetDocumentationPart": {
+			output: true,
+		},
+		"GetDocumentationVersion": {
+			output: true,
+		},
+		"GetDomainName": {
+			output: true,
+		},
+		"GetIntegration": {
+			output: true,
+		},
+		"GetIntegrationResponse": {
+			output: true,
+		},
+		"GetMethod": {
+			output: true,
+		},
+		"GetMethodResponse": {
+			output: true,
+		},
+		"GetModel": {
+			output: true,
+		},
+		"GetResource": {
+			output: true,
+		},
+		"GetRestApi": {
+			output: true,
+		},
+		"GetSdkType": {
+			output: true,
+		},
+		"GetStage": {
+			output: true,
+		},
+		"GetUsage": {
+			output: true,
+		},
+		"GetUsagePlan": {
+			output: true,
+		},
+		"GetUsagePlanKey": {
+			output: true,
+		},
+		"ImportRestApi": {
+			output: true,
+		},
+		"PutIntegration": {
+			output: true,
+		},
+		"PutIntegrationResponse": {
+			output: true,
+		},
+		"PutMethod": {
+			output: true,
+		},
+		"PutMethodResponse": {
+			output: true,
+		},
+		"PutRestApi": {
+			output: true,
+		},
+		"UpdateAccount": {
+			output: true,
+		},
+		"UpdateApiKey": {
+			output: true,
+		},
+		"UpdateAuthorizer": {
+			output: true,
+		},
+		"UpdateBasePathMapping": {
+			output: true,
+		},
+		"UpdateClientCertificate": {
+			output: true,
+		},
+		"UpdateDeployment": {
+			output: true,
+		},
+		"UpdateDocumentationPart": {
+			output: true,
+		},
+		"UpdateDocumentationVersion": {
+			output: true,
+		},
+		"UpdateDomainName": {
+			output: true,
+		},
+		"UpdateIntegration": {
+			output: true,
+		},
+		"UpdateIntegrationResponse": {
+			output: true,
+		},
+		"UpdateMethod": {
+			output: true,
+		},
+		"UpdateMethodResponse": {
+			output: true,
+		},
+		"UpdateModel": {
+			output: true,
+		},
+		"UpdateResource": {
+			output: true,
+		},
+		"UpdateRestApi": {
+			output: true,
+		},
+		"UpdateStage": {
+			output: true,
+		},
+		"UpdateUsage": {
+			output: true,
+		},
+		"UpdateUsagePlan": {
+			output: true,
+		},
+	},
+	"AutoScaling": {
+		"ResumeProcesses": {
+			input: true,
+		},
+		"SuspendProcesses": {
+			input: true,
+		},
+	},
+	"CognitoIdentity": {
+		"CreateIdentityPool": {
+			output: true,
+		},
+		"DescribeIdentity": {
+			output: true,
+		},
+		"DescribeIdentityPool": {
+			output: true,
+		},
+		"UpdateIdentityPool": {
+			input:  true,
+			output: true,
+		},
+	},
+	"DirectConnect": {
+		"AllocateConnectionOnInterconnect": {
+			output: true,
+		},
+		"AllocateHostedConnection": {
+			output: true,
+		},
+		"AllocatePrivateVirtualInterface": {
+			output: true,
+		},
+		"AllocatePublicVirtualInterface": {
+			output: true,
+		},
+		"AssociateConnectionWithLag": {
+			output: true,
+		},
+		"AssociateHostedConnection": {
+			output: true,
+		},
+		"AssociateVirtualInterface": {
+			output: true,
+		},
+		"CreateConnection": {
+			output: true,
+		},
+		"CreateInterconnect": {
+			output: true,
+		},
+		"CreateLag": {
+			output: true,
+		},
+		"CreatePrivateVirtualInterface": {
+			output: true,
+		},
+		"CreatePublicVirtualInterface": {
+			output: true,
+		},
+		"DeleteConnection": {
+			output: true,
+		},
+		"DeleteLag": {
+			output: true,
+		},
+		"DescribeConnections": {
+			output: true,
+		},
+		"DescribeConnectionsOnInterconnect": {
+			output: true,
+		},
+		"DescribeHostedConnections": {
+			output: true,
+		},
+		"DescribeLoa": {
+			output: true,
+		},
+		"DisassociateConnectionFromLag": {
+			output: true,
+		},
+		"UpdateLag": {
+			output: true,
+		},
+	},
+	"EC2": {
+		"AttachVolume": {
+			output: true,
+		},
+		"CreateSnapshot": {
+			output: true,
+		},
+		"CreateVolume": {
+			output: true,
+		},
+		"DetachVolume": {
+			output: true,
+		},
+		"RunInstances": {
+			output: true,
+		},
+	},
+	"EFS": {
+		"CreateFileSystem": {
+			output: true,
+		},
+		"CreateMountTarget": {
+			output: true,
+		},
+	},
+	"ElastiCache": {
+		"AddTagsToResource": {
+			output: true,
+		},
+		"ListTagsForResource": {
+			output: true,
+		},
+		"ModifyCacheParameterGroup": {
+			output: true,
+		},
+		"RemoveTagsFromResource": {
+			output: true,
+		},
+		"ResetCacheParameterGroup": {
+			output: true,
+		},
+	},
+	"ElasticBeanstalk": {
+		"ComposeEnvironments": {
+			output: true,
+		},
+		"CreateApplication": {
+			output: true,
+		},
+		"CreateApplicationVersion": {
+			output: true,
+		},
+		"CreateConfigurationTemplate": {
+			output: true,
+		},
+		"CreateEnvironment": {
+			output: true,
+		},
+		"DescribeEnvironments": {
+			output: true,
+		},
+		"TerminateEnvironment": {
+			output: true,
+		},
+		"UpdateApplication": {
+			output: true,
+		},
+		"UpdateApplicationVersion": {
+			output: true,
+		},
+		"UpdateConfigurationTemplate": {
+			output: true,
+		},
+		"UpdateEnvironment": {
+			output: true,
+		},
+	},
+	"Glacier": {
+		"DescribeJob": {
+			output: true,
+		},
+		"UploadArchive": {
+			output: true,
+		},
+		"CompleteMultipartUpload": {
+			output: true,
+		},
+	},
+	"IAM": {
+		"GetContextKeysForCustomPolicy": {
+			output: true,
+		},
+		"GetContextKeysForPrincipalPolicy": {
+			output: true,
+		},
+		"SimulateCustomPolicy": {
+			output: true,
+		},
+		"SimulatePrincipalPolicy": {
+			output: true,
+		},
+	},
+	"Kinesis": {
+		"DisableEnhancedMonitoring": {
+			output: true,
+		},
+		"EnableEnhancedMonitoring": {
+			output: true,
+		},
+	},
+	"KMS": {
+		"ListGrants": {
+			output: true,
+		},
+		"ListRetirableGrants": {
+			output: true,
+		},
+	},
+	"Lambda": {
+		"CreateAlias": {
+			output: true,
+		},
+		"CreateEventSourceMapping": {
+			output: true,
+		},
+		"CreateFunction": {
+			output: true,
+		},
+		"DeleteEventSourceMapping": {
+			output: true,
+		},
+		"GetAlias": {
+			output: true,
+		},
+		"GetEventSourceMapping": {
+			output: true,
+		},
+		"GetFunctionConfiguration": {
+			output: true,
+		},
+		"PublishVersion": {
+			output: true,
+		},
+		"UpdateAlias": {
+			output: true,
+		},
+		"UpdateEventSourceMapping": {
+			output: true,
+		},
+		"UpdateFunctionCode": {
+			output: true,
+		},
+		"UpdateFunctionConfiguration": {
+			output: true,
+		},
+	},
+	"RDS": {
+		"ModifyDBClusterParameterGroup": {
+			output: true,
+		},
+		"ModifyDBParameterGroup": {
+			output: true,
+		},
+		"ResetDBClusterParameterGroup": {
+			output: true,
+		},
+		"ResetDBParameterGroup": {
+			output: true,
+		},
+	},
+	"Redshift": {
+		"DescribeLoggingStatus": {
+			output: true,
+		},
+		"DisableLogging": {
+			output: true,
+		},
+		"EnableLogging": {
+			output: true,
+		},
+		"ModifyClusterParameterGroup": {
+			output: true,
+		},
+		"ResetClusterParameterGroup": {
+			output: true,
+		},
+	},
+	"S3": {
+		"GetBucketNotification": {
+			input:  true,
+			output: true,
+		},
+		"GetBucketNotificationConfiguration": {
+			input:  true,
+			output: true,
+		},
+	},
+	"SWF": {
+		"CountClosedWorkflowExecutions": {
+			output: true,
+		},
+		"CountOpenWorkflowExecutions": {
+			output: true,
+		},
+		"CountPendingActivityTasks": {
+			output: true,
+		},
+		"CountPendingDecisionTasks": {
+			output: true,
+		},
+		"ListClosedWorkflowExecutions": {
+			output: true,
+		},
+		"ListOpenWorkflowExecutions": {
+			output: true,
+		},
+	},
+}

vendor/github.com/aws/aws-sdk-go/private/model/api/load_test.go

@@ -4,8 +4,6 @@ package api
 
 import (
 	"testing"
-
-	"github.com/stretchr/testify/assert"
 )
 
 func TestResolvedReferences(t *testing.T) {
@@ -28,5 +26,7 @@ func TestResolvedReferences(t *testing.T) {
 	}`
 	a := API{}
 	a.AttachString(json)
-	assert.Equal(t, len(a.Shapes["OtherTest"].refs), 2)
+	if len(a.Shapes["OtherTest"].refs) != 2 {
+		t.Errorf("Expected %d, but received %d", 2, len(a.Shapes["OtherTest"].refs))
+	}
 }

vendor/github.com/aws/aws-sdk-go/private/model/api/operation.go

@@ -72,19 +72,18 @@ const op{{ .ExportedName }} = "{{ .Name }}"
 
 // {{ .ExportedName }}Request generates a "aws/request.Request" representing the
 // client's request for the {{ .ExportedName }} operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See {{ .ExportedName }} for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the {{ .ExportedName }} method directly
-// instead.
+// See {{ .ExportedName }} for more information on using the {{ .ExportedName }}
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the {{ .ExportedName }}Request method.
 //    req, resp := client.{{ .ExportedName }}Request(params)
@@ -93,7 +92,7 @@ const op{{ .ExportedName }} = "{{ .Name }}"
 //    if err == nil { // resp is now filled
 //        fmt.Println(resp)
 //    }
-{{ $crosslinkURL := GetCrosslinkURL $.API.BaseCrosslinkURL $.API.APIName $.API.Metadata.UID $.ExportedName -}}
+{{ $crosslinkURL := GetCrosslinkURL $.API.BaseCrosslinkURL $.API.Metadata.UID $.ExportedName -}}
 {{ if ne $crosslinkURL "" -}} 
 //
 // Please also see {{ $crosslinkURL }}
@@ -151,7 +150,7 @@ func (c *{{ .API.StructName }}) {{ .ExportedName }}Request(` +
 //
 {{ end -}}
 {{ end -}}
-{{ $crosslinkURL := GetCrosslinkURL $.API.BaseCrosslinkURL $.API.APIName $.API.Metadata.UID $.ExportedName -}}
+{{ $crosslinkURL := GetCrosslinkURL $.API.BaseCrosslinkURL $.API.Metadata.UID $.ExportedName -}}
 {{ if ne $crosslinkURL "" -}} 
 // Please also see {{ $crosslinkURL }}
 {{ end -}}
@@ -216,8 +215,12 @@ func (c *{{ .API.StructName }}) {{ .ExportedName }}PagesWithContext(` +
 	`opts ...request.Option) error {
 	p := request.Pagination {
 		NewRequest: func() (*request.Request, error) {
-			inCpy := *input
-			req, _ := c.{{ .ExportedName }}Request(&inCpy)
+			var inCpy {{ .InputRef.GoType }}
+			if input != nil  {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.{{ .ExportedName }}Request(inCpy)
 			req.SetContext(ctx)
 			req.ApplyOptions(opts...)
 			return req, nil

vendor/github.com/aws/aws-sdk-go/private/model/api/passes.go

@@ -121,18 +121,28 @@ func (r *referenceResolver) resolveShape(shape *Shape) {
 // exportable variant. The shapes are also updated to include notations
 // if they are Input or Outputs.
 func (a *API) renameToplevelShapes() {
-	for _, v := range a.Operations {
+	for _, v := range a.OperationList() {
 		if v.HasInput() {
 			name := v.ExportedName + "Input"
-			switch n := len(v.InputRef.Shape.refs); {
-			case n == 1 && a.Shapes[name] == nil:
+			switch {
+			case a.Shapes[name] == nil:
+				if service, ok := shamelist[a.name]; ok {
+					if check, ok := service[v.Name]; ok && check.input {
+						break
+					}
+				}
 				v.InputRef.Shape.Rename(name)
 			}
 		}
 		if v.HasOutput() {
 			name := v.ExportedName + "Output"
-			switch n := len(v.OutputRef.Shape.refs); {
-			case n == 1 && a.Shapes[name] == nil:
+			switch {
+			case a.Shapes[name] == nil:
+				if service, ok := shamelist[a.name]; ok {
+					if check, ok := service[v.Name]; ok && check.output {
+						break
+					}
+				}
 				v.OutputRef.Shape.Rename(name)
 			}
 		}

vendor/github.com/aws/aws-sdk-go/private/model/api/passes_test.go

@@ -0,0 +1,169 @@
+// +build 1.6,codegen
+
+package api
+
+import (
+	"testing"
+)
+
+func TestUniqueInputAndOutputs(t *testing.T) {
+	shamelist["FooService"] = map[string]struct {
+		input  bool
+		output bool
+	}{}
+	v := shamelist["FooService"]["OpOutputNoRename"]
+	v.output = true
+	shamelist["FooService"]["OpOutputNoRename"] = v
+	v = shamelist["FooService"]["InputNoRename"]
+	v.input = true
+	shamelist["FooService"]["OpInputNoRename"] = v
+	v = shamelist["FooService"]["BothNoRename"]
+	v.input = true
+	v.output = true
+	shamelist["FooService"]["OpBothNoRename"] = v
+
+	testCases := [][]struct {
+		expectedInput  string
+		expectedOutput string
+		operation      string
+		input          string
+		inputRef       string
+		output         string
+		outputRef      string
+	}{
+		{
+			{
+				expectedInput:  "FooOperationInput",
+				expectedOutput: "FooOperationOutput",
+				operation:      "FooOperation",
+				input:          "FooInputShape",
+				inputRef:       "FooInputShapeRef",
+				output:         "FooOutputShape",
+				outputRef:      "FooOutputShapeRef",
+			},
+			{
+				expectedInput:  "BarOperationInput",
+				expectedOutput: "BarOperationOutput",
+				operation:      "BarOperation",
+				input:          "FooInputShape",
+				inputRef:       "FooInputShapeRef",
+				output:         "FooOutputShape",
+				outputRef:      "FooOutputShapeRef",
+			},
+		},
+		{
+			{
+				expectedInput:  "FooOperationInput",
+				expectedOutput: "FooOperationOutput",
+				operation:      "FooOperation",
+				input:          "FooInputShape",
+				inputRef:       "FooInputShapeRef",
+				output:         "FooOutputShape",
+				outputRef:      "FooOutputShapeRef",
+			},
+			{
+				expectedInput:  "OpOutputNoRenameInput",
+				expectedOutput: "OpOutputNoRenameOutputShape",
+				operation:      "OpOutputNoRename",
+				input:          "OpOutputNoRenameInputShape",
+				inputRef:       "OpOutputNoRenameInputRef",
+				output:         "OpOutputNoRenameOutputShape",
+				outputRef:      "OpOutputNoRenameOutputRef",
+			},
+		},
+		{
+			{
+				expectedInput:  "FooOperationInput",
+				expectedOutput: "FooOperationOutput",
+				operation:      "FooOperation",
+				input:          "FooInputShape",
+				inputRef:       "FooInputShapeRef",
+				output:         "FooOutputShape",
+				outputRef:      "FooOutputShapeRef",
+			},
+			{
+				expectedInput:  "OpInputNoRenameInputShape",
+				expectedOutput: "OpInputNoRenameOutput",
+				operation:      "OpInputNoRename",
+				input:          "OpInputNoRenameInputShape",
+				inputRef:       "OpInputNoRenameInputRef",
+				output:         "OpInputNoRenameOutputShape",
+				outputRef:      "OpInputNoRenameOutputRef",
+			},
+		},
+		{
+			{
+				expectedInput:  "FooOperationInput",
+				expectedOutput: "FooOperationOutput",
+				operation:      "FooOperation",
+				input:          "FooInputShape",
+				inputRef:       "FooInputShapeRef",
+				output:         "FooOutputShape",
+				outputRef:      "FooOutputShapeRef",
+			},
+			{
+				expectedInput:  "OpInputNoRenameInputShape",
+				expectedOutput: "OpInputNoRenameOutputShape",
+				operation:      "OpBothNoRename",
+				input:          "OpInputNoRenameInputShape",
+				inputRef:       "OpInputNoRenameInputRef",
+				output:         "OpInputNoRenameOutputShape",
+				outputRef:      "OpInputNoRenameOutputRef",
+			},
+		},
+	}
+
+	for _, c := range testCases {
+		a := &API{
+			name:       "FooService",
+			Operations: map[string]*Operation{},
+		}
+
+		expected := map[string][]string{}
+		a.Shapes = map[string]*Shape{}
+		for _, op := range c {
+			a.Operations[op.operation] = &Operation{
+				ExportedName: op.operation,
+			}
+			a.Operations[op.operation].Name = op.operation
+			a.Operations[op.operation].InputRef = ShapeRef{
+				API:       a,
+				ShapeName: op.inputRef,
+				Shape: &Shape{
+					API:       a,
+					ShapeName: op.input,
+				},
+			}
+			a.Operations[op.operation].OutputRef = ShapeRef{
+				API:       a,
+				ShapeName: op.outputRef,
+				Shape: &Shape{
+					API:       a,
+					ShapeName: op.output,
+				},
+			}
+
+			a.Shapes[op.input] = &Shape{
+				ShapeName: op.input,
+			}
+			a.Shapes[op.output] = &Shape{
+				ShapeName: op.output,
+			}
+
+			expected[op.operation] = append(expected[op.operation], op.expectedInput)
+			expected[op.operation] = append(expected[op.operation], op.expectedOutput)
+		}
+
+		a.fixStutterNames()
+		a.renameToplevelShapes()
+		for k, v := range expected {
+			if a.Operations[k].InputRef.Shape.ShapeName != v[0] {
+				t.Errorf("Error %d case: Expected %q, but received %q", k, v[0], a.Operations[k].InputRef.Shape.ShapeName)
+			}
+			if a.Operations[k].OutputRef.Shape.ShapeName != v[1] {
+				t.Errorf("Error %d case: Expected %q, but received %q", k, v[1], a.Operations[k].OutputRef.Shape.ShapeName)
+			}
+		}
+
+	}
+}

vendor/github.com/aws/aws-sdk-go/private/model/api/shape.go

@@ -33,6 +33,8 @@ type ShapeRef struct {
 	Deprecated       bool `json:"deprecated"`
 
 	OrigShapeName string `json:"-"`
+
+	GenerateGetter bool
 }
 
 // ErrorInfo represents the error block of a shape's structure
@@ -145,6 +147,14 @@ func (s *Shape) GoTypeWithPkgName() string {
 	return goType(s, true)
 }
 
+func (s *Shape) GoTypeWithPkgNameElem() string {
+	t := goType(s, true)
+	if strings.HasPrefix(t, "*") {
+		return t[1:]
+	}
+	return t
+}
+
 // GenAccessors returns if the shape's reference should have setters generated.
 func (s *ShapeRef) UseIndirection() bool {
 	switch s.Shape.Type {
@@ -244,11 +254,11 @@ func goType(s *Shape, withPkgName bool) string {
 		}
 		return "*" + s.ShapeName
 	case "map":
-		return "map[string]" + s.ValueRef.GoType()
+		return "map[string]" + goType(s.ValueRef.Shape, withPkgName)
 	case "jsonvalue":
 		return "aws.JSONValue"
 	case "list":
-		return "[]" + s.MemberRef.GoType()
+		return "[]" + goType(s.MemberRef.Shape, withPkgName)
 	case "boolean":
 		return "*bool"
 	case "string", "character":
@@ -392,16 +402,18 @@ func (ref *ShapeRef) GoTags(toplevel bool, isRequired bool) string {
 		if ref.Shape.Payload != "" {
 			tags = append(tags, ShapeTag{"payload", ref.Shape.Payload})
 		}
-		if ref.XMLNamespace.Prefix != "" {
-			tags = append(tags, ShapeTag{"xmlPrefix", ref.XMLNamespace.Prefix})
-		} else if ref.Shape.XMLNamespace.Prefix != "" {
-			tags = append(tags, ShapeTag{"xmlPrefix", ref.Shape.XMLNamespace.Prefix})
-		}
-		if ref.XMLNamespace.URI != "" {
-			tags = append(tags, ShapeTag{"xmlURI", ref.XMLNamespace.URI})
-		} else if ref.Shape.XMLNamespace.URI != "" {
-			tags = append(tags, ShapeTag{"xmlURI", ref.Shape.XMLNamespace.URI})
-		}
+	}
+
+	if ref.XMLNamespace.Prefix != "" {
+		tags = append(tags, ShapeTag{"xmlPrefix", ref.XMLNamespace.Prefix})
+	} else if ref.Shape.XMLNamespace.Prefix != "" {
+		tags = append(tags, ShapeTag{"xmlPrefix", ref.Shape.XMLNamespace.Prefix})
+	}
+
+	if ref.XMLNamespace.URI != "" {
+		tags = append(tags, ShapeTag{"xmlURI", ref.XMLNamespace.URI})
+	} else if ref.Shape.XMLNamespace.URI != "" {
+		tags = append(tags, ShapeTag{"xmlURI", ref.Shape.XMLNamespace.URI})
 	}
 
 	if ref.IdempotencyToken || ref.Shape.IdempotencyToken {
@@ -505,12 +517,12 @@ var structShapeTmpl = template.Must(template.New("StructShape").Funcs(template.F
 }).Parse(`
 {{ .Docstring }}
 {{ if ne $.OrigShapeName "" -}}
-{{ $crosslinkURL := GetCrosslinkURL $.API.BaseCrosslinkURL $.API.APIName $.API.Metadata.UID $.OrigShapeName -}}
+{{ $crosslinkURL := GetCrosslinkURL $.API.BaseCrosslinkURL $.API.Metadata.UID $.OrigShapeName -}}
 {{ if ne $crosslinkURL "" -}} 
 // Please also see {{ $crosslinkURL }}
 {{ end -}}
 {{ else -}}
-{{ $crosslinkURL := GetCrosslinkURL $.API.BaseCrosslinkURL $.API.APIName $.API.Metadata.UID $.ShapeName -}}
+{{ $crosslinkURL := GetCrosslinkURL $.API.BaseCrosslinkURL $.API.Metadata.UID $.ShapeName -}}
 {{ if ne $crosslinkURL "" -}} 
 // Please also see {{ $crosslinkURL }}
 {{ end -}}
@@ -521,14 +533,23 @@ type {{ .ShapeName }} struct {
 
 	{{ range $_, $name := $context.MemberNames -}}
 		{{ $elem := index $context.MemberRefs $name -}}
+		{{ $isBlob := $context.WillRefBeBase64Encoded $name -}}
 		{{ $isRequired := $context.IsRequired $name -}}
 		{{ $doc := $elem.Docstring -}}
 
-		{{ $doc }}
-		{{ if $isRequired -}}
+		{{ if $doc -}}
+			{{ $doc }}
+		{{ end -}}
+		{{ if $isBlob -}}
 			{{ if $doc -}}
 				//
 			{{ end -}}
+			// {{ $name }} is automatically base64 encoded/decoded by the SDK.
+		{{ end -}}
+		{{ if $isRequired -}}
+			{{ if or $doc $isBlob -}}
+				//
+			{{ end -}}
 			// {{ $name }} is a required field
 		{{ end -}}
 		{{ $name }} {{ $context.GoStructType $name $elem }} {{ $elem.GoTags false $isRequired }}
@@ -561,6 +582,19 @@ func (s *{{ $builderShapeName }}) Set{{ $name }}(v {{ $context.GoStructValueType
 	return s
 }
 
+{{ if $elem.GenerateGetter -}}
+func (s *{{ $builderShapeName }}) get{{ $name }}() (v {{ $context.GoStructValueType $name $elem }}) {
+	{{ if $elem.UseIndirection -}}
+		if s.{{ $name }} == nil {
+			return v
+		}
+		return *s.{{ $name }}
+	{{ else -}}
+		return s.{{ $name }}
+	{{ end -}}
+}
+{{- end }}
+
 {{ end }}
 {{ end }}
 `))
@@ -634,3 +668,17 @@ func (s *Shape) removeRef(ref *ShapeRef) {
 		}
 	}
 }
+
+func (s *Shape) WillRefBeBase64Encoded(refName string) bool {
+	payloadRefName := s.Payload
+	if payloadRefName == refName {
+		return false
+	}
+
+	ref, ok := s.MemberRefs[refName]
+	if !ok {
+		panic(fmt.Sprintf("shape %s does not contain %q refName", s.ShapeName, refName))
+	}
+
+	return ref.Shape.Type == "blob"
+}

vendor/github.com/aws/aws-sdk-go/private/model/api/shapetag_test.go

@@ -6,7 +6,6 @@ import (
 	"testing"
 
 	"github.com/aws/aws-sdk-go/private/model/api"
-	"github.com/stretchr/testify/assert"
 )
 
 func TestShapeTagJoin(t *testing.T) {
@@ -20,6 +19,10 @@ func TestShapeTagJoin(t *testing.T) {
 
 	o := s.Join(" ")
 	o2 := s.String()
-	assert.Equal(t, expected, o)
-	assert.Equal(t, expected, o2)
+	if expected != o {
+		t.Errorf("Expected %s, but received %s", expected, o)
+	}
+	if expected != o2 {
+		t.Errorf("Expected %s, but received %s", expected, o2)
+	}
 }

vendor/github.com/aws/aws-sdk-go/private/model/api/waiters.go

@@ -113,7 +113,7 @@ var waiterTmpls = template.Must(template.New("waiterTmpls").Funcs(
 {{ define "waiter"}}
 // WaitUntil{{ .Name }} uses the {{ .Operation.API.NiceName }} API operation
 // {{ .OperationName }} to wait for a condition to be met before returning.
-// If the condition is not meet within the max attempt window an error will
+// If the condition is not met within the max attempt window, an error will
 // be returned.
 func (c *{{ .Operation.API.StructName }}) WaitUntil{{ .Name }}(input {{ .Operation.InputRef.GoType }}) error {
 	return c.WaitUntil{{ .Name }}WithContext(aws.BackgroundContext(), input)
@@ -144,7 +144,12 @@ func (c *{{ .Operation.API.StructName }}) WaitUntil{{ .Name }}WithContext(` +
 		},
 		Logger: c.Config.Logger,
 		NewRequest: func(opts []request.Option) (*request.Request, error) {
-			req, _ := c.{{ .OperationName }}Request(input)
+			var inCpy {{ .Operation.InputRef.GoType }}
+			if input != nil  {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.{{ .OperationName }}Request(inCpy)
 			req.SetContext(ctx)
 			req.ApplyOptions(opts...)
 			return req, nil

vendor/github.com/aws/aws-sdk-go/private/model/cli/gen-api/main.go

@@ -62,6 +62,20 @@ func newGenerateInfo(modelFile, svcPath, svcImportPath string) *generateInfo {
 		fmt.Println("waiters-2.json error:", err)
 	}
 
+	examplesFile := strings.Replace(modelFile, "api-2.json", "examples-1.json", -1)
+	if _, err := os.Stat(examplesFile); err == nil {
+		g.API.AttachExamples(examplesFile)
+	} else if !os.IsNotExist(err) {
+		fmt.Println("examples-1.json error:", err)
+	}
+
+	//	pkgDocAddonsFile := strings.Replace(modelFile, "api-2.json", "go-pkg-doc.gotmpl", -1)
+	//	if _, err := os.Stat(pkgDocAddonsFile); err == nil {
+	//		g.API.AttachPackageDocAddons(pkgDocAddonsFile)
+	//	} else if !os.IsNotExist(err) {
+	//		fmt.Println("go-pkg-doc.gotmpl error:", err)
+	//	}
+
 	g.API.Setup()
 
 	if svc := os.Getenv("SERVICES"); svc != "" {
@@ -175,13 +189,14 @@ func writeServiceFiles(g *generateInfo, filename string) {
 	fmt.Printf("Generating %s (%s)...\n",
 		g.API.PackageName(), g.API.Metadata.APIVersion)
 
-	// write api.go and service.go files
+	// write files for service client and API
+	Must(writeServiceDocFile(g))
 	Must(writeAPIFile(g))
-	Must(writeExamplesFile(g))
 	Must(writeServiceFile(g))
 	Must(writeInterfaceFile(g))
 	Must(writeWaitersFile(g))
 	Must(writeAPIErrorsFile(g))
+	Must(writeExamplesFile(g))
 }
 
 // Must will panic if the error passed in is not nil.
@@ -191,7 +206,8 @@ func Must(err error) {
 	}
 }
 
-const codeLayout = `// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
+const codeLayout = `// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
+
 %s
 package %s
 
@@ -202,14 +218,28 @@ func writeGoFile(file string, layout string, args ...interface{}) error {
 	return ioutil.WriteFile(file, []byte(util.GoFmt(fmt.Sprintf(layout, args...))), 0664)
 }
 
+// writeServiceDocFile generates the documentation for service package.
+func writeServiceDocFile(g *generateInfo) error {
+	return writeGoFile(filepath.Join(g.PackageDir, "doc.go"),
+		codeLayout,
+		strings.TrimSpace(g.API.ServicePackageDoc()),
+		g.API.PackageName(),
+		"",
+	)
+}
+
 // writeExamplesFile writes out the service example file.
 func writeExamplesFile(g *generateInfo) error {
-	return writeGoFile(filepath.Join(g.PackageDir, "examples_test.go"),
-		codeLayout,
-		"",
-		g.API.PackageName()+"_test",
-		g.API.ExampleGoCode(),
-	)
+	code := g.API.ExamplesGoCode()
+	if len(code) > 0 {
+		return writeGoFile(filepath.Join(g.PackageDir, "examples_test.go"),
+			codeLayout,
+			"",
+			g.API.PackageName()+"_test",
+			code,
+		)
+	}
+	return nil
 }
 
 // writeServiceFile writes out the service initialization file.
@@ -252,18 +282,17 @@ func writeWaitersFile(g *generateInfo) error {
 	)
 }
 
-// writeAPIFile writes out the service api file.
+// writeAPIFile writes out the service API file.
 func writeAPIFile(g *generateInfo) error {
 	return writeGoFile(filepath.Join(g.PackageDir, "api.go"),
 		codeLayout,
-		fmt.Sprintf("\n// Package %s provides a client for %s.",
-			g.API.PackageName(), g.API.Metadata.ServiceFullName),
+		"",
 		g.API.PackageName(),
 		g.API.APIGoCode(),
 	)
 }
 
-// writeAPIErrorsFile writes out the service api errors file.
+// writeAPIErrorsFile writes out the service API errors file.
 func writeAPIErrorsFile(g *generateInfo) error {
 	return writeGoFile(filepath.Join(g.PackageDir, "errors.go"),
 		codeLayout,

vendor/github.com/aws/aws-sdk-go/private/protocol/ec2query/build_test.go

@@ -45,8 +45,12 @@ func init() {
 	protocol.RandReader = &awstesting.ZeroReader{}
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// InputService1ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// InputService1ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type InputService1ProtocolTest struct {
 	*client.Client
 }
@@ -104,19 +108,18 @@ const opInputService1TestCaseOperation1 = "OperationName"
 
 // InputService1TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the InputService1TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService1TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService1TestCaseOperation1 method directly
-// instead.
+// See InputService1TestCaseOperation1 for more information on using the InputService1TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService1TestCaseOperation1Request method.
 //    req, resp := client.InputService1TestCaseOperation1Request(params)
@@ -195,8 +198,12 @@ type InputService1TestShapeInputService1TestCaseOperation1Output struct {
 	_ struct{} `type:"structure"`
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// InputService2ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// InputService2ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type InputService2ProtocolTest struct {
 	*client.Client
 }
@@ -254,19 +261,18 @@ const opInputService2TestCaseOperation1 = "OperationName"
 
 // InputService2TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the InputService2TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService2TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService2TestCaseOperation1 method directly
-// instead.
+// See InputService2TestCaseOperation1 for more information on using the InputService2TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService2TestCaseOperation1Request method.
 //    req, resp := client.InputService2TestCaseOperation1Request(params)
@@ -353,8 +359,12 @@ type InputService2TestShapeInputService2TestCaseOperation1Output struct {
 	_ struct{} `type:"structure"`
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// InputService3ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// InputService3ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type InputService3ProtocolTest struct {
 	*client.Client
 }
@@ -412,19 +422,18 @@ const opInputService3TestCaseOperation1 = "OperationName"
 
 // InputService3TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the InputService3TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService3TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService3TestCaseOperation1 method directly
-// instead.
+// See InputService3TestCaseOperation1 for more information on using the InputService3TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService3TestCaseOperation1Request method.
 //    req, resp := client.InputService3TestCaseOperation1Request(params)
@@ -507,8 +516,12 @@ func (s *InputService3TestShapeStructType) SetScalarArg(v string) *InputService3
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// InputService4ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// InputService4ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type InputService4ProtocolTest struct {
 	*client.Client
 }
@@ -566,19 +579,18 @@ const opInputService4TestCaseOperation1 = "OperationName"
 
 // InputService4TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the InputService4TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService4TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService4TestCaseOperation1 method directly
-// instead.
+// See InputService4TestCaseOperation1 for more information on using the InputService4TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService4TestCaseOperation1Request method.
 //    req, resp := client.InputService4TestCaseOperation1Request(params)
@@ -649,8 +661,12 @@ type InputService4TestShapeInputService4TestCaseOperation1Output struct {
 	_ struct{} `type:"structure"`
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// InputService5ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// InputService5ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type InputService5ProtocolTest struct {
 	*client.Client
 }
@@ -708,19 +724,18 @@ const opInputService5TestCaseOperation1 = "OperationName"
 
 // InputService5TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the InputService5TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService5TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService5TestCaseOperation1 method directly
-// instead.
+// See InputService5TestCaseOperation1 for more information on using the InputService5TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService5TestCaseOperation1Request method.
 //    req, resp := client.InputService5TestCaseOperation1Request(params)
@@ -791,8 +806,12 @@ type InputService5TestShapeInputService5TestCaseOperation1Output struct {
 	_ struct{} `type:"structure"`
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// InputService6ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// InputService6ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type InputService6ProtocolTest struct {
 	*client.Client
 }
@@ -850,19 +869,18 @@ const opInputService6TestCaseOperation1 = "OperationName"
 
 // InputService6TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the InputService6TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService6TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService6TestCaseOperation1 method directly
-// instead.
+// See InputService6TestCaseOperation1 for more information on using the InputService6TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService6TestCaseOperation1Request method.
 //    req, resp := client.InputService6TestCaseOperation1Request(params)
@@ -933,8 +951,12 @@ type InputService6TestShapeInputService6TestCaseOperation1Output struct {
 	_ struct{} `type:"structure"`
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// InputService7ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// InputService7ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type InputService7ProtocolTest struct {
 	*client.Client
 }
@@ -992,19 +1014,18 @@ const opInputService7TestCaseOperation1 = "OperationName"
 
 // InputService7TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the InputService7TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService7TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService7TestCaseOperation1 method directly
-// instead.
+// See InputService7TestCaseOperation1 for more information on using the InputService7TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService7TestCaseOperation1Request method.
 //    req, resp := client.InputService7TestCaseOperation1Request(params)
@@ -1076,8 +1097,12 @@ type InputService7TestShapeInputService7TestCaseOperation1Output struct {
 	_ struct{} `type:"structure"`
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// InputService8ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// InputService8ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type InputService8ProtocolTest struct {
 	*client.Client
 }
@@ -1135,19 +1160,18 @@ const opInputService8TestCaseOperation1 = "OperationName"
 
 // InputService8TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the InputService8TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService8TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService8TestCaseOperation1 method directly
-// instead.
+// See InputService8TestCaseOperation1 for more information on using the InputService8TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService8TestCaseOperation1Request method.
 //    req, resp := client.InputService8TestCaseOperation1Request(params)
@@ -1218,8 +1242,12 @@ type InputService8TestShapeInputService8TestCaseOperation1Output struct {
 	_ struct{} `type:"structure"`
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// InputService9ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// InputService9ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type InputService9ProtocolTest struct {
 	*client.Client
 }
@@ -1277,19 +1305,18 @@ const opInputService9TestCaseOperation1 = "OperationName"
 
 // InputService9TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the InputService9TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService9TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService9TestCaseOperation1 method directly
-// instead.
+// See InputService9TestCaseOperation1 for more information on using the InputService9TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService9TestCaseOperation1Request method.
 //    req, resp := client.InputService9TestCaseOperation1Request(params)
@@ -1298,14 +1325,14 @@ const opInputService9TestCaseOperation1 = "OperationName"
 //    if err == nil { // resp is now filled
 //        fmt.Println(resp)
 //    }
-func (c *InputService9ProtocolTest) InputService9TestCaseOperation1Request(input *InputService9TestShapeInputShape) (req *request.Request, output *InputService9TestShapeInputService9TestCaseOperation1Output) {
+func (c *InputService9ProtocolTest) InputService9TestCaseOperation1Request(input *InputService9TestShapeInputService9TestCaseOperation2Input) (req *request.Request, output *InputService9TestShapeInputService9TestCaseOperation1Output) {
 	op := &request.Operation{
 		Name:     opInputService9TestCaseOperation1,
 		HTTPPath: "/",
 	}
 
 	if input == nil {
-		input = &InputService9TestShapeInputShape{}
+		input = &InputService9TestShapeInputService9TestCaseOperation2Input{}
 	}
 
 	output = &InputService9TestShapeInputService9TestCaseOperation1Output{}
@@ -1323,7 +1350,7 @@ func (c *InputService9ProtocolTest) InputService9TestCaseOperation1Request(input
 //
 // See the AWS API reference guide for 's
 // API operation InputService9TestCaseOperation1 for usage and error information.
-func (c *InputService9ProtocolTest) InputService9TestCaseOperation1(input *InputService9TestShapeInputShape) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) {
+func (c *InputService9ProtocolTest) InputService9TestCaseOperation1(input *InputService9TestShapeInputService9TestCaseOperation2Input) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) {
 	req, out := c.InputService9TestCaseOperation1Request(input)
 	return out, req.Send()
 }
@@ -1337,7 +1364,7 @@ func (c *InputService9ProtocolTest) InputService9TestCaseOperation1(input *Input
 // the context is nil a panic will occur. In the future the SDK may create
 // sub-contexts for http.Requests. See https://golang.org/pkg/context/
 // for more information on using Contexts.
-func (c *InputService9ProtocolTest) InputService9TestCaseOperation1WithContext(ctx aws.Context, input *InputService9TestShapeInputShape, opts ...request.Option) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) {
+func (c *InputService9ProtocolTest) InputService9TestCaseOperation1WithContext(ctx aws.Context, input *InputService9TestShapeInputService9TestCaseOperation2Input, opts ...request.Option) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) {
 	req, out := c.InputService9TestCaseOperation1Request(input)
 	req.SetContext(ctx)
 	req.ApplyOptions(opts...)
@@ -1348,19 +1375,18 @@ const opInputService9TestCaseOperation2 = "OperationName"
 
 // InputService9TestCaseOperation2Request generates a "aws/request.Request" representing the
 // client's request for the InputService9TestCaseOperation2 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService9TestCaseOperation2 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService9TestCaseOperation2 method directly
-// instead.
+// See InputService9TestCaseOperation2 for more information on using the InputService9TestCaseOperation2
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService9TestCaseOperation2Request method.
 //    req, resp := client.InputService9TestCaseOperation2Request(params)
@@ -1369,14 +1395,14 @@ const opInputService9TestCaseOperation2 = "OperationName"
 //    if err == nil { // resp is now filled
 //        fmt.Println(resp)
 //    }
-func (c *InputService9ProtocolTest) InputService9TestCaseOperation2Request(input *InputService9TestShapeInputShape) (req *request.Request, output *InputService9TestShapeInputService9TestCaseOperation2Output) {
+func (c *InputService9ProtocolTest) InputService9TestCaseOperation2Request(input *InputService9TestShapeInputService9TestCaseOperation2Input) (req *request.Request, output *InputService9TestShapeInputService9TestCaseOperation2Output) {
 	op := &request.Operation{
 		Name:     opInputService9TestCaseOperation2,
 		HTTPPath: "/",
 	}
 
 	if input == nil {
-		input = &InputService9TestShapeInputShape{}
+		input = &InputService9TestShapeInputService9TestCaseOperation2Input{}
 	}
 
 	output = &InputService9TestShapeInputService9TestCaseOperation2Output{}
@@ -1394,7 +1420,7 @@ func (c *InputService9ProtocolTest) InputService9TestCaseOperation2Request(input
 //
 // See the AWS API reference guide for 's
 // API operation InputService9TestCaseOperation2 for usage and error information.
-func (c *InputService9ProtocolTest) InputService9TestCaseOperation2(input *InputService9TestShapeInputShape) (*InputService9TestShapeInputService9TestCaseOperation2Output, error) {
+func (c *InputService9ProtocolTest) InputService9TestCaseOperation2(input *InputService9TestShapeInputService9TestCaseOperation2Input) (*InputService9TestShapeInputService9TestCaseOperation2Output, error) {
 	req, out := c.InputService9TestCaseOperation2Request(input)
 	return out, req.Send()
 }
@@ -1408,7 +1434,7 @@ func (c *InputService9ProtocolTest) InputService9TestCaseOperation2(input *Input
 // the context is nil a panic will occur. In the future the SDK may create
 // sub-contexts for http.Requests. See https://golang.org/pkg/context/
 // for more information on using Contexts.
-func (c *InputService9ProtocolTest) InputService9TestCaseOperation2WithContext(ctx aws.Context, input *InputService9TestShapeInputShape, opts ...request.Option) (*InputService9TestShapeInputService9TestCaseOperation2Output, error) {
+func (c *InputService9ProtocolTest) InputService9TestCaseOperation2WithContext(ctx aws.Context, input *InputService9TestShapeInputService9TestCaseOperation2Input, opts ...request.Option) (*InputService9TestShapeInputService9TestCaseOperation2Output, error) {
 	req, out := c.InputService9TestCaseOperation2Request(input)
 	req.SetContext(ctx)
 	req.ApplyOptions(opts...)
@@ -1419,22 +1445,22 @@ type InputService9TestShapeInputService9TestCaseOperation1Output struct {
 	_ struct{} `type:"structure"`
 }
 
-type InputService9TestShapeInputService9TestCaseOperation2Output struct {
-	_ struct{} `type:"structure"`
-}
-
-type InputService9TestShapeInputShape struct {
+type InputService9TestShapeInputService9TestCaseOperation2Input struct {
 	_ struct{} `type:"structure"`
 
 	Token *string `type:"string" idempotencyToken:"true"`
 }
 
 // SetToken sets the Token field's value.
-func (s *InputService9TestShapeInputShape) SetToken(v string) *InputService9TestShapeInputShape {
+func (s *InputService9TestShapeInputService9TestCaseOperation2Input) SetToken(v string) *InputService9TestShapeInputService9TestCaseOperation2Input {
 	s.Token = &v
 	return s
 }
 
+type InputService9TestShapeInputService9TestCaseOperation2Output struct {
+	_ struct{} `type:"structure"`
+}
+
 //
 // Tests begin here
 //
@@ -1650,7 +1676,7 @@ func TestInputService8ProtocolTestTimestampValuesCase1(t *testing.T) {
 
 func TestInputService9ProtocolTestIdempotencyTokenAutoFillCase1(t *testing.T) {
 	svc := NewInputService9ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
-	input := &InputService9TestShapeInputShape{
+	input := &InputService9TestShapeInputService9TestCaseOperation2Input{
 		Token: aws.String("abc123"),
 	}
 	req, _ := svc.InputService9TestCaseOperation1Request(input)
@@ -1674,7 +1700,7 @@ func TestInputService9ProtocolTestIdempotencyTokenAutoFillCase1(t *testing.T) {
 
 func TestInputService9ProtocolTestIdempotencyTokenAutoFillCase2(t *testing.T) {
 	svc := NewInputService9ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
-	input := &InputService9TestShapeInputShape{}
+	input := &InputService9TestShapeInputService9TestCaseOperation2Input{}
 	req, _ := svc.InputService9TestCaseOperation2Request(input)
 	r := req.HTTPRequest
 

vendor/github.com/aws/aws-sdk-go/private/protocol/ec2query/unmarshal_test.go

@@ -45,8 +45,12 @@ func init() {
 	protocol.RandReader = &awstesting.ZeroReader{}
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService1ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService1ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService1ProtocolTest struct {
 	*client.Client
 }
@@ -104,19 +108,18 @@ const opOutputService1TestCaseOperation1 = "OperationName"
 
 // OutputService1TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService1TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService1TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService1TestCaseOperation1 method directly
-// instead.
+// See OutputService1TestCaseOperation1 for more information on using the OutputService1TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService1TestCaseOperation1Request method.
 //    req, resp := client.OutputService1TestCaseOperation1Request(params)
@@ -241,8 +244,12 @@ func (s *OutputService1TestShapeOutputService1TestCaseOperation1Output) SetTrueB
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService2ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService2ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService2ProtocolTest struct {
 	*client.Client
 }
@@ -300,19 +307,18 @@ const opOutputService2TestCaseOperation1 = "OperationName"
 
 // OutputService2TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService2TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService2TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService2TestCaseOperation1 method directly
-// instead.
+// See OutputService2TestCaseOperation1 for more information on using the OutputService2TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService2TestCaseOperation1Request method.
 //    req, resp := client.OutputService2TestCaseOperation1Request(params)
@@ -382,8 +388,12 @@ func (s *OutputService2TestShapeOutputService2TestCaseOperation1Output) SetBlob(
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService3ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService3ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService3ProtocolTest struct {
 	*client.Client
 }
@@ -441,19 +451,18 @@ const opOutputService3TestCaseOperation1 = "OperationName"
 
 // OutputService3TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService3TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService3TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService3TestCaseOperation1 method directly
-// instead.
+// See OutputService3TestCaseOperation1 for more information on using the OutputService3TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService3TestCaseOperation1Request method.
 //    req, resp := client.OutputService3TestCaseOperation1Request(params)
@@ -522,8 +531,12 @@ func (s *OutputService3TestShapeOutputService3TestCaseOperation1Output) SetListM
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService4ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService4ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService4ProtocolTest struct {
 	*client.Client
 }
@@ -581,19 +594,18 @@ const opOutputService4TestCaseOperation1 = "OperationName"
 
 // OutputService4TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService4TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService4TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService4TestCaseOperation1 method directly
-// instead.
+// See OutputService4TestCaseOperation1 for more information on using the OutputService4TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService4TestCaseOperation1Request method.
 //    req, resp := client.OutputService4TestCaseOperation1Request(params)
@@ -662,8 +674,12 @@ func (s *OutputService4TestShapeOutputService4TestCaseOperation1Output) SetListM
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService5ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService5ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService5ProtocolTest struct {
 	*client.Client
 }
@@ -721,19 +737,18 @@ const opOutputService5TestCaseOperation1 = "OperationName"
 
 // OutputService5TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService5TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService5TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService5TestCaseOperation1 method directly
-// instead.
+// See OutputService5TestCaseOperation1 for more information on using the OutputService5TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService5TestCaseOperation1Request method.
 //    req, resp := client.OutputService5TestCaseOperation1Request(params)
@@ -802,8 +817,12 @@ func (s *OutputService5TestShapeOutputService5TestCaseOperation1Output) SetListM
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService6ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService6ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService6ProtocolTest struct {
 	*client.Client
 }
@@ -861,19 +880,18 @@ const opOutputService6TestCaseOperation1 = "OperationName"
 
 // OutputService6TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService6TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService6TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService6TestCaseOperation1 method directly
-// instead.
+// See OutputService6TestCaseOperation1 for more information on using the OutputService6TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService6TestCaseOperation1Request method.
 //    req, resp := client.OutputService6TestCaseOperation1Request(params)
@@ -954,8 +972,12 @@ func (s *OutputService6TestShapeStructureType) SetFoo(v string) *OutputService6T
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService7ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService7ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService7ProtocolTest struct {
 	*client.Client
 }
@@ -1013,19 +1035,18 @@ const opOutputService7TestCaseOperation1 = "OperationName"
 
 // OutputService7TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService7TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService7TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService7TestCaseOperation1 method directly
-// instead.
+// See OutputService7TestCaseOperation1 for more information on using the OutputService7TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService7TestCaseOperation1Request method.
 //    req, resp := client.OutputService7TestCaseOperation1Request(params)
@@ -1094,8 +1115,12 @@ func (s *OutputService7TestShapeOutputService7TestCaseOperation1Output) SetMap(v
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService8ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService8ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService8ProtocolTest struct {
 	*client.Client
 }
@@ -1153,19 +1178,18 @@ const opOutputService8TestCaseOperation1 = "OperationName"
 
 // OutputService8TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService8TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService8TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService8TestCaseOperation1 method directly
-// instead.
+// See OutputService8TestCaseOperation1 for more information on using the OutputService8TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService8TestCaseOperation1Request method.
 //    req, resp := client.OutputService8TestCaseOperation1Request(params)
@@ -1234,8 +1258,12 @@ func (s *OutputService8TestShapeOutputService8TestCaseOperation1Output) SetMap(v
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService9ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService9ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService9ProtocolTest struct {
 	*client.Client
 }
@@ -1293,19 +1321,18 @@ const opOutputService9TestCaseOperation1 = "OperationName"
 
 // OutputService9TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService9TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService9TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService9TestCaseOperation1 method directly
-// instead.
+// See OutputService9TestCaseOperation1 for more information on using the OutputService9TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService9TestCaseOperation1Request method.
 //    req, resp := client.OutputService9TestCaseOperation1Request(params)

vendor/github.com/aws/aws-sdk-go/private/protocol/jsonrpc/build_test.go

@@ -45,8 +45,12 @@ func init() {
 	protocol.RandReader = &awstesting.ZeroReader{}
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// InputService1ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// InputService1ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type InputService1ProtocolTest struct {
 	*client.Client
 }
@@ -106,19 +110,18 @@ const opInputService1TestCaseOperation1 = "OperationName"
 
 // InputService1TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the InputService1TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService1TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService1TestCaseOperation1 method directly
-// instead.
+// See InputService1TestCaseOperation1 for more information on using the InputService1TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService1TestCaseOperation1Request method.
 //    req, resp := client.InputService1TestCaseOperation1Request(params)
@@ -190,8 +193,12 @@ type InputService1TestShapeInputService1TestCaseOperation1Output struct {
 	_ struct{} `type:"structure"`
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// InputService2ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// InputService2ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type InputService2ProtocolTest struct {
 	*client.Client
 }
@@ -251,19 +258,18 @@ const opInputService2TestCaseOperation1 = "OperationName"
 
 // InputService2TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the InputService2TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService2TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService2TestCaseOperation1 method directly
-// instead.
+// See InputService2TestCaseOperation1 for more information on using the InputService2TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService2TestCaseOperation1Request method.
 //    req, resp := client.InputService2TestCaseOperation1Request(params)
@@ -334,8 +340,12 @@ type InputService2TestShapeInputService2TestCaseOperation1Output struct {
 	_ struct{} `type:"structure"`
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// InputService3ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// InputService3ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type InputService3ProtocolTest struct {
 	*client.Client
 }
@@ -395,19 +405,18 @@ const opInputService3TestCaseOperation1 = "OperationName"
 
 // InputService3TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the InputService3TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService3TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService3TestCaseOperation1 method directly
-// instead.
+// See InputService3TestCaseOperation1 for more information on using the InputService3TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService3TestCaseOperation1Request method.
 //    req, resp := client.InputService3TestCaseOperation1Request(params)
@@ -416,14 +425,14 @@ const opInputService3TestCaseOperation1 = "OperationName"
 //    if err == nil { // resp is now filled
 //        fmt.Println(resp)
 //    }
-func (c *InputService3ProtocolTest) InputService3TestCaseOperation1Request(input *InputService3TestShapeInputShape) (req *request.Request, output *InputService3TestShapeInputService3TestCaseOperation1Output) {
+func (c *InputService3ProtocolTest) InputService3TestCaseOperation1Request(input *InputService3TestShapeInputService3TestCaseOperation2Input) (req *request.Request, output *InputService3TestShapeInputService3TestCaseOperation1Output) {
 	op := &request.Operation{
 		Name:     opInputService3TestCaseOperation1,
 		HTTPPath: "/",
 	}
 
 	if input == nil {
-		input = &InputService3TestShapeInputShape{}
+		input = &InputService3TestShapeInputService3TestCaseOperation2Input{}
 	}
 
 	output = &InputService3TestShapeInputService3TestCaseOperation1Output{}
@@ -441,7 +450,7 @@ func (c *InputService3ProtocolTest) InputService3TestCaseOperation1Request(input
 //
 // See the AWS API reference guide for 's
 // API operation InputService3TestCaseOperation1 for usage and error information.
-func (c *InputService3ProtocolTest) InputService3TestCaseOperation1(input *InputService3TestShapeInputShape) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) {
+func (c *InputService3ProtocolTest) InputService3TestCaseOperation1(input *InputService3TestShapeInputService3TestCaseOperation2Input) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) {
 	req, out := c.InputService3TestCaseOperation1Request(input)
 	return out, req.Send()
 }
@@ -455,7 +464,7 @@ func (c *InputService3ProtocolTest) InputService3TestCaseOperation1(input *Input
 // the context is nil a panic will occur. In the future the SDK may create
 // sub-contexts for http.Requests. See https://golang.org/pkg/context/
 // for more information on using Contexts.
-func (c *InputService3ProtocolTest) InputService3TestCaseOperation1WithContext(ctx aws.Context, input *InputService3TestShapeInputShape, opts ...request.Option) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) {
+func (c *InputService3ProtocolTest) InputService3TestCaseOperation1WithContext(ctx aws.Context, input *InputService3TestShapeInputService3TestCaseOperation2Input, opts ...request.Option) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) {
 	req, out := c.InputService3TestCaseOperation1Request(input)
 	req.SetContext(ctx)
 	req.ApplyOptions(opts...)
@@ -466,19 +475,18 @@ const opInputService3TestCaseOperation2 = "OperationName"
 
 // InputService3TestCaseOperation2Request generates a "aws/request.Request" representing the
 // client's request for the InputService3TestCaseOperation2 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService3TestCaseOperation2 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService3TestCaseOperation2 method directly
-// instead.
+// See InputService3TestCaseOperation2 for more information on using the InputService3TestCaseOperation2
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService3TestCaseOperation2Request method.
 //    req, resp := client.InputService3TestCaseOperation2Request(params)
@@ -487,14 +495,14 @@ const opInputService3TestCaseOperation2 = "OperationName"
 //    if err == nil { // resp is now filled
 //        fmt.Println(resp)
 //    }
-func (c *InputService3ProtocolTest) InputService3TestCaseOperation2Request(input *InputService3TestShapeInputShape) (req *request.Request, output *InputService3TestShapeInputService3TestCaseOperation2Output) {
+func (c *InputService3ProtocolTest) InputService3TestCaseOperation2Request(input *InputService3TestShapeInputService3TestCaseOperation2Input) (req *request.Request, output *InputService3TestShapeInputService3TestCaseOperation2Output) {
 	op := &request.Operation{
 		Name:     opInputService3TestCaseOperation2,
 		HTTPPath: "/",
 	}
 
 	if input == nil {
-		input = &InputService3TestShapeInputShape{}
+		input = &InputService3TestShapeInputService3TestCaseOperation2Input{}
 	}
 
 	output = &InputService3TestShapeInputService3TestCaseOperation2Output{}
@@ -512,7 +520,7 @@ func (c *InputService3ProtocolTest) InputService3TestCaseOperation2Request(input
 //
 // See the AWS API reference guide for 's
 // API operation InputService3TestCaseOperation2 for usage and error information.
-func (c *InputService3ProtocolTest) InputService3TestCaseOperation2(input *InputService3TestShapeInputShape) (*InputService3TestShapeInputService3TestCaseOperation2Output, error) {
+func (c *InputService3ProtocolTest) InputService3TestCaseOperation2(input *InputService3TestShapeInputService3TestCaseOperation2Input) (*InputService3TestShapeInputService3TestCaseOperation2Output, error) {
 	req, out := c.InputService3TestCaseOperation2Request(input)
 	return out, req.Send()
 }
@@ -526,7 +534,7 @@ func (c *InputService3ProtocolTest) InputService3TestCaseOperation2(input *Input
 // the context is nil a panic will occur. In the future the SDK may create
 // sub-contexts for http.Requests. See https://golang.org/pkg/context/
 // for more information on using Contexts.
-func (c *InputService3ProtocolTest) InputService3TestCaseOperation2WithContext(ctx aws.Context, input *InputService3TestShapeInputShape, opts ...request.Option) (*InputService3TestShapeInputService3TestCaseOperation2Output, error) {
+func (c *InputService3ProtocolTest) InputService3TestCaseOperation2WithContext(ctx aws.Context, input *InputService3TestShapeInputService3TestCaseOperation2Input, opts ...request.Option) (*InputService3TestShapeInputService3TestCaseOperation2Output, error) {
 	req, out := c.InputService3TestCaseOperation2Request(input)
 	req.SetContext(ctx)
 	req.ApplyOptions(opts...)
@@ -537,11 +545,7 @@ type InputService3TestShapeInputService3TestCaseOperation1Output struct {
 	_ struct{} `type:"structure"`
 }
 
-type InputService3TestShapeInputService3TestCaseOperation2Output struct {
-	_ struct{} `type:"structure"`
-}
-
-type InputService3TestShapeInputShape struct {
+type InputService3TestShapeInputService3TestCaseOperation2Input struct {
 	_ struct{} `type:"structure"`
 
 	// BlobArg is automatically base64 encoded/decoded by the SDK.
@@ -551,19 +555,27 @@ type InputService3TestShapeInputShape struct {
 }
 
 // SetBlobArg sets the BlobArg field's value.
-func (s *InputService3TestShapeInputShape) SetBlobArg(v []byte) *InputService3TestShapeInputShape {
+func (s *InputService3TestShapeInputService3TestCaseOperation2Input) SetBlobArg(v []byte) *InputService3TestShapeInputService3TestCaseOperation2Input {
 	s.BlobArg = v
 	return s
 }
 
 // SetBlobMap sets the BlobMap field's value.
-func (s *InputService3TestShapeInputShape) SetBlobMap(v map[string][]byte) *InputService3TestShapeInputShape {
+func (s *InputService3TestShapeInputService3TestCaseOperation2Input) SetBlobMap(v map[string][]byte) *InputService3TestShapeInputService3TestCaseOperation2Input {
 	s.BlobMap = v
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+type InputService3TestShapeInputService3TestCaseOperation2Output struct {
+	_ struct{} `type:"structure"`
+}
+
+// InputService4ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// InputService4ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type InputService4ProtocolTest struct {
 	*client.Client
 }
@@ -623,19 +635,18 @@ const opInputService4TestCaseOperation1 = "OperationName"
 
 // InputService4TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the InputService4TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService4TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService4TestCaseOperation1 method directly
-// instead.
+// See InputService4TestCaseOperation1 for more information on using the InputService4TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService4TestCaseOperation1Request method.
 //    req, resp := client.InputService4TestCaseOperation1Request(params)
@@ -707,8 +718,12 @@ type InputService4TestShapeInputService4TestCaseOperation1Output struct {
 	_ struct{} `type:"structure"`
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// InputService5ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// InputService5ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type InputService5ProtocolTest struct {
 	*client.Client
 }
@@ -768,19 +783,18 @@ const opInputService5TestCaseOperation1 = "OperationName"
 
 // InputService5TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the InputService5TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService5TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService5TestCaseOperation1 method directly
-// instead.
+// See InputService5TestCaseOperation1 for more information on using the InputService5TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService5TestCaseOperation1Request method.
 //    req, resp := client.InputService5TestCaseOperation1Request(params)
@@ -789,14 +803,14 @@ const opInputService5TestCaseOperation1 = "OperationName"
 //    if err == nil { // resp is now filled
 //        fmt.Println(resp)
 //    }
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation1Request(input *InputService5TestShapeInputShape) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation1Output) {
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation1Request(input *InputService5TestShapeInputService5TestCaseOperation6Input) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation1Output) {
 	op := &request.Operation{
 		Name:     opInputService5TestCaseOperation1,
 		HTTPPath: "/",
 	}
 
 	if input == nil {
-		input = &InputService5TestShapeInputShape{}
+		input = &InputService5TestShapeInputService5TestCaseOperation6Input{}
 	}
 
 	output = &InputService5TestShapeInputService5TestCaseOperation1Output{}
@@ -814,7 +828,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation1Request(input
 //
 // See the AWS API reference guide for 's
 // API operation InputService5TestCaseOperation1 for usage and error information.
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation1(input *InputService5TestShapeInputShape) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) {
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation1(input *InputService5TestShapeInputService5TestCaseOperation6Input) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) {
 	req, out := c.InputService5TestCaseOperation1Request(input)
 	return out, req.Send()
 }
@@ -828,7 +842,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation1(input *Input
 // the context is nil a panic will occur. In the future the SDK may create
 // sub-contexts for http.Requests. See https://golang.org/pkg/context/
 // for more information on using Contexts.
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation1WithContext(ctx aws.Context, input *InputService5TestShapeInputShape, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) {
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation1WithContext(ctx aws.Context, input *InputService5TestShapeInputService5TestCaseOperation6Input, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) {
 	req, out := c.InputService5TestCaseOperation1Request(input)
 	req.SetContext(ctx)
 	req.ApplyOptions(opts...)
@@ -839,19 +853,18 @@ const opInputService5TestCaseOperation2 = "OperationName"
 
 // InputService5TestCaseOperation2Request generates a "aws/request.Request" representing the
 // client's request for the InputService5TestCaseOperation2 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService5TestCaseOperation2 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService5TestCaseOperation2 method directly
-// instead.
+// See InputService5TestCaseOperation2 for more information on using the InputService5TestCaseOperation2
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService5TestCaseOperation2Request method.
 //    req, resp := client.InputService5TestCaseOperation2Request(params)
@@ -860,14 +873,14 @@ const opInputService5TestCaseOperation2 = "OperationName"
 //    if err == nil { // resp is now filled
 //        fmt.Println(resp)
 //    }
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation2Request(input *InputService5TestShapeInputShape) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation2Output) {
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation2Request(input *InputService5TestShapeInputService5TestCaseOperation6Input) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation2Output) {
 	op := &request.Operation{
 		Name:     opInputService5TestCaseOperation2,
 		HTTPPath: "/",
 	}
 
 	if input == nil {
-		input = &InputService5TestShapeInputShape{}
+		input = &InputService5TestShapeInputService5TestCaseOperation6Input{}
 	}
 
 	output = &InputService5TestShapeInputService5TestCaseOperation2Output{}
@@ -885,7 +898,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation2Request(input
 //
 // See the AWS API reference guide for 's
 // API operation InputService5TestCaseOperation2 for usage and error information.
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation2(input *InputService5TestShapeInputShape) (*InputService5TestShapeInputService5TestCaseOperation2Output, error) {
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation2(input *InputService5TestShapeInputService5TestCaseOperation6Input) (*InputService5TestShapeInputService5TestCaseOperation2Output, error) {
 	req, out := c.InputService5TestCaseOperation2Request(input)
 	return out, req.Send()
 }
@@ -899,7 +912,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation2(input *Input
 // the context is nil a panic will occur. In the future the SDK may create
 // sub-contexts for http.Requests. See https://golang.org/pkg/context/
 // for more information on using Contexts.
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation2WithContext(ctx aws.Context, input *InputService5TestShapeInputShape, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation2Output, error) {
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation2WithContext(ctx aws.Context, input *InputService5TestShapeInputService5TestCaseOperation6Input, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation2Output, error) {
 	req, out := c.InputService5TestCaseOperation2Request(input)
 	req.SetContext(ctx)
 	req.ApplyOptions(opts...)
@@ -910,19 +923,18 @@ const opInputService5TestCaseOperation3 = "OperationName"
 
 // InputService5TestCaseOperation3Request generates a "aws/request.Request" representing the
 // client's request for the InputService5TestCaseOperation3 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService5TestCaseOperation3 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService5TestCaseOperation3 method directly
-// instead.
+// See InputService5TestCaseOperation3 for more information on using the InputService5TestCaseOperation3
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService5TestCaseOperation3Request method.
 //    req, resp := client.InputService5TestCaseOperation3Request(params)
@@ -931,14 +943,14 @@ const opInputService5TestCaseOperation3 = "OperationName"
 //    if err == nil { // resp is now filled
 //        fmt.Println(resp)
 //    }
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation3Request(input *InputService5TestShapeInputShape) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation3Output) {
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation3Request(input *InputService5TestShapeInputService5TestCaseOperation6Input) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation3Output) {
 	op := &request.Operation{
 		Name:     opInputService5TestCaseOperation3,
 		HTTPPath: "/",
 	}
 
 	if input == nil {
-		input = &InputService5TestShapeInputShape{}
+		input = &InputService5TestShapeInputService5TestCaseOperation6Input{}
 	}
 
 	output = &InputService5TestShapeInputService5TestCaseOperation3Output{}
@@ -956,7 +968,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation3Request(input
 //
 // See the AWS API reference guide for 's
 // API operation InputService5TestCaseOperation3 for usage and error information.
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation3(input *InputService5TestShapeInputShape) (*InputService5TestShapeInputService5TestCaseOperation3Output, error) {
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation3(input *InputService5TestShapeInputService5TestCaseOperation6Input) (*InputService5TestShapeInputService5TestCaseOperation3Output, error) {
 	req, out := c.InputService5TestCaseOperation3Request(input)
 	return out, req.Send()
 }
@@ -970,7 +982,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation3(input *Input
 // the context is nil a panic will occur. In the future the SDK may create
 // sub-contexts for http.Requests. See https://golang.org/pkg/context/
 // for more information on using Contexts.
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation3WithContext(ctx aws.Context, input *InputService5TestShapeInputShape, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation3Output, error) {
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation3WithContext(ctx aws.Context, input *InputService5TestShapeInputService5TestCaseOperation6Input, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation3Output, error) {
 	req, out := c.InputService5TestCaseOperation3Request(input)
 	req.SetContext(ctx)
 	req.ApplyOptions(opts...)
@@ -981,19 +993,18 @@ const opInputService5TestCaseOperation4 = "OperationName"
 
 // InputService5TestCaseOperation4Request generates a "aws/request.Request" representing the
 // client's request for the InputService5TestCaseOperation4 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService5TestCaseOperation4 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService5TestCaseOperation4 method directly
-// instead.
+// See InputService5TestCaseOperation4 for more information on using the InputService5TestCaseOperation4
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService5TestCaseOperation4Request method.
 //    req, resp := client.InputService5TestCaseOperation4Request(params)
@@ -1002,14 +1013,14 @@ const opInputService5TestCaseOperation4 = "OperationName"
 //    if err == nil { // resp is now filled
 //        fmt.Println(resp)
 //    }
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation4Request(input *InputService5TestShapeInputShape) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation4Output) {
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation4Request(input *InputService5TestShapeInputService5TestCaseOperation6Input) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation4Output) {
 	op := &request.Operation{
 		Name:     opInputService5TestCaseOperation4,
 		HTTPPath: "/",
 	}
 
 	if input == nil {
-		input = &InputService5TestShapeInputShape{}
+		input = &InputService5TestShapeInputService5TestCaseOperation6Input{}
 	}
 
 	output = &InputService5TestShapeInputService5TestCaseOperation4Output{}
@@ -1027,7 +1038,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation4Request(input
 //
 // See the AWS API reference guide for 's
 // API operation InputService5TestCaseOperation4 for usage and error information.
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation4(input *InputService5TestShapeInputShape) (*InputService5TestShapeInputService5TestCaseOperation4Output, error) {
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation4(input *InputService5TestShapeInputService5TestCaseOperation6Input) (*InputService5TestShapeInputService5TestCaseOperation4Output, error) {
 	req, out := c.InputService5TestCaseOperation4Request(input)
 	return out, req.Send()
 }
@@ -1041,7 +1052,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation4(input *Input
 // the context is nil a panic will occur. In the future the SDK may create
 // sub-contexts for http.Requests. See https://golang.org/pkg/context/
 // for more information on using Contexts.
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation4WithContext(ctx aws.Context, input *InputService5TestShapeInputShape, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation4Output, error) {
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation4WithContext(ctx aws.Context, input *InputService5TestShapeInputService5TestCaseOperation6Input, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation4Output, error) {
 	req, out := c.InputService5TestCaseOperation4Request(input)
 	req.SetContext(ctx)
 	req.ApplyOptions(opts...)
@@ -1052,19 +1063,18 @@ const opInputService5TestCaseOperation5 = "OperationName"
 
 // InputService5TestCaseOperation5Request generates a "aws/request.Request" representing the
 // client's request for the InputService5TestCaseOperation5 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService5TestCaseOperation5 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService5TestCaseOperation5 method directly
-// instead.
+// See InputService5TestCaseOperation5 for more information on using the InputService5TestCaseOperation5
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService5TestCaseOperation5Request method.
 //    req, resp := client.InputService5TestCaseOperation5Request(params)
@@ -1073,14 +1083,14 @@ const opInputService5TestCaseOperation5 = "OperationName"
 //    if err == nil { // resp is now filled
 //        fmt.Println(resp)
 //    }
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation5Request(input *InputService5TestShapeInputShape) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation5Output) {
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation5Request(input *InputService5TestShapeInputService5TestCaseOperation6Input) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation5Output) {
 	op := &request.Operation{
 		Name:     opInputService5TestCaseOperation5,
 		HTTPPath: "/",
 	}
 
 	if input == nil {
-		input = &InputService5TestShapeInputShape{}
+		input = &InputService5TestShapeInputService5TestCaseOperation6Input{}
 	}
 
 	output = &InputService5TestShapeInputService5TestCaseOperation5Output{}
@@ -1098,7 +1108,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation5Request(input
 //
 // See the AWS API reference guide for 's
 // API operation InputService5TestCaseOperation5 for usage and error information.
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation5(input *InputService5TestShapeInputShape) (*InputService5TestShapeInputService5TestCaseOperation5Output, error) {
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation5(input *InputService5TestShapeInputService5TestCaseOperation6Input) (*InputService5TestShapeInputService5TestCaseOperation5Output, error) {
 	req, out := c.InputService5TestCaseOperation5Request(input)
 	return out, req.Send()
 }
@@ -1112,7 +1122,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation5(input *Input
 // the context is nil a panic will occur. In the future the SDK may create
 // sub-contexts for http.Requests. See https://golang.org/pkg/context/
 // for more information on using Contexts.
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation5WithContext(ctx aws.Context, input *InputService5TestShapeInputShape, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation5Output, error) {
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation5WithContext(ctx aws.Context, input *InputService5TestShapeInputService5TestCaseOperation6Input, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation5Output, error) {
 	req, out := c.InputService5TestCaseOperation5Request(input)
 	req.SetContext(ctx)
 	req.ApplyOptions(opts...)
@@ -1123,19 +1133,18 @@ const opInputService5TestCaseOperation6 = "OperationName"
 
 // InputService5TestCaseOperation6Request generates a "aws/request.Request" representing the
 // client's request for the InputService5TestCaseOperation6 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService5TestCaseOperation6 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService5TestCaseOperation6 method directly
-// instead.
+// See InputService5TestCaseOperation6 for more information on using the InputService5TestCaseOperation6
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService5TestCaseOperation6Request method.
 //    req, resp := client.InputService5TestCaseOperation6Request(params)
@@ -1144,14 +1153,14 @@ const opInputService5TestCaseOperation6 = "OperationName"
 //    if err == nil { // resp is now filled
 //        fmt.Println(resp)
 //    }
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation6Request(input *InputService5TestShapeInputShape) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation6Output) {
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation6Request(input *InputService5TestShapeInputService5TestCaseOperation6Input) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation6Output) {
 	op := &request.Operation{
 		Name:     opInputService5TestCaseOperation6,
 		HTTPPath: "/",
 	}
 
 	if input == nil {
-		input = &InputService5TestShapeInputShape{}
+		input = &InputService5TestShapeInputService5TestCaseOperation6Input{}
 	}
 
 	output = &InputService5TestShapeInputService5TestCaseOperation6Output{}
@@ -1169,7 +1178,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation6Request(input
 //
 // See the AWS API reference guide for 's
 // API operation InputService5TestCaseOperation6 for usage and error information.
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation6(input *InputService5TestShapeInputShape) (*InputService5TestShapeInputService5TestCaseOperation6Output, error) {
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation6(input *InputService5TestShapeInputService5TestCaseOperation6Input) (*InputService5TestShapeInputService5TestCaseOperation6Output, error) {
 	req, out := c.InputService5TestCaseOperation6Request(input)
 	return out, req.Send()
 }
@@ -1183,7 +1192,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation6(input *Input
 // the context is nil a panic will occur. In the future the SDK may create
 // sub-contexts for http.Requests. See https://golang.org/pkg/context/
 // for more information on using Contexts.
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation6WithContext(ctx aws.Context, input *InputService5TestShapeInputShape, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation6Output, error) {
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation6WithContext(ctx aws.Context, input *InputService5TestShapeInputService5TestCaseOperation6Input, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation6Output, error) {
 	req, out := c.InputService5TestCaseOperation6Request(input)
 	req.SetContext(ctx)
 	req.ApplyOptions(opts...)
@@ -1210,22 +1219,22 @@ type InputService5TestShapeInputService5TestCaseOperation5Output struct {
 	_ struct{} `type:"structure"`
 }
 
-type InputService5TestShapeInputService5TestCaseOperation6Output struct {
-	_ struct{} `type:"structure"`
-}
-
-type InputService5TestShapeInputShape struct {
+type InputService5TestShapeInputService5TestCaseOperation6Input struct {
 	_ struct{} `type:"structure"`
 
 	RecursiveStruct *InputService5TestShapeRecursiveStructType `type:"structure"`
 }
 
 // SetRecursiveStruct sets the RecursiveStruct field's value.
-func (s *InputService5TestShapeInputShape) SetRecursiveStruct(v *InputService5TestShapeRecursiveStructType) *InputService5TestShapeInputShape {
+func (s *InputService5TestShapeInputService5TestCaseOperation6Input) SetRecursiveStruct(v *InputService5TestShapeRecursiveStructType) *InputService5TestShapeInputService5TestCaseOperation6Input {
 	s.RecursiveStruct = v
 	return s
 }
 
+type InputService5TestShapeInputService5TestCaseOperation6Output struct {
+	_ struct{} `type:"structure"`
+}
+
 type InputService5TestShapeRecursiveStructType struct {
 	_ struct{} `type:"structure"`
 
@@ -1262,8 +1271,12 @@ func (s *InputService5TestShapeRecursiveStructType) SetRecursiveStruct(v *InputS
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// InputService6ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// InputService6ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type InputService6ProtocolTest struct {
 	*client.Client
 }
@@ -1323,19 +1336,18 @@ const opInputService6TestCaseOperation1 = "OperationName"
 
 // InputService6TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the InputService6TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService6TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService6TestCaseOperation1 method directly
-// instead.
+// See InputService6TestCaseOperation1 for more information on using the InputService6TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService6TestCaseOperation1Request method.
 //    req, resp := client.InputService6TestCaseOperation1Request(params)
@@ -1407,8 +1419,12 @@ type InputService6TestShapeInputService6TestCaseOperation1Output struct {
 	_ struct{} `type:"structure"`
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// InputService7ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// InputService7ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type InputService7ProtocolTest struct {
 	*client.Client
 }
@@ -1466,19 +1482,18 @@ const opInputService7TestCaseOperation1 = "OperationName"
 
 // InputService7TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the InputService7TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService7TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService7TestCaseOperation1 method directly
-// instead.
+// See InputService7TestCaseOperation1 for more information on using the InputService7TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService7TestCaseOperation1Request method.
 //    req, resp := client.InputService7TestCaseOperation1Request(params)
@@ -1487,7 +1502,7 @@ const opInputService7TestCaseOperation1 = "OperationName"
 //    if err == nil { // resp is now filled
 //        fmt.Println(resp)
 //    }
-func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input *InputService7TestShapeInputShape) (req *request.Request, output *InputService7TestShapeInputService7TestCaseOperation1Output) {
+func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input *InputService7TestShapeInputService7TestCaseOperation2Input) (req *request.Request, output *InputService7TestShapeInputService7TestCaseOperation1Output) {
 	op := &request.Operation{
 		Name:       opInputService7TestCaseOperation1,
 		HTTPMethod: "POST",
@@ -1495,7 +1510,7 @@ func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input
 	}
 
 	if input == nil {
-		input = &InputService7TestShapeInputShape{}
+		input = &InputService7TestShapeInputService7TestCaseOperation2Input{}
 	}
 
 	output = &InputService7TestShapeInputService7TestCaseOperation1Output{}
@@ -1513,7 +1528,7 @@ func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input
 //
 // See the AWS API reference guide for 's
 // API operation InputService7TestCaseOperation1 for usage and error information.
-func (c *InputService7ProtocolTest) InputService7TestCaseOperation1(input *InputService7TestShapeInputShape) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) {
+func (c *InputService7ProtocolTest) InputService7TestCaseOperation1(input *InputService7TestShapeInputService7TestCaseOperation2Input) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) {
 	req, out := c.InputService7TestCaseOperation1Request(input)
 	return out, req.Send()
 }
@@ -1527,7 +1542,7 @@ func (c *InputService7ProtocolTest) InputService7TestCaseOperation1(input *Input
 // the context is nil a panic will occur. In the future the SDK may create
 // sub-contexts for http.Requests. See https://golang.org/pkg/context/
 // for more information on using Contexts.
-func (c *InputService7ProtocolTest) InputService7TestCaseOperation1WithContext(ctx aws.Context, input *InputService7TestShapeInputShape, opts ...request.Option) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) {
+func (c *InputService7ProtocolTest) InputService7TestCaseOperation1WithContext(ctx aws.Context, input *InputService7TestShapeInputService7TestCaseOperation2Input, opts ...request.Option) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) {
 	req, out := c.InputService7TestCaseOperation1Request(input)
 	req.SetContext(ctx)
 	req.ApplyOptions(opts...)
@@ -1538,19 +1553,18 @@ const opInputService7TestCaseOperation2 = "OperationName"
 
 // InputService7TestCaseOperation2Request generates a "aws/request.Request" representing the
 // client's request for the InputService7TestCaseOperation2 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See InputService7TestCaseOperation2 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the InputService7TestCaseOperation2 method directly
-// instead.
+// See InputService7TestCaseOperation2 for more information on using the InputService7TestCaseOperation2
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the InputService7TestCaseOperation2Request method.
 //    req, resp := client.InputService7TestCaseOperation2Request(params)
@@ -1559,7 +1573,7 @@ const opInputService7TestCaseOperation2 = "OperationName"
 //    if err == nil { // resp is now filled
 //        fmt.Println(resp)
 //    }
-func (c *InputService7ProtocolTest) InputService7TestCaseOperation2Request(input *InputService7TestShapeInputShape) (req *request.Request, output *InputService7TestShapeInputService7TestCaseOperation2Output) {
+func (c *InputService7ProtocolTest) InputService7TestCaseOperation2Request(input *InputService7TestShapeInputService7TestCaseOperation2Input) (req *request.Request, output *InputService7TestShapeInputService7TestCaseOperation2Output) {
 	op := &request.Operation{
 		Name:       opInputService7TestCaseOperation2,
 		HTTPMethod: "POST",
@@ -1567,7 +1581,7 @@ func (c *InputService7ProtocolTest) InputService7TestCaseOperation2Request(input
 	}
 
 	if input == nil {
-		input = &InputService7TestShapeInputShape{}
+		input = &InputService7TestShapeInputService7TestCaseOperation2Input{}
 	}
 
 	output = &InputService7TestShapeInputService7TestCaseOperation2Output{}
@@ -1585,7 +1599,7 @@ func (c *InputService7ProtocolTest) InputService7TestCaseOperation2Request(input
 //
 // See the AWS API reference guide for 's
 // API operation InputService7TestCaseOperation2 for usage and error information.
-func (c *InputService7ProtocolTest) InputService7TestCaseOperation2(input *InputService7TestShapeInputShape) (*InputService7TestShapeInputService7TestCaseOperation2Output, error) {
+func (c *InputService7ProtocolTest) InputService7TestCaseOperation2(input *InputService7TestShapeInputService7TestCaseOperation2Input) (*InputService7TestShapeInputService7TestCaseOperation2Output, error) {
 	req, out := c.InputService7TestCaseOperation2Request(input)
 	return out, req.Send()
 }
@@ -1599,7 +1613,7 @@ func (c *InputService7ProtocolTest) InputService7TestCaseOperation2(input *Input
 // the context is nil a panic will occur. In the future the SDK may create
 // sub-contexts for http.Requests. See https://golang.org/pkg/context/
 // for more information on using Contexts.
-func (c *InputService7ProtocolTest) InputService7TestCaseOperation2WithContext(ctx aws.Context, input *InputService7TestShapeInputShape, opts ...request.Option) (*InputService7TestShapeInputService7TestCaseOperation2Output, error) {
+func (c *InputService7ProtocolTest) InputService7TestCaseOperation2WithContext(ctx aws.Context, input *InputService7TestShapeInputService7TestCaseOperation2Input, opts ...request.Option) (*InputService7TestShapeInputService7TestCaseOperation2Output, error) {
 	req, out := c.InputService7TestCaseOperation2Request(input)
 	req.SetContext(ctx)
 	req.ApplyOptions(opts...)
@@ -1610,22 +1624,22 @@ type InputService7TestShapeInputService7TestCaseOperation1Output struct {
 	_ struct{} `type:"structure"`
 }
 
-type InputService7TestShapeInputService7TestCaseOperation2Output struct {
-	_ struct{} `type:"structure"`
-}
-
-type InputService7TestShapeInputShape struct {
+type InputService7TestShapeInputService7TestCaseOperation2Input struct {
 	_ struct{} `type:"structure"`
 
 	Token *string `type:"string" idempotencyToken:"true"`
 }
 
 // SetToken sets the Token field's value.
-func (s *InputService7TestShapeInputShape) SetToken(v string) *InputService7TestShapeInputShape {
+func (s *InputService7TestShapeInputService7TestCaseOperation2Input) SetToken(v string) *InputService7TestShapeInputService7TestCaseOperation2Input {
 	s.Token = &v
 	return s
 }
 
+type InputService7TestShapeInputService7TestCaseOperation2Output struct {
+	_ struct{} `type:"structure"`
+}
+
 //
 // Tests begin here
 //
@@ -1684,7 +1698,7 @@ func TestInputService2ProtocolTestTimestampValuesCase1(t *testing.T) {
 
 func TestInputService3ProtocolTestBase64EncodedBlobsCase1(t *testing.T) {
 	svc := NewInputService3ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
-	input := &InputService3TestShapeInputShape{
+	input := &InputService3TestShapeInputService3TestCaseOperation2Input{
 		BlobArg: []byte("foo"),
 	}
 	req, _ := svc.InputService3TestCaseOperation1Request(input)
@@ -1710,7 +1724,7 @@ func TestInputService3ProtocolTestBase64EncodedBlobsCase1(t *testing.T) {
 
 func TestInputService3ProtocolTestBase64EncodedBlobsCase2(t *testing.T) {
 	svc := NewInputService3ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
-	input := &InputService3TestShapeInputShape{
+	input := &InputService3TestShapeInputService3TestCaseOperation2Input{
 		BlobMap: map[string][]byte{
 			"key1": []byte("foo"),
 			"key2": []byte("bar"),
@@ -1768,7 +1782,7 @@ func TestInputService4ProtocolTestNestedBlobsCase1(t *testing.T) {
 
 func TestInputService5ProtocolTestRecursiveShapesCase1(t *testing.T) {
 	svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
-	input := &InputService5TestShapeInputShape{
+	input := &InputService5TestShapeInputService5TestCaseOperation6Input{
 		RecursiveStruct: &InputService5TestShapeRecursiveStructType{
 			NoRecurse: aws.String("foo"),
 		},
@@ -1796,7 +1810,7 @@ func TestInputService5ProtocolTestRecursiveShapesCase1(t *testing.T) {
 
 func TestInputService5ProtocolTestRecursiveShapesCase2(t *testing.T) {
 	svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
-	input := &InputService5TestShapeInputShape{
+	input := &InputService5TestShapeInputService5TestCaseOperation6Input{
 		RecursiveStruct: &InputService5TestShapeRecursiveStructType{
 			RecursiveStruct: &InputService5TestShapeRecursiveStructType{
 				NoRecurse: aws.String("foo"),
@@ -1826,7 +1840,7 @@ func TestInputService5ProtocolTestRecursiveShapesCase2(t *testing.T) {
 
 func TestInputService5ProtocolTestRecursiveShapesCase3(t *testing.T) {
 	svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
-	input := &InputService5TestShapeInputShape{
+	input := &InputService5TestShapeInputService5TestCaseOperation6Input{
 		RecursiveStruct: &InputService5TestShapeRecursiveStructType{
 			RecursiveStruct: &InputService5TestShapeRecursiveStructType{
 				RecursiveStruct: &InputService5TestShapeRecursiveStructType{
@@ -1860,7 +1874,7 @@ func TestInputService5ProtocolTestRecursiveShapesCase3(t *testing.T) {
 
 func TestInputService5ProtocolTestRecursiveShapesCase4(t *testing.T) {
 	svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
-	input := &InputService5TestShapeInputShape{
+	input := &InputService5TestShapeInputService5TestCaseOperation6Input{
 		RecursiveStruct: &InputService5TestShapeRecursiveStructType{
 			RecursiveList: []*InputService5TestShapeRecursiveStructType{
 				{
@@ -1895,7 +1909,7 @@ func TestInputService5ProtocolTestRecursiveShapesCase4(t *testing.T) {
 
 func TestInputService5ProtocolTestRecursiveShapesCase5(t *testing.T) {
 	svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
-	input := &InputService5TestShapeInputShape{
+	input := &InputService5TestShapeInputService5TestCaseOperation6Input{
 		RecursiveStruct: &InputService5TestShapeRecursiveStructType{
 			RecursiveList: []*InputService5TestShapeRecursiveStructType{
 				{
@@ -1932,7 +1946,7 @@ func TestInputService5ProtocolTestRecursiveShapesCase5(t *testing.T) {
 
 func TestInputService5ProtocolTestRecursiveShapesCase6(t *testing.T) {
 	svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
-	input := &InputService5TestShapeInputShape{
+	input := &InputService5TestShapeInputService5TestCaseOperation6Input{
 		RecursiveStruct: &InputService5TestShapeRecursiveStructType{
 			RecursiveMap: map[string]*InputService5TestShapeRecursiveStructType{
 				"bar": {
@@ -1993,7 +2007,7 @@ func TestInputService6ProtocolTestEmptyMapsCase1(t *testing.T) {
 
 func TestInputService7ProtocolTestIdempotencyTokenAutoFillCase1(t *testing.T) {
 	svc := NewInputService7ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
-	input := &InputService7TestShapeInputShape{
+	input := &InputService7TestShapeInputService7TestCaseOperation2Input{
 		Token: aws.String("abc123"),
 	}
 	req, _ := svc.InputService7TestCaseOperation1Request(input)
@@ -2017,7 +2031,7 @@ func TestInputService7ProtocolTestIdempotencyTokenAutoFillCase1(t *testing.T) {
 
 func TestInputService7ProtocolTestIdempotencyTokenAutoFillCase2(t *testing.T) {
 	svc := NewInputService7ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
-	input := &InputService7TestShapeInputShape{}
+	input := &InputService7TestShapeInputService7TestCaseOperation2Input{}
 	req, _ := svc.InputService7TestCaseOperation2Request(input)
 	r := req.HTTPRequest
 

vendor/github.com/aws/aws-sdk-go/private/protocol/jsonrpc/unmarshal_test.go

@@ -45,8 +45,12 @@ func init() {
 	protocol.RandReader = &awstesting.ZeroReader{}
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService1ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService1ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService1ProtocolTest struct {
 	*client.Client
 }
@@ -104,19 +108,18 @@ const opOutputService1TestCaseOperation1 = "OperationName"
 
 // OutputService1TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService1TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService1TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService1TestCaseOperation1 method directly
-// instead.
+// See OutputService1TestCaseOperation1 for more information on using the OutputService1TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService1TestCaseOperation1Request method.
 //    req, resp := client.OutputService1TestCaseOperation1Request(params)
@@ -241,8 +244,12 @@ func (s *OutputService1TestShapeOutputService1TestCaseOperation1Output) SetTrueB
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService2ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService2ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService2ProtocolTest struct {
 	*client.Client
 }
@@ -300,19 +307,18 @@ const opOutputService2TestCaseOperation1 = "OperationName"
 
 // OutputService2TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService2TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService2TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService2TestCaseOperation1 method directly
-// instead.
+// See OutputService2TestCaseOperation1 for more information on using the OutputService2TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService2TestCaseOperation1Request method.
 //    req, resp := client.OutputService2TestCaseOperation1Request(params)
@@ -403,8 +409,12 @@ func (s *OutputService2TestShapeOutputService2TestCaseOperation1Output) SetStruc
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService3ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService3ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService3ProtocolTest struct {
 	*client.Client
 }
@@ -462,19 +472,18 @@ const opOutputService3TestCaseOperation1 = "OperationName"
 
 // OutputService3TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService3TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService3TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService3TestCaseOperation1 method directly
-// instead.
+// See OutputService3TestCaseOperation1 for more information on using the OutputService3TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService3TestCaseOperation1Request method.
 //    req, resp := client.OutputService3TestCaseOperation1Request(params)
@@ -563,8 +572,12 @@ func (s *OutputService3TestShapeTimeContainer) SetFoo(v time.Time) *OutputServic
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService4ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService4ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService4ProtocolTest struct {
 	*client.Client
 }
@@ -622,19 +635,18 @@ const opOutputService4TestCaseOperation1 = "OperationName"
 
 // OutputService4TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService4TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService4TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService4TestCaseOperation1 method directly
-// instead.
+// See OutputService4TestCaseOperation1 for more information on using the OutputService4TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService4TestCaseOperation1Request method.
 //    req, resp := client.OutputService4TestCaseOperation1Request(params)
@@ -643,7 +655,7 @@ const opOutputService4TestCaseOperation1 = "OperationName"
 //    if err == nil { // resp is now filled
 //        fmt.Println(resp)
 //    }
-func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1Request(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (req *request.Request, output *OutputService4TestShapeOutputShape) {
+func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1Request(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (req *request.Request, output *OutputService4TestShapeOutputService4TestCaseOperation2Output) {
 	op := &request.Operation{
 		Name:     opOutputService4TestCaseOperation1,
 		HTTPPath: "/",
@@ -653,7 +665,7 @@ func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1Request(inp
 		input = &OutputService4TestShapeOutputService4TestCaseOperation1Input{}
 	}
 
-	output = &OutputService4TestShapeOutputShape{}
+	output = &OutputService4TestShapeOutputService4TestCaseOperation2Output{}
 	req = c.newRequest(op, input, output)
 	return
 }
@@ -666,7 +678,7 @@ func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1Request(inp
 //
 // See the AWS API reference guide for 's
 // API operation OutputService4TestCaseOperation1 for usage and error information.
-func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (*OutputService4TestShapeOutputShape, error) {
+func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (*OutputService4TestShapeOutputService4TestCaseOperation2Output, error) {
 	req, out := c.OutputService4TestCaseOperation1Request(input)
 	return out, req.Send()
 }
@@ -680,7 +692,7 @@ func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1(input *Out
 // the context is nil a panic will occur. In the future the SDK may create
 // sub-contexts for http.Requests. See https://golang.org/pkg/context/
 // for more information on using Contexts.
-func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1WithContext(ctx aws.Context, input *OutputService4TestShapeOutputService4TestCaseOperation1Input, opts ...request.Option) (*OutputService4TestShapeOutputShape, error) {
+func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1WithContext(ctx aws.Context, input *OutputService4TestShapeOutputService4TestCaseOperation1Input, opts ...request.Option) (*OutputService4TestShapeOutputService4TestCaseOperation2Output, error) {
 	req, out := c.OutputService4TestCaseOperation1Request(input)
 	req.SetContext(ctx)
 	req.ApplyOptions(opts...)
@@ -691,19 +703,18 @@ const opOutputService4TestCaseOperation2 = "OperationName"
 
 // OutputService4TestCaseOperation2Request generates a "aws/request.Request" representing the
 // client's request for the OutputService4TestCaseOperation2 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService4TestCaseOperation2 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService4TestCaseOperation2 method directly
-// instead.
+// See OutputService4TestCaseOperation2 for more information on using the OutputService4TestCaseOperation2
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService4TestCaseOperation2Request method.
 //    req, resp := client.OutputService4TestCaseOperation2Request(params)
@@ -712,7 +723,7 @@ const opOutputService4TestCaseOperation2 = "OperationName"
 //    if err == nil { // resp is now filled
 //        fmt.Println(resp)
 //    }
-func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation2Request(input *OutputService4TestShapeOutputService4TestCaseOperation2Input) (req *request.Request, output *OutputService4TestShapeOutputShape) {
+func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation2Request(input *OutputService4TestShapeOutputService4TestCaseOperation2Input) (req *request.Request, output *OutputService4TestShapeOutputService4TestCaseOperation2Output) {
 	op := &request.Operation{
 		Name:     opOutputService4TestCaseOperation2,
 		HTTPPath: "/",
@@ -722,7 +733,7 @@ func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation2Request(inp
 		input = &OutputService4TestShapeOutputService4TestCaseOperation2Input{}
 	}
 
-	output = &OutputService4TestShapeOutputShape{}
+	output = &OutputService4TestShapeOutputService4TestCaseOperation2Output{}
 	req = c.newRequest(op, input, output)
 	return
 }
@@ -735,7 +746,7 @@ func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation2Request(inp
 //
 // See the AWS API reference guide for 's
 // API operation OutputService4TestCaseOperation2 for usage and error information.
-func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation2(input *OutputService4TestShapeOutputService4TestCaseOperation2Input) (*OutputService4TestShapeOutputShape, error) {
+func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation2(input *OutputService4TestShapeOutputService4TestCaseOperation2Input) (*OutputService4TestShapeOutputService4TestCaseOperation2Output, error) {
 	req, out := c.OutputService4TestCaseOperation2Request(input)
 	return out, req.Send()
 }
@@ -749,7 +760,7 @@ func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation2(input *Out
 // the context is nil a panic will occur. In the future the SDK may create
 // sub-contexts for http.Requests. See https://golang.org/pkg/context/
 // for more information on using Contexts.
-func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation2WithContext(ctx aws.Context, input *OutputService4TestShapeOutputService4TestCaseOperation2Input, opts ...request.Option) (*OutputService4TestShapeOutputShape, error) {
+func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation2WithContext(ctx aws.Context, input *OutputService4TestShapeOutputService4TestCaseOperation2Input, opts ...request.Option) (*OutputService4TestShapeOutputService4TestCaseOperation2Output, error) {
 	req, out := c.OutputService4TestCaseOperation2Request(input)
 	req.SetContext(ctx)
 	req.ApplyOptions(opts...)
@@ -764,7 +775,7 @@ type OutputService4TestShapeOutputService4TestCaseOperation2Input struct {
 	_ struct{} `type:"structure"`
 }
 
-type OutputService4TestShapeOutputShape struct {
+type OutputService4TestShapeOutputService4TestCaseOperation2Output struct {
 	_ struct{} `type:"structure"`
 
 	ListMember []*string `type:"list"`
@@ -775,19 +786,19 @@ type OutputService4TestShapeOutputShape struct {
 }
 
 // SetListMember sets the ListMember field's value.
-func (s *OutputService4TestShapeOutputShape) SetListMember(v []*string) *OutputService4TestShapeOutputShape {
+func (s *OutputService4TestShapeOutputService4TestCaseOperation2Output) SetListMember(v []*string) *OutputService4TestShapeOutputService4TestCaseOperation2Output {
 	s.ListMember = v
 	return s
 }
 
 // SetListMemberMap sets the ListMemberMap field's value.
-func (s *OutputService4TestShapeOutputShape) SetListMemberMap(v []map[string]*string) *OutputService4TestShapeOutputShape {
+func (s *OutputService4TestShapeOutputService4TestCaseOperation2Output) SetListMemberMap(v []map[string]*string) *OutputService4TestShapeOutputService4TestCaseOperation2Output {
 	s.ListMemberMap = v
 	return s
 }
 
 // SetListMemberStruct sets the ListMemberStruct field's value.
-func (s *OutputService4TestShapeOutputShape) SetListMemberStruct(v []*OutputService4TestShapeStructType) *OutputService4TestShapeOutputShape {
+func (s *OutputService4TestShapeOutputService4TestCaseOperation2Output) SetListMemberStruct(v []*OutputService4TestShapeStructType) *OutputService4TestShapeOutputService4TestCaseOperation2Output {
 	s.ListMemberStruct = v
 	return s
 }
@@ -796,8 +807,12 @@ type OutputService4TestShapeStructType struct {
 	_ struct{} `type:"structure"`
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService5ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService5ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService5ProtocolTest struct {
 	*client.Client
 }
@@ -855,19 +870,18 @@ const opOutputService5TestCaseOperation1 = "OperationName"
 
 // OutputService5TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService5TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService5TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService5TestCaseOperation1 method directly
-// instead.
+// See OutputService5TestCaseOperation1 for more information on using the OutputService5TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService5TestCaseOperation1Request method.
 //    req, resp := client.OutputService5TestCaseOperation1Request(params)
@@ -936,8 +950,12 @@ func (s *OutputService5TestShapeOutputService5TestCaseOperation1Output) SetMapMe
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService6ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService6ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService6ProtocolTest struct {
 	*client.Client
 }
@@ -995,19 +1013,18 @@ const opOutputService6TestCaseOperation1 = "OperationName"
 
 // OutputService6TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService6TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService6TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService6TestCaseOperation1 method directly
-// instead.
+// See OutputService6TestCaseOperation1 for more information on using the OutputService6TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService6TestCaseOperation1Request method.
 //    req, resp := client.OutputService6TestCaseOperation1Request(params)

vendor/github.com/aws/aws-sdk-go/private/protocol/protocol_test.go

@@ -1,7 +1,6 @@
 package protocol_test
 
 import (
-	"fmt"
 	"net/http"
 	"net/url"
 	"testing"
@@ -21,11 +20,13 @@ import (
 )
 
 func xmlData(set bool, b []byte, size, delta int) {
+	const openingTags = "<B><A>"
+	const closingTags = "</A></B>"
 	if !set {
-		copy(b, []byte("<B><A>"))
+		copy(b, []byte(openingTags))
 	}
 	if size == 0 {
-		copy(b[delta-len("</B></A>"):], []byte("</B></A>"))
+		copy(b[delta-len(closingTags):], []byte(closingTags))
 	}
 }
 
@@ -118,7 +119,6 @@ func checkForLeak(data interface{}, build, fn func(*request.Request), t *testing
 	if result.errExists {
 		assert.NotNil(t, req.Error)
 	} else {
-		fmt.Println(req.Error)
 		assert.Nil(t, req.Error)
 	}
 

vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal_test.go

@@ -45,8 +45,12 @@ func init() {
 	protocol.RandReader = &awstesting.ZeroReader{}
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService1ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService1ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService1ProtocolTest struct {
 	*client.Client
 }
@@ -104,19 +108,18 @@ const opOutputService1TestCaseOperation1 = "OperationName"
 
 // OutputService1TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService1TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService1TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService1TestCaseOperation1 method directly
-// instead.
+// See OutputService1TestCaseOperation1 for more information on using the OutputService1TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService1TestCaseOperation1Request method.
 //    req, resp := client.OutputService1TestCaseOperation1Request(params)
@@ -249,8 +252,12 @@ func (s *OutputService1TestShapeOutputService1TestCaseOperation1Output) SetTrueB
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService2ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService2ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService2ProtocolTest struct {
 	*client.Client
 }
@@ -308,19 +315,18 @@ const opOutputService2TestCaseOperation1 = "OperationName"
 
 // OutputService2TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService2TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService2TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService2TestCaseOperation1 method directly
-// instead.
+// See OutputService2TestCaseOperation1 for more information on using the OutputService2TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService2TestCaseOperation1Request method.
 //    req, resp := client.OutputService2TestCaseOperation1Request(params)
@@ -397,8 +403,12 @@ func (s *OutputService2TestShapeOutputService2TestCaseOperation1Output) SetStr(v
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService3ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService3ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService3ProtocolTest struct {
 	*client.Client
 }
@@ -456,19 +466,18 @@ const opOutputService3TestCaseOperation1 = "OperationName"
 
 // OutputService3TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService3TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService3TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService3TestCaseOperation1 method directly
-// instead.
+// See OutputService3TestCaseOperation1 for more information on using the OutputService3TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService3TestCaseOperation1Request method.
 //    req, resp := client.OutputService3TestCaseOperation1Request(params)
@@ -538,8 +547,12 @@ func (s *OutputService3TestShapeOutputService3TestCaseOperation1Output) SetBlob(
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService4ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService4ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService4ProtocolTest struct {
 	*client.Client
 }
@@ -597,19 +610,18 @@ const opOutputService4TestCaseOperation1 = "OperationName"
 
 // OutputService4TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService4TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService4TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService4TestCaseOperation1 method directly
-// instead.
+// See OutputService4TestCaseOperation1 for more information on using the OutputService4TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService4TestCaseOperation1Request method.
 //    req, resp := client.OutputService4TestCaseOperation1Request(params)
@@ -678,8 +690,12 @@ func (s *OutputService4TestShapeOutputService4TestCaseOperation1Output) SetListM
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService5ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService5ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService5ProtocolTest struct {
 	*client.Client
 }
@@ -737,19 +753,18 @@ const opOutputService5TestCaseOperation1 = "OperationName"
 
 // OutputService5TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService5TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService5TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService5TestCaseOperation1 method directly
-// instead.
+// See OutputService5TestCaseOperation1 for more information on using the OutputService5TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService5TestCaseOperation1Request method.
 //    req, resp := client.OutputService5TestCaseOperation1Request(params)
@@ -818,8 +833,12 @@ func (s *OutputService5TestShapeOutputService5TestCaseOperation1Output) SetListM
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService6ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService6ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService6ProtocolTest struct {
 	*client.Client
 }
@@ -877,19 +896,18 @@ const opOutputService6TestCaseOperation1 = "OperationName"
 
 // OutputService6TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService6TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService6TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService6TestCaseOperation1 method directly
-// instead.
+// See OutputService6TestCaseOperation1 for more information on using the OutputService6TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService6TestCaseOperation1Request method.
 //    req, resp := client.OutputService6TestCaseOperation1Request(params)
@@ -958,8 +976,12 @@ func (s *OutputService6TestShapeOutputService6TestCaseOperation1Output) SetListM
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService7ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService7ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService7ProtocolTest struct {
 	*client.Client
 }
@@ -1017,19 +1039,18 @@ const opOutputService7TestCaseOperation1 = "OperationName"
 
 // OutputService7TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService7TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService7TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService7TestCaseOperation1 method directly
-// instead.
+// See OutputService7TestCaseOperation1 for more information on using the OutputService7TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService7TestCaseOperation1Request method.
 //    req, resp := client.OutputService7TestCaseOperation1Request(params)
@@ -1098,8 +1119,12 @@ func (s *OutputService7TestShapeOutputService7TestCaseOperation1Output) SetListM
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService8ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService8ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService8ProtocolTest struct {
 	*client.Client
 }
@@ -1157,19 +1182,18 @@ const opOutputService8TestCaseOperation1 = "OperationName"
 
 // OutputService8TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService8TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService8TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService8TestCaseOperation1 method directly
-// instead.
+// See OutputService8TestCaseOperation1 for more information on using the OutputService8TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService8TestCaseOperation1Request method.
 //    req, resp := client.OutputService8TestCaseOperation1Request(params)
@@ -1266,8 +1290,12 @@ func (s *OutputService8TestShapeStructureShape) SetFoo(v string) *OutputService8
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService9ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService9ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService9ProtocolTest struct {
 	*client.Client
 }
@@ -1325,19 +1353,18 @@ const opOutputService9TestCaseOperation1 = "OperationName"
 
 // OutputService9TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService9TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService9TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService9TestCaseOperation1 method directly
-// instead.
+// See OutputService9TestCaseOperation1 for more information on using the OutputService9TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService9TestCaseOperation1Request method.
 //    req, resp := client.OutputService9TestCaseOperation1Request(params)
@@ -1434,8 +1461,12 @@ func (s *OutputService9TestShapeStructureShape) SetFoo(v string) *OutputService9
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService10ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService10ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService10ProtocolTest struct {
 	*client.Client
 }
@@ -1493,19 +1524,18 @@ const opOutputService10TestCaseOperation1 = "OperationName"
 
 // OutputService10TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService10TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService10TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService10TestCaseOperation1 method directly
-// instead.
+// See OutputService10TestCaseOperation1 for more information on using the OutputService10TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService10TestCaseOperation1Request method.
 //    req, resp := client.OutputService10TestCaseOperation1Request(params)
@@ -1574,8 +1604,12 @@ func (s *OutputService10TestShapeOutputService10TestCaseOperation1Output) SetLis
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService11ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService11ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService11ProtocolTest struct {
 	*client.Client
 }
@@ -1633,19 +1667,18 @@ const opOutputService11TestCaseOperation1 = "OperationName"
 
 // OutputService11TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService11TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService11TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService11TestCaseOperation1 method directly
-// instead.
+// See OutputService11TestCaseOperation1 for more information on using the OutputService11TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService11TestCaseOperation1Request method.
 //    req, resp := client.OutputService11TestCaseOperation1Request(params)
@@ -1726,8 +1759,12 @@ func (s *OutputService11TestShapeStructType) SetFoo(v string) *OutputService11Te
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService12ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService12ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService12ProtocolTest struct {
 	*client.Client
 }
@@ -1785,19 +1822,18 @@ const opOutputService12TestCaseOperation1 = "OperationName"
 
 // OutputService12TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService12TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService12TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService12TestCaseOperation1 method directly
-// instead.
+// See OutputService12TestCaseOperation1 for more information on using the OutputService12TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService12TestCaseOperation1Request method.
 //    req, resp := client.OutputService12TestCaseOperation1Request(params)
@@ -1866,8 +1902,12 @@ func (s *OutputService12TestShapeOutputService12TestCaseOperation1Output) SetMap
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService13ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService13ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService13ProtocolTest struct {
 	*client.Client
 }
@@ -1925,19 +1965,18 @@ const opOutputService13TestCaseOperation1 = "OperationName"
 
 // OutputService13TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService13TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService13TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService13TestCaseOperation1 method directly
-// instead.
+// See OutputService13TestCaseOperation1 for more information on using the OutputService13TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService13TestCaseOperation1Request method.
 //    req, resp := client.OutputService13TestCaseOperation1Request(params)
@@ -2006,8 +2045,12 @@ func (s *OutputService13TestShapeOutputService13TestCaseOperation1Output) SetMap
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService14ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService14ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService14ProtocolTest struct {
 	*client.Client
 }
@@ -2065,19 +2108,18 @@ const opOutputService14TestCaseOperation1 = "OperationName"
 
 // OutputService14TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService14TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService14TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService14TestCaseOperation1 method directly
-// instead.
+// See OutputService14TestCaseOperation1 for more information on using the OutputService14TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService14TestCaseOperation1Request method.
 //    req, resp := client.OutputService14TestCaseOperation1Request(params)
@@ -2146,8 +2188,12 @@ func (s *OutputService14TestShapeOutputService14TestCaseOperation1Output) SetMap
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService15ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService15ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService15ProtocolTest struct {
 	*client.Client
 }
@@ -2205,19 +2251,18 @@ const opOutputService15TestCaseOperation1 = "OperationName"
 
 // OutputService15TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService15TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService15TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService15TestCaseOperation1 method directly
-// instead.
+// See OutputService15TestCaseOperation1 for more information on using the OutputService15TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService15TestCaseOperation1Request method.
 //    req, resp := client.OutputService15TestCaseOperation1Request(params)

vendor/github.com/aws/aws-sdk-go/private/protocol/restjson/build_bench_test.go

@@ -3,232 +3,131 @@
 package restjson_test
 
 import (
-	"bytes"
-	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
 	"testing"
 
 	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/credentials"
+	"github.com/aws/aws-sdk-go/aws/endpoints"
 	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/awstesting"
-	"github.com/aws/aws-sdk-go/private/protocol/rest"
+	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/private/protocol/restjson"
 	"github.com/aws/aws-sdk-go/service/elastictranscoder"
 )
 
-func BenchmarkRESTJSONBuild_Complex_elastictranscoderCreateJobInput(b *testing.B) {
-	svc := awstesting.NewClient()
-	svc.ServiceName = "elastictranscoder"
-	svc.APIVersion = "2012-09-25"
+var (
+	elastictranscoderSvc *elastictranscoder.ElasticTranscoder
+)
+
+func TestMain(m *testing.M) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+
+	sess := session.Must(session.NewSession(&aws.Config{
+		Credentials:      credentials.NewStaticCredentials("Key", "Secret", "Token"),
+		Endpoint:         aws.String(server.URL),
+		S3ForcePathStyle: aws.Bool(true),
+		DisableSSL:       aws.Bool(true),
+		Region:           aws.String(endpoints.UsWest2RegionID),
+	}))
+	elastictranscoderSvc = elastictranscoder.New(sess)
+
+	c := m.Run()
+	server.Close()
+	os.Exit(c)
+}
+
+func BenchmarkRESTJSONBuild_Complex_ETCCreateJob(b *testing.B) {
+	params := elastictranscoderCreateJobInput()
+
+	benchRESTJSONBuild(b, func() *request.Request {
+		req, _ := elastictranscoderSvc.CreateJobRequest(params)
+		return req
+	})
+}
+
+func BenchmarkRESTJSONBuild_Simple_ETCListJobsByPipeline(b *testing.B) {
+	params := elastictranscoderListJobsByPipeline()
+
+	benchRESTJSONBuild(b, func() *request.Request {
+		req, _ := elastictranscoderSvc.ListJobsByPipelineRequest(params)
+		return req
+	})
+}
+
+func BenchmarkRESTJSONRequest_Complex_CFCreateJob(b *testing.B) {
+	benchRESTJSONRequest(b, func() *request.Request {
+		req, _ := elastictranscoderSvc.CreateJobRequest(elastictranscoderCreateJobInput())
+		return req
+	})
+}
+
+func BenchmarkRESTJSONRequest_Simple_ETCListJobsByPipeline(b *testing.B) {
+	benchRESTJSONRequest(b, func() *request.Request {
+		req, _ := elastictranscoderSvc.ListJobsByPipelineRequest(elastictranscoderListJobsByPipeline())
+		return req
+	})
+}
+
+func benchRESTJSONBuild(b *testing.B, reqFn func() *request.Request) {
+	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		r := svc.NewRequest(&request.Operation{Name: "CreateJobInput"}, restjsonBuildParms, nil)
-		restjson.Build(r)
-		if r.Error != nil {
-			b.Fatal("Unexpected error", r.Error)
+		req := reqFn()
+		restjson.Build(req)
+		if req.Error != nil {
+			b.Fatal("Unexpected error", req.Error)
 		}
 	}
 }
 
-func BenchmarkRESTBuild_Complex_elastictranscoderCreateJobInput(b *testing.B) {
-	svc := awstesting.NewClient()
-	svc.ServiceName = "elastictranscoder"
-	svc.APIVersion = "2012-09-25"
+func benchRESTJSONRequest(b *testing.B, reqFn func() *request.Request) {
+	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		r := svc.NewRequest(&request.Operation{Name: "CreateJobInput"}, restjsonBuildParms, nil)
-		rest.Build(r)
-		if r.Error != nil {
-			b.Fatal("Unexpected error", r.Error)
-		}
-	}
-}
-
-func BenchmarkEncodingJSONMarshal_Complex_elastictranscoderCreateJobInput(b *testing.B) {
-	params := restjsonBuildParms
-
-	for i := 0; i < b.N; i++ {
-		buf := &bytes.Buffer{}
-		encoder := json.NewEncoder(buf)
-		if err := encoder.Encode(params); err != nil {
+		err := reqFn().Send()
+		if err != nil {
 			b.Fatal("Unexpected error", err)
 		}
 	}
 }
 
-func BenchmarkRESTJSONBuild_Simple_elastictranscoderListJobsByPipeline(b *testing.B) {
-	svc := awstesting.NewClient()
-	svc.ServiceName = "elastictranscoder"
-	svc.APIVersion = "2012-09-25"
-
-	params := &elastictranscoder.ListJobsByPipelineInput{
+func elastictranscoderListJobsByPipeline() *elastictranscoder.ListJobsByPipelineInput {
+	return &elastictranscoder.ListJobsByPipelineInput{
 		PipelineId: aws.String("Id"), // Required
 		Ascending:  aws.String("Ascending"),
 		PageToken:  aws.String("Id"),
 	}
-
-	for i := 0; i < b.N; i++ {
-		r := svc.NewRequest(&request.Operation{Name: "ListJobsByPipeline"}, params, nil)
-		restjson.Build(r)
-		if r.Error != nil {
-			b.Fatal("Unexpected error", r.Error)
-		}
-	}
 }
 
-func BenchmarkRESTBuild_Simple_elastictranscoderListJobsByPipeline(b *testing.B) {
-	svc := awstesting.NewClient()
-	svc.ServiceName = "elastictranscoder"
-	svc.APIVersion = "2012-09-25"
-
-	params := &elastictranscoder.ListJobsByPipelineInput{
+func elastictranscoderCreateJobInput() *elastictranscoder.CreateJobInput {
+	return &elastictranscoder.CreateJobInput{
+		Input: &elastictranscoder.JobInput{ // Required
+			AspectRatio: aws.String("AspectRatio"),
+			Container:   aws.String("JobContainer"),
+			DetectedProperties: &elastictranscoder.DetectedProperties{
+				DurationMillis: aws.Int64(1),
+				FileSize:       aws.Int64(1),
+				FrameRate:      aws.String("FloatString"),
+				Height:         aws.Int64(1),
+				Width:          aws.Int64(1),
+			},
+			Encryption: &elastictranscoder.Encryption{
+				InitializationVector: aws.String("ZeroTo255String"),
+				Key:                  aws.String("Base64EncodedString"),
+				KeyMd5:               aws.String("Base64EncodedString"),
+				Mode:                 aws.String("EncryptionMode"),
+			},
+			FrameRate:  aws.String("FrameRate"),
+			Interlaced: aws.String("Interlaced"),
+			Key:        aws.String("Key"),
+			Resolution: aws.String("Resolution"),
+		},
 		PipelineId: aws.String("Id"), // Required
-		Ascending:  aws.String("Ascending"),
-		PageToken:  aws.String("Id"),
-	}
-
-	for i := 0; i < b.N; i++ {
-		r := svc.NewRequest(&request.Operation{Name: "ListJobsByPipeline"}, params, nil)
-		rest.Build(r)
-		if r.Error != nil {
-			b.Fatal("Unexpected error", r.Error)
-		}
-	}
-}
-
-func BenchmarkEncodingJSONMarshal_Simple_elastictranscoderListJobsByPipeline(b *testing.B) {
-	params := &elastictranscoder.ListJobsByPipelineInput{
-		PipelineId: aws.String("Id"), // Required
-		Ascending:  aws.String("Ascending"),
-		PageToken:  aws.String("Id"),
-	}
-
-	for i := 0; i < b.N; i++ {
-		buf := &bytes.Buffer{}
-		encoder := json.NewEncoder(buf)
-		if err := encoder.Encode(params); err != nil {
-			b.Fatal("Unexpected error", err)
-		}
-	}
-}
-
-var restjsonBuildParms = &elastictranscoder.CreateJobInput{
-	Input: &elastictranscoder.JobInput{ // Required
-		AspectRatio: aws.String("AspectRatio"),
-		Container:   aws.String("JobContainer"),
-		DetectedProperties: &elastictranscoder.DetectedProperties{
-			DurationMillis: aws.Int64(1),
-			FileSize:       aws.Int64(1),
-			FrameRate:      aws.String("FloatString"),
-			Height:         aws.Int64(1),
-			Width:          aws.Int64(1),
-		},
-		Encryption: &elastictranscoder.Encryption{
-			InitializationVector: aws.String("ZeroTo255String"),
-			Key:                  aws.String("Base64EncodedString"),
-			KeyMd5:               aws.String("Base64EncodedString"),
-			Mode:                 aws.String("EncryptionMode"),
-		},
-		FrameRate:  aws.String("FrameRate"),
-		Interlaced: aws.String("Interlaced"),
-		Key:        aws.String("Key"),
-		Resolution: aws.String("Resolution"),
-	},
-	PipelineId: aws.String("Id"), // Required
-	Output: &elastictranscoder.CreateJobOutput{
-		AlbumArt: &elastictranscoder.JobAlbumArt{
-			Artwork: []*elastictranscoder.Artwork{
-				{ // Required
-					AlbumArtFormat: aws.String("JpgOrPng"),
-					Encryption: &elastictranscoder.Encryption{
-						InitializationVector: aws.String("ZeroTo255String"),
-						Key:                  aws.String("Base64EncodedString"),
-						KeyMd5:               aws.String("Base64EncodedString"),
-						Mode:                 aws.String("EncryptionMode"),
-					},
-					InputKey:      aws.String("WatermarkKey"),
-					MaxHeight:     aws.String("DigitsOrAuto"),
-					MaxWidth:      aws.String("DigitsOrAuto"),
-					PaddingPolicy: aws.String("PaddingPolicy"),
-					SizingPolicy:  aws.String("SizingPolicy"),
-				},
-				// More values...
-			},
-			MergePolicy: aws.String("MergePolicy"),
-		},
-		Captions: &elastictranscoder.Captions{
-			CaptionFormats: []*elastictranscoder.CaptionFormat{
-				{ // Required
-					Encryption: &elastictranscoder.Encryption{
-						InitializationVector: aws.String("ZeroTo255String"),
-						Key:                  aws.String("Base64EncodedString"),
-						KeyMd5:               aws.String("Base64EncodedString"),
-						Mode:                 aws.String("EncryptionMode"),
-					},
-					Format:  aws.String("CaptionFormatFormat"),
-					Pattern: aws.String("CaptionFormatPattern"),
-				},
-				// More values...
-			},
-			CaptionSources: []*elastictranscoder.CaptionSource{
-				{ // Required
-					Encryption: &elastictranscoder.Encryption{
-						InitializationVector: aws.String("ZeroTo255String"),
-						Key:                  aws.String("Base64EncodedString"),
-						KeyMd5:               aws.String("Base64EncodedString"),
-						Mode:                 aws.String("EncryptionMode"),
-					},
-					Key:        aws.String("Key"),
-					Label:      aws.String("Name"),
-					Language:   aws.String("Key"),
-					TimeOffset: aws.String("TimeOffset"),
-				},
-				// More values...
-			},
-			MergePolicy: aws.String("CaptionMergePolicy"),
-		},
-		Composition: []*elastictranscoder.Clip{
-			{ // Required
-				TimeSpan: &elastictranscoder.TimeSpan{
-					Duration:  aws.String("Time"),
-					StartTime: aws.String("Time"),
-				},
-			},
-			// More values...
-		},
-		Encryption: &elastictranscoder.Encryption{
-			InitializationVector: aws.String("ZeroTo255String"),
-			Key:                  aws.String("Base64EncodedString"),
-			KeyMd5:               aws.String("Base64EncodedString"),
-			Mode:                 aws.String("EncryptionMode"),
-		},
-		Key:             aws.String("Key"),
-		PresetId:        aws.String("Id"),
-		Rotate:          aws.String("Rotate"),
-		SegmentDuration: aws.String("FloatString"),
-		ThumbnailEncryption: &elastictranscoder.Encryption{
-			InitializationVector: aws.String("ZeroTo255String"),
-			Key:                  aws.String("Base64EncodedString"),
-			KeyMd5:               aws.String("Base64EncodedString"),
-			Mode:                 aws.String("EncryptionMode"),
-		},
-		ThumbnailPattern: aws.String("ThumbnailPattern"),
-		Watermarks: []*elastictranscoder.JobWatermark{
-			{ // Required
-				Encryption: &elastictranscoder.Encryption{
-					InitializationVector: aws.String("ZeroTo255String"),
-					Key:                  aws.String("Base64EncodedString"),
-					KeyMd5:               aws.String("Base64EncodedString"),
-					Mode:                 aws.String("EncryptionMode"),
-				},
-				InputKey:          aws.String("WatermarkKey"),
-				PresetWatermarkId: aws.String("PresetWatermarkId"),
-			},
-			// More values...
-		},
-	},
-	OutputKeyPrefix: aws.String("Key"),
-	Outputs: []*elastictranscoder.CreateJobOutput{
-		{ // Required
+		Output: &elastictranscoder.CreateJobOutput{
 			AlbumArt: &elastictranscoder.JobAlbumArt{
 				Artwork: []*elastictranscoder.Artwork{
 					{ // Required
@@ -320,37 +219,132 @@ var restjsonBuildParms = &elastictranscoder.CreateJobInput{
 				// More values...
 			},
 		},
-		// More values...
-	},
-	Playlists: []*elastictranscoder.CreateJobPlaylist{
-		{ // Required
-			Format: aws.String("PlaylistFormat"),
-			HlsContentProtection: &elastictranscoder.HlsContentProtection{
-				InitializationVector:  aws.String("ZeroTo255String"),
-				Key:                   aws.String("Base64EncodedString"),
-				KeyMd5:                aws.String("Base64EncodedString"),
-				KeyStoragePolicy:      aws.String("KeyStoragePolicy"),
-				LicenseAcquisitionUrl: aws.String("ZeroTo512String"),
-				Method:                aws.String("HlsContentProtectionMethod"),
-			},
-			Name: aws.String("Filename"),
-			OutputKeys: []*string{
-				aws.String("Key"), // Required
-				// More values...
-			},
-			PlayReadyDrm: &elastictranscoder.PlayReadyDrm{
-				Format:                aws.String("PlayReadyDrmFormatString"),
-				InitializationVector:  aws.String("ZeroTo255String"),
-				Key:                   aws.String("NonEmptyBase64EncodedString"),
-				KeyId:                 aws.String("KeyIdGuid"),
-				KeyMd5:                aws.String("NonEmptyBase64EncodedString"),
-				LicenseAcquisitionUrl: aws.String("OneTo512String"),
+		OutputKeyPrefix: aws.String("Key"),
+		Outputs: []*elastictranscoder.CreateJobOutput{
+			{ // Required
+				AlbumArt: &elastictranscoder.JobAlbumArt{
+					Artwork: []*elastictranscoder.Artwork{
+						{ // Required
+							AlbumArtFormat: aws.String("JpgOrPng"),
+							Encryption: &elastictranscoder.Encryption{
+								InitializationVector: aws.String("ZeroTo255String"),
+								Key:                  aws.String("Base64EncodedString"),
+								KeyMd5:               aws.String("Base64EncodedString"),
+								Mode:                 aws.String("EncryptionMode"),
+							},
+							InputKey:      aws.String("WatermarkKey"),
+							MaxHeight:     aws.String("DigitsOrAuto"),
+							MaxWidth:      aws.String("DigitsOrAuto"),
+							PaddingPolicy: aws.String("PaddingPolicy"),
+							SizingPolicy:  aws.String("SizingPolicy"),
+						},
+						// More values...
+					},
+					MergePolicy: aws.String("MergePolicy"),
+				},
+				Captions: &elastictranscoder.Captions{
+					CaptionFormats: []*elastictranscoder.CaptionFormat{
+						{ // Required
+							Encryption: &elastictranscoder.Encryption{
+								InitializationVector: aws.String("ZeroTo255String"),
+								Key:                  aws.String("Base64EncodedString"),
+								KeyMd5:               aws.String("Base64EncodedString"),
+								Mode:                 aws.String("EncryptionMode"),
+							},
+							Format:  aws.String("CaptionFormatFormat"),
+							Pattern: aws.String("CaptionFormatPattern"),
+						},
+						// More values...
+					},
+					CaptionSources: []*elastictranscoder.CaptionSource{
+						{ // Required
+							Encryption: &elastictranscoder.Encryption{
+								InitializationVector: aws.String("ZeroTo255String"),
+								Key:                  aws.String("Base64EncodedString"),
+								KeyMd5:               aws.String("Base64EncodedString"),
+								Mode:                 aws.String("EncryptionMode"),
+							},
+							Key:        aws.String("Key"),
+							Label:      aws.String("Name"),
+							Language:   aws.String("Key"),
+							TimeOffset: aws.String("TimeOffset"),
+						},
+						// More values...
+					},
+					MergePolicy: aws.String("CaptionMergePolicy"),
+				},
+				Composition: []*elastictranscoder.Clip{
+					{ // Required
+						TimeSpan: &elastictranscoder.TimeSpan{
+							Duration:  aws.String("Time"),
+							StartTime: aws.String("Time"),
+						},
+					},
+					// More values...
+				},
+				Encryption: &elastictranscoder.Encryption{
+					InitializationVector: aws.String("ZeroTo255String"),
+					Key:                  aws.String("Base64EncodedString"),
+					KeyMd5:               aws.String("Base64EncodedString"),
+					Mode:                 aws.String("EncryptionMode"),
+				},
+				Key:             aws.String("Key"),
+				PresetId:        aws.String("Id"),
+				Rotate:          aws.String("Rotate"),
+				SegmentDuration: aws.String("FloatString"),
+				ThumbnailEncryption: &elastictranscoder.Encryption{
+					InitializationVector: aws.String("ZeroTo255String"),
+					Key:                  aws.String("Base64EncodedString"),
+					KeyMd5:               aws.String("Base64EncodedString"),
+					Mode:                 aws.String("EncryptionMode"),
+				},
+				ThumbnailPattern: aws.String("ThumbnailPattern"),
+				Watermarks: []*elastictranscoder.JobWatermark{
+					{ // Required
+						Encryption: &elastictranscoder.Encryption{
+							InitializationVector: aws.String("ZeroTo255String"),
+							Key:                  aws.String("Base64EncodedString"),
+							KeyMd5:               aws.String("Base64EncodedString"),
+							Mode:                 aws.String("EncryptionMode"),
+						},
+						InputKey:          aws.String("WatermarkKey"),
+						PresetWatermarkId: aws.String("PresetWatermarkId"),
+					},
+					// More values...
+				},
 			},
+			// More values...
 		},
-		// More values...
-	},
-	UserMetadata: map[string]*string{
-		"Key": aws.String("String"), // Required
-		// More values...
-	},
+		Playlists: []*elastictranscoder.CreateJobPlaylist{
+			{ // Required
+				Format: aws.String("PlaylistFormat"),
+				HlsContentProtection: &elastictranscoder.HlsContentProtection{
+					InitializationVector:  aws.String("ZeroTo255String"),
+					Key:                   aws.String("Base64EncodedString"),
+					KeyMd5:                aws.String("Base64EncodedString"),
+					KeyStoragePolicy:      aws.String("KeyStoragePolicy"),
+					LicenseAcquisitionUrl: aws.String("ZeroTo512String"),
+					Method:                aws.String("HlsContentProtectionMethod"),
+				},
+				Name: aws.String("Filename"),
+				OutputKeys: []*string{
+					aws.String("Key"), // Required
+					// More values...
+				},
+				PlayReadyDrm: &elastictranscoder.PlayReadyDrm{
+					Format:                aws.String("PlayReadyDrmFormatString"),
+					InitializationVector:  aws.String("ZeroTo255String"),
+					Key:                   aws.String("NonEmptyBase64EncodedString"),
+					KeyId:                 aws.String("KeyIdGuid"),
+					KeyMd5:                aws.String("NonEmptyBase64EncodedString"),
+					LicenseAcquisitionUrl: aws.String("OneTo512String"),
+				},
+			},
+			// More values...
+		},
+		UserMetadata: map[string]*string{
+			"Key": aws.String("String"), // Required
+			// More values...
+		},
+	}
 }

vendor/github.com/aws/aws-sdk-go/private/protocol/restjson/unmarshal_test.go

@@ -45,8 +45,12 @@ func init() {
 	protocol.RandReader = &awstesting.ZeroReader{}
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService1ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService1ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService1ProtocolTest struct {
 	*client.Client
 }
@@ -104,19 +108,18 @@ const opOutputService1TestCaseOperation1 = "OperationName"
 
 // OutputService1TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService1TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService1TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService1TestCaseOperation1 method directly
-// instead.
+// See OutputService1TestCaseOperation1 for more information on using the OutputService1TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService1TestCaseOperation1Request method.
 //    req, resp := client.OutputService1TestCaseOperation1Request(params)
@@ -265,8 +268,12 @@ func (s *OutputService1TestShapeOutputService1TestCaseOperation1Output) SetTrueB
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService2ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService2ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService2ProtocolTest struct {
 	*client.Client
 }
@@ -324,19 +331,18 @@ const opOutputService2TestCaseOperation1 = "OperationName"
 
 // OutputService2TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService2TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService2TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService2TestCaseOperation1 method directly
-// instead.
+// See OutputService2TestCaseOperation1 for more information on using the OutputService2TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService2TestCaseOperation1Request method.
 //    req, resp := client.OutputService2TestCaseOperation1Request(params)
@@ -427,8 +433,12 @@ func (s *OutputService2TestShapeOutputService2TestCaseOperation1Output) SetStruc
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService3ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService3ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService3ProtocolTest struct {
 	*client.Client
 }
@@ -486,19 +496,18 @@ const opOutputService3TestCaseOperation1 = "OperationName"
 
 // OutputService3TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService3TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService3TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService3TestCaseOperation1 method directly
-// instead.
+// See OutputService3TestCaseOperation1 for more information on using the OutputService3TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService3TestCaseOperation1Request method.
 //    req, resp := client.OutputService3TestCaseOperation1Request(params)
@@ -587,8 +596,12 @@ func (s *OutputService3TestShapeTimeContainer) SetFoo(v time.Time) *OutputServic
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService4ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService4ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService4ProtocolTest struct {
 	*client.Client
 }
@@ -646,19 +659,18 @@ const opOutputService4TestCaseOperation1 = "OperationName"
 
 // OutputService4TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService4TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService4TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService4TestCaseOperation1 method directly
-// instead.
+// See OutputService4TestCaseOperation1 for more information on using the OutputService4TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService4TestCaseOperation1Request method.
 //    req, resp := client.OutputService4TestCaseOperation1Request(params)
@@ -727,8 +739,12 @@ func (s *OutputService4TestShapeOutputService4TestCaseOperation1Output) SetListM
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService5ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService5ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService5ProtocolTest struct {
 	*client.Client
 }
@@ -786,19 +802,18 @@ const opOutputService5TestCaseOperation1 = "OperationName"
 
 // OutputService5TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService5TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService5TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService5TestCaseOperation1 method directly
-// instead.
+// See OutputService5TestCaseOperation1 for more information on using the OutputService5TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService5TestCaseOperation1Request method.
 //    req, resp := client.OutputService5TestCaseOperation1Request(params)
@@ -879,8 +894,12 @@ func (s *OutputService5TestShapeSingleStruct) SetFoo(v string) *OutputService5Te
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService6ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService6ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService6ProtocolTest struct {
 	*client.Client
 }
@@ -938,19 +957,18 @@ const opOutputService6TestCaseOperation1 = "OperationName"
 
 // OutputService6TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService6TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService6TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService6TestCaseOperation1 method directly
-// instead.
+// See OutputService6TestCaseOperation1 for more information on using the OutputService6TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService6TestCaseOperation1Request method.
 //    req, resp := client.OutputService6TestCaseOperation1Request(params)
@@ -1019,8 +1037,12 @@ func (s *OutputService6TestShapeOutputService6TestCaseOperation1Output) SetMapMe
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService7ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService7ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService7ProtocolTest struct {
 	*client.Client
 }
@@ -1078,19 +1100,18 @@ const opOutputService7TestCaseOperation1 = "OperationName"
 
 // OutputService7TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService7TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService7TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService7TestCaseOperation1 method directly
-// instead.
+// See OutputService7TestCaseOperation1 for more information on using the OutputService7TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService7TestCaseOperation1Request method.
 //    req, resp := client.OutputService7TestCaseOperation1Request(params)
@@ -1159,8 +1180,12 @@ func (s *OutputService7TestShapeOutputService7TestCaseOperation1Output) SetMapMe
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService8ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService8ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService8ProtocolTest struct {
 	*client.Client
 }
@@ -1218,19 +1243,18 @@ const opOutputService8TestCaseOperation1 = "OperationName"
 
 // OutputService8TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService8TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService8TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService8TestCaseOperation1 method directly
-// instead.
+// See OutputService8TestCaseOperation1 for more information on using the OutputService8TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService8TestCaseOperation1Request method.
 //    req, resp := client.OutputService8TestCaseOperation1Request(params)
@@ -1299,8 +1323,12 @@ func (s *OutputService8TestShapeOutputService8TestCaseOperation1Output) SetStrTy
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService9ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService9ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService9ProtocolTest struct {
 	*client.Client
 }
@@ -1358,19 +1386,18 @@ const opOutputService9TestCaseOperation1 = "OperationName"
 
 // OutputService9TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService9TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService9TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService9TestCaseOperation1 method directly
-// instead.
+// See OutputService9TestCaseOperation1 for more information on using the OutputService9TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService9TestCaseOperation1Request method.
 //    req, resp := client.OutputService9TestCaseOperation1Request(params)
@@ -1447,8 +1474,12 @@ func (s *OutputService9TestShapeOutputService9TestCaseOperation1Output) SetPrefi
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService10ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService10ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService10ProtocolTest struct {
 	*client.Client
 }
@@ -1506,19 +1537,18 @@ const opOutputService10TestCaseOperation1 = "OperationName"
 
 // OutputService10TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService10TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService10TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService10TestCaseOperation1 method directly
-// instead.
+// See OutputService10TestCaseOperation1 for more information on using the OutputService10TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService10TestCaseOperation1Request method.
 //    req, resp := client.OutputService10TestCaseOperation1Request(params)
@@ -1607,8 +1637,12 @@ func (s *OutputService10TestShapeOutputService10TestCaseOperation1Output) SetHea
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService11ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService11ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService11ProtocolTest struct {
 	*client.Client
 }
@@ -1666,19 +1700,18 @@ const opOutputService11TestCaseOperation1 = "OperationName"
 
 // OutputService11TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService11TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService11TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService11TestCaseOperation1 method directly
-// instead.
+// See OutputService11TestCaseOperation1 for more information on using the OutputService11TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService11TestCaseOperation1Request method.
 //    req, resp := client.OutputService11TestCaseOperation1Request(params)
@@ -1747,8 +1780,12 @@ func (s *OutputService11TestShapeOutputService11TestCaseOperation1Output) SetStr
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService12ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService12ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService12ProtocolTest struct {
 	*client.Client
 }
@@ -1806,19 +1843,18 @@ const opOutputService12TestCaseOperation1 = "OperationName"
 
 // OutputService12TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService12TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService12TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService12TestCaseOperation1 method directly
-// instead.
+// See OutputService12TestCaseOperation1 for more information on using the OutputService12TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService12TestCaseOperation1Request method.
 //    req, resp := client.OutputService12TestCaseOperation1Request(params)

vendor/github.com/aws/aws-sdk-go/private/protocol/restxml/build_bench_test.go

@@ -3,47 +3,115 @@
 package restxml_test
 
 import (
+	"net/http"
+	"net/http/httptest"
+	"os"
 	"testing"
 
 	"bytes"
 	"encoding/xml"
+
 	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/credentials"
+	"github.com/aws/aws-sdk-go/aws/endpoints"
 	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/awstesting"
+	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/private/protocol/restxml"
 	"github.com/aws/aws-sdk-go/service/cloudfront"
+	"github.com/aws/aws-sdk-go/service/s3"
 )
 
-func BenchmarkRESTXMLBuild_Complex_cloudfrontCreateDistribution(b *testing.B) {
-	params := restxmlBuildCreateDistroParms
+var (
+	cloudfrontSvc *cloudfront.CloudFront
+	s3Svc         *s3.S3
+)
 
-	op := &request.Operation{
-		Name:       "CreateDistribution",
-		HTTPMethod: "POST",
-		HTTPPath:   "/2015-04-17/distribution/{DistributionId}/invalidation",
-	}
+func TestMain(m *testing.M) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
 
-	benchRESTXMLBuild(b, op, params)
+	sess := session.Must(session.NewSession(&aws.Config{
+		Credentials:      credentials.NewStaticCredentials("Key", "Secret", "Token"),
+		Endpoint:         aws.String(server.URL),
+		S3ForcePathStyle: aws.Bool(true),
+		DisableSSL:       aws.Bool(true),
+		Region:           aws.String(endpoints.UsWest2RegionID),
+	}))
+	cloudfrontSvc = cloudfront.New(sess)
+	s3Svc = s3.New(sess)
+
+	c := m.Run()
+	server.Close()
+	os.Exit(c)
 }
 
-func BenchmarkRESTXMLBuild_Simple_cloudfrontDeleteStreamingDistribution(b *testing.B) {
-	params := &cloudfront.DeleteDistributionInput{
-		Id:      aws.String("string"), // Required
-		IfMatch: aws.String("string"),
-	}
-	op := &request.Operation{
-		Name:       "DeleteStreamingDistribution",
-		HTTPMethod: "DELETE",
-		HTTPPath:   "/2015-04-17/streaming-distribution/{Id}",
-	}
-	benchRESTXMLBuild(b, op, params)
+func BenchmarkRESTXMLBuild_Complex_CFCreateDistro(b *testing.B) {
+	params := cloudfrontCreateDistributionInput()
+
+	benchRESTXMLBuild(b, func() *request.Request {
+		req, _ := cloudfrontSvc.CreateDistributionRequest(params)
+		return req
+	})
 }
 
-func BenchmarkEncodingXMLMarshal_Simple_cloudfrontDeleteStreamingDistribution(b *testing.B) {
-	params := &cloudfront.DeleteDistributionInput{
-		Id:      aws.String("string"), // Required
-		IfMatch: aws.String("string"),
-	}
+func BenchmarkRESTXMLBuild_Simple_CFDeleteDistro(b *testing.B) {
+	params := cloudfrontDeleteDistributionInput()
+
+	benchRESTXMLBuild(b, func() *request.Request {
+		req, _ := cloudfrontSvc.DeleteDistributionRequest(params)
+		return req
+	})
+}
+
+func BenchmarkRESTXMLBuild_REST_S3HeadObject(b *testing.B) {
+	params := s3HeadObjectInput()
+
+	benchRESTXMLBuild(b, func() *request.Request {
+		req, _ := s3Svc.HeadObjectRequest(params)
+		return req
+	})
+}
+
+func BenchmarkRESTXMLBuild_XML_S3PutObjectAcl(b *testing.B) {
+	params := s3PutObjectAclInput()
+
+	benchRESTXMLBuild(b, func() *request.Request {
+		req, _ := s3Svc.PutObjectAclRequest(params)
+		return req
+	})
+}
+
+func BenchmarkRESTXMLRequest_Complex_CFCreateDistro(b *testing.B) {
+	benchRESTXMLRequest(b, func() *request.Request {
+		req, _ := cloudfrontSvc.CreateDistributionRequest(cloudfrontCreateDistributionInput())
+		return req
+	})
+}
+
+func BenchmarkRESTXMLRequest_Simple_CFDeleteDistro(b *testing.B) {
+	benchRESTXMLRequest(b, func() *request.Request {
+		req, _ := cloudfrontSvc.DeleteDistributionRequest(cloudfrontDeleteDistributionInput())
+		return req
+	})
+}
+
+func BenchmarkRESTXMLRequest_REST_S3HeadObject(b *testing.B) {
+	benchRESTXMLRequest(b, func() *request.Request {
+		req, _ := s3Svc.HeadObjectRequest(s3HeadObjectInput())
+		return req
+	})
+}
+
+func BenchmarkRESTXMLRequest_XML_S3PutObjectAcl(b *testing.B) {
+	benchRESTXMLRequest(b, func() *request.Request {
+		req, _ := s3Svc.PutObjectAclRequest(s3PutObjectAclInput())
+		return req
+	})
+}
+
+func BenchmarkEncodingXML_Simple(b *testing.B) {
+	params := cloudfrontDeleteDistributionInput()
 
 	for i := 0; i < b.N; i++ {
 		buf := &bytes.Buffer{}
@@ -54,118 +122,39 @@ func BenchmarkEncodingXMLMarshal_Simple_cloudfrontDeleteStreamingDistribution(b
 	}
 }
 
-func benchRESTXMLBuild(b *testing.B, op *request.Operation, params interface{}) {
-	svc := awstesting.NewClient()
-	svc.ServiceName = "cloudfront"
-	svc.APIVersion = "2015-04-17"
+func benchRESTXMLBuild(b *testing.B, reqFn func() *request.Request) {
+	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		r := svc.NewRequest(op, params, nil)
-		restxml.Build(r)
-		if r.Error != nil {
-			b.Fatal("Unexpected error", r.Error)
+		req := reqFn()
+		restxml.Build(req)
+		if req.Error != nil {
+			b.Fatal("Unexpected error", req.Error)
 		}
 	}
 }
 
-var restxmlBuildCreateDistroParms = &cloudfront.CreateDistributionInput{
-	DistributionConfig: &cloudfront.DistributionConfig{ // Required
-		CallerReference: aws.String("string"), // Required
-		Comment:         aws.String("string"), // Required
-		DefaultCacheBehavior: &cloudfront.DefaultCacheBehavior{ // Required
-			ForwardedValues: &cloudfront.ForwardedValues{ // Required
-				Cookies: &cloudfront.CookiePreference{ // Required
-					Forward: aws.String("ItemSelection"), // Required
-					WhitelistedNames: &cloudfront.CookieNames{
-						Quantity: aws.Int64(1), // Required
-						Items: []*string{
-							aws.String("string"), // Required
-							// More values...
-						},
-					},
-				},
-				QueryString: aws.Bool(true), // Required
-				Headers: &cloudfront.Headers{
-					Quantity: aws.Int64(1), // Required
-					Items: []*string{
-						aws.String("string"), // Required
-						// More values...
-					},
-				},
-			},
-			MinTTL:         aws.Int64(1),         // Required
-			TargetOriginId: aws.String("string"), // Required
-			TrustedSigners: &cloudfront.TrustedSigners{ // Required
-				Enabled:  aws.Bool(true), // Required
-				Quantity: aws.Int64(1),   // Required
-				Items: []*string{
-					aws.String("string"), // Required
-					// More values...
-				},
-			},
-			ViewerProtocolPolicy: aws.String("ViewerProtocolPolicy"), // Required
-			AllowedMethods: &cloudfront.AllowedMethods{
-				Items: []*string{ // Required
-					aws.String("Method"), // Required
-					// More values...
-				},
-				Quantity: aws.Int64(1), // Required
-				CachedMethods: &cloudfront.CachedMethods{
-					Items: []*string{ // Required
-						aws.String("Method"), // Required
-						// More values...
-					},
-					Quantity: aws.Int64(1), // Required
-				},
-			},
-			DefaultTTL:      aws.Int64(1),
-			MaxTTL:          aws.Int64(1),
-			SmoothStreaming: aws.Bool(true),
-		},
-		Enabled: aws.Bool(true), // Required
-		Origins: &cloudfront.Origins{ // Required
-			Quantity: aws.Int64(1), // Required
-			Items: []*cloudfront.Origin{
-				{ // Required
-					DomainName: aws.String("string"), // Required
-					Id:         aws.String("string"), // Required
-					CustomOriginConfig: &cloudfront.CustomOriginConfig{
-						HTTPPort:             aws.Int64(1),                       // Required
-						HTTPSPort:            aws.Int64(1),                       // Required
-						OriginProtocolPolicy: aws.String("OriginProtocolPolicy"), // Required
-					},
-					OriginPath: aws.String("string"),
-					S3OriginConfig: &cloudfront.S3OriginConfig{
-						OriginAccessIdentity: aws.String("string"), // Required
-					},
-				},
-				// More values...
-			},
-		},
-		Aliases: &cloudfront.Aliases{
-			Quantity: aws.Int64(1), // Required
-			Items: []*string{
-				aws.String("string"), // Required
-				// More values...
-			},
-		},
-		CacheBehaviors: &cloudfront.CacheBehaviors{
-			Quantity: aws.Int64(1), // Required
-			Items: []*cloudfront.CacheBehavior{
-				{ // Required
-					ForwardedValues: &cloudfront.ForwardedValues{ // Required
-						Cookies: &cloudfront.CookiePreference{ // Required
-							Forward: aws.String("ItemSelection"), // Required
-							WhitelistedNames: &cloudfront.CookieNames{
-								Quantity: aws.Int64(1), // Required
-								Items: []*string{
-									aws.String("string"), // Required
-									// More values...
-								},
-							},
-						},
-						QueryString: aws.Bool(true), // Required
-						Headers: &cloudfront.Headers{
+func benchRESTXMLRequest(b *testing.B, reqFn func() *request.Request) {
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		err := reqFn().Send()
+		if err != nil {
+			b.Fatal("Unexpected error", err)
+		}
+	}
+}
+
+func cloudfrontCreateDistributionInput() *cloudfront.CreateDistributionInput {
+	return &cloudfront.CreateDistributionInput{
+		DistributionConfig: &cloudfront.DistributionConfig{ // Required
+			CallerReference: aws.String("string"), // Required
+			Comment:         aws.String("string"), // Required
+			DefaultCacheBehavior: &cloudfront.DefaultCacheBehavior{ // Required
+				ForwardedValues: &cloudfront.ForwardedValues{ // Required
+					Cookies: &cloudfront.CookiePreference{ // Required
+						Forward: aws.String("ItemSelection"), // Required
+						WhitelistedNames: &cloudfront.CookieNames{
 							Quantity: aws.Int64(1), // Required
 							Items: []*string{
 								aws.String("string"), // Required
@@ -173,74 +162,205 @@ var restxmlBuildCreateDistroParms = &cloudfront.CreateDistributionInput{
 							},
 						},
 					},
-					MinTTL:         aws.Int64(1),         // Required
-					PathPattern:    aws.String("string"), // Required
-					TargetOriginId: aws.String("string"), // Required
-					TrustedSigners: &cloudfront.TrustedSigners{ // Required
-						Enabled:  aws.Bool(true), // Required
-						Quantity: aws.Int64(1),   // Required
+					QueryString: aws.Bool(true), // Required
+					Headers: &cloudfront.Headers{
+						Quantity: aws.Int64(1), // Required
 						Items: []*string{
 							aws.String("string"), // Required
 							// More values...
 						},
 					},
-					ViewerProtocolPolicy: aws.String("ViewerProtocolPolicy"), // Required
-					AllowedMethods: &cloudfront.AllowedMethods{
+				},
+				MinTTL:         aws.Int64(1),         // Required
+				TargetOriginId: aws.String("string"), // Required
+				TrustedSigners: &cloudfront.TrustedSigners{ // Required
+					Enabled:  aws.Bool(true), // Required
+					Quantity: aws.Int64(1),   // Required
+					Items: []*string{
+						aws.String("string"), // Required
+						// More values...
+					},
+				},
+				ViewerProtocolPolicy: aws.String("ViewerProtocolPolicy"), // Required
+				AllowedMethods: &cloudfront.AllowedMethods{
+					Items: []*string{ // Required
+						aws.String("Method"), // Required
+						// More values...
+					},
+					Quantity: aws.Int64(1), // Required
+					CachedMethods: &cloudfront.CachedMethods{
 						Items: []*string{ // Required
 							aws.String("Method"), // Required
 							// More values...
 						},
 						Quantity: aws.Int64(1), // Required
-						CachedMethods: &cloudfront.CachedMethods{
-							Items: []*string{ // Required
-								aws.String("Method"), // Required
-								// More values...
-							},
-							Quantity: aws.Int64(1), // Required
+					},
+				},
+				DefaultTTL:      aws.Int64(1),
+				MaxTTL:          aws.Int64(1),
+				SmoothStreaming: aws.Bool(true),
+			},
+			Enabled: aws.Bool(true), // Required
+			Origins: &cloudfront.Origins{ // Required
+				Quantity: aws.Int64(1), // Required
+				Items: []*cloudfront.Origin{
+					{ // Required
+						DomainName: aws.String("string"), // Required
+						Id:         aws.String("string"), // Required
+						CustomOriginConfig: &cloudfront.CustomOriginConfig{
+							HTTPPort:             aws.Int64(1),                       // Required
+							HTTPSPort:            aws.Int64(1),                       // Required
+							OriginProtocolPolicy: aws.String("OriginProtocolPolicy"), // Required
+						},
+						OriginPath: aws.String("string"),
+						S3OriginConfig: &cloudfront.S3OriginConfig{
+							OriginAccessIdentity: aws.String("string"), // Required
 						},
 					},
-					DefaultTTL:      aws.Int64(1),
-					MaxTTL:          aws.Int64(1),
-					SmoothStreaming: aws.Bool(true),
+					// More values...
 				},
-				// More values...
 			},
-		},
-		CustomErrorResponses: &cloudfront.CustomErrorResponses{
-			Quantity: aws.Int64(1), // Required
-			Items: []*cloudfront.CustomErrorResponse{
-				{ // Required
-					ErrorCode:          aws.Int64(1), // Required
-					ErrorCachingMinTTL: aws.Int64(1),
-					ResponseCode:       aws.String("string"),
-					ResponsePagePath:   aws.String("string"),
-				},
-				// More values...
-			},
-		},
-		DefaultRootObject: aws.String("string"),
-		Logging: &cloudfront.LoggingConfig{
-			Bucket:         aws.String("string"), // Required
-			Enabled:        aws.Bool(true),       // Required
-			IncludeCookies: aws.Bool(true),       // Required
-			Prefix:         aws.String("string"), // Required
-		},
-		PriceClass: aws.String("PriceClass"),
-		Restrictions: &cloudfront.Restrictions{
-			GeoRestriction: &cloudfront.GeoRestriction{ // Required
-				Quantity:        aws.Int64(1),                     // Required
-				RestrictionType: aws.String("GeoRestrictionType"), // Required
+			Aliases: &cloudfront.Aliases{
+				Quantity: aws.Int64(1), // Required
 				Items: []*string{
 					aws.String("string"), // Required
 					// More values...
 				},
 			},
+			CacheBehaviors: &cloudfront.CacheBehaviors{
+				Quantity: aws.Int64(1), // Required
+				Items: []*cloudfront.CacheBehavior{
+					{ // Required
+						ForwardedValues: &cloudfront.ForwardedValues{ // Required
+							Cookies: &cloudfront.CookiePreference{ // Required
+								Forward: aws.String("ItemSelection"), // Required
+								WhitelistedNames: &cloudfront.CookieNames{
+									Quantity: aws.Int64(1), // Required
+									Items: []*string{
+										aws.String("string"), // Required
+										// More values...
+									},
+								},
+							},
+							QueryString: aws.Bool(true), // Required
+							Headers: &cloudfront.Headers{
+								Quantity: aws.Int64(1), // Required
+								Items: []*string{
+									aws.String("string"), // Required
+									// More values...
+								},
+							},
+						},
+						MinTTL:         aws.Int64(1),         // Required
+						PathPattern:    aws.String("string"), // Required
+						TargetOriginId: aws.String("string"), // Required
+						TrustedSigners: &cloudfront.TrustedSigners{ // Required
+							Enabled:  aws.Bool(true), // Required
+							Quantity: aws.Int64(1),   // Required
+							Items: []*string{
+								aws.String("string"), // Required
+								// More values...
+							},
+						},
+						ViewerProtocolPolicy: aws.String("ViewerProtocolPolicy"), // Required
+						AllowedMethods: &cloudfront.AllowedMethods{
+							Items: []*string{ // Required
+								aws.String("Method"), // Required
+								// More values...
+							},
+							Quantity: aws.Int64(1), // Required
+							CachedMethods: &cloudfront.CachedMethods{
+								Items: []*string{ // Required
+									aws.String("Method"), // Required
+									// More values...
+								},
+								Quantity: aws.Int64(1), // Required
+							},
+						},
+						DefaultTTL:      aws.Int64(1),
+						MaxTTL:          aws.Int64(1),
+						SmoothStreaming: aws.Bool(true),
+					},
+					// More values...
+				},
+			},
+			CustomErrorResponses: &cloudfront.CustomErrorResponses{
+				Quantity: aws.Int64(1), // Required
+				Items: []*cloudfront.CustomErrorResponse{
+					{ // Required
+						ErrorCode:          aws.Int64(1), // Required
+						ErrorCachingMinTTL: aws.Int64(1),
+						ResponseCode:       aws.String("string"),
+						ResponsePagePath:   aws.String("string"),
+					},
+					// More values...
+				},
+			},
+			DefaultRootObject: aws.String("string"),
+			Logging: &cloudfront.LoggingConfig{
+				Bucket:         aws.String("string"), // Required
+				Enabled:        aws.Bool(true),       // Required
+				IncludeCookies: aws.Bool(true),       // Required
+				Prefix:         aws.String("string"), // Required
+			},
+			PriceClass: aws.String("PriceClass"),
+			Restrictions: &cloudfront.Restrictions{
+				GeoRestriction: &cloudfront.GeoRestriction{ // Required
+					Quantity:        aws.Int64(1),                     // Required
+					RestrictionType: aws.String("GeoRestrictionType"), // Required
+					Items: []*string{
+						aws.String("string"), // Required
+						// More values...
+					},
+				},
+			},
+			ViewerCertificate: &cloudfront.ViewerCertificate{
+				CloudFrontDefaultCertificate: aws.Bool(true),
+				IAMCertificateId:             aws.String("string"),
+				MinimumProtocolVersion:       aws.String("MinimumProtocolVersion"),
+				SSLSupportMethod:             aws.String("SSLSupportMethod"),
+			},
 		},
-		ViewerCertificate: &cloudfront.ViewerCertificate{
-			CloudFrontDefaultCertificate: aws.Bool(true),
-			IAMCertificateId:             aws.String("string"),
-			MinimumProtocolVersion:       aws.String("MinimumProtocolVersion"),
-			SSLSupportMethod:             aws.String("SSLSupportMethod"),
-		},
-	},
+	}
+}
+
+func cloudfrontDeleteDistributionInput() *cloudfront.DeleteDistributionInput {
+	return &cloudfront.DeleteDistributionInput{
+		Id:      aws.String("string"), // Required
+		IfMatch: aws.String("string"),
+	}
+}
+
+func s3HeadObjectInput() *s3.HeadObjectInput {
+	return &s3.HeadObjectInput{
+		Bucket:    aws.String("somebucketname"),
+		Key:       aws.String("keyname"),
+		VersionId: aws.String("someVersion"),
+		IfMatch:   aws.String("IfMatch"),
+	}
+}
+
+func s3PutObjectAclInput() *s3.PutObjectAclInput {
+	return &s3.PutObjectAclInput{
+		Bucket: aws.String("somebucketname"),
+		Key:    aws.String("keyname"),
+		AccessControlPolicy: &s3.AccessControlPolicy{
+			Grants: []*s3.Grant{
+				{
+					Grantee: &s3.Grantee{
+						DisplayName:  aws.String("someName"),
+						EmailAddress: aws.String("someAddr"),
+						ID:           aws.String("someID"),
+						Type:         aws.String(s3.TypeCanonicalUser),
+						URI:          aws.String("someURI"),
+					},
+					Permission: aws.String(s3.PermissionWrite),
+				},
+			},
+			Owner: &s3.Owner{
+				DisplayName: aws.String("howdy"),
+				ID:          aws.String("someID"),
+			},
+		},
+	}
 }

vendor/github.com/aws/aws-sdk-go/private/protocol/restxml/unmarshal_test.go

@@ -45,8 +45,12 @@ func init() {
 	protocol.RandReader = &awstesting.ZeroReader{}
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService1ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService1ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService1ProtocolTest struct {
 	*client.Client
 }
@@ -104,19 +108,18 @@ const opOutputService1TestCaseOperation1 = "OperationName"
 
 // OutputService1TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService1TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService1TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService1TestCaseOperation1 method directly
-// instead.
+// See OutputService1TestCaseOperation1 for more information on using the OutputService1TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService1TestCaseOperation1Request method.
 //    req, resp := client.OutputService1TestCaseOperation1Request(params)
@@ -125,7 +128,7 @@ const opOutputService1TestCaseOperation1 = "OperationName"
 //    if err == nil { // resp is now filled
 //        fmt.Println(resp)
 //    }
-func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1Request(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (req *request.Request, output *OutputService1TestShapeOutputShape) {
+func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1Request(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (req *request.Request, output *OutputService1TestShapeOutputService1TestCaseOperation2Output) {
 	op := &request.Operation{
 		Name:     opOutputService1TestCaseOperation1,
 		HTTPPath: "/",
@@ -135,7 +138,7 @@ func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1Request(inp
 		input = &OutputService1TestShapeOutputService1TestCaseOperation1Input{}
 	}
 
-	output = &OutputService1TestShapeOutputShape{}
+	output = &OutputService1TestShapeOutputService1TestCaseOperation2Output{}
 	req = c.newRequest(op, input, output)
 	return
 }
@@ -148,7 +151,7 @@ func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1Request(inp
 //
 // See the AWS API reference guide for 's
 // API operation OutputService1TestCaseOperation1 for usage and error information.
-func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (*OutputService1TestShapeOutputShape, error) {
+func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (*OutputService1TestShapeOutputService1TestCaseOperation2Output, error) {
 	req, out := c.OutputService1TestCaseOperation1Request(input)
 	return out, req.Send()
 }
@@ -162,7 +165,7 @@ func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1(input *Out
 // the context is nil a panic will occur. In the future the SDK may create
 // sub-contexts for http.Requests. See https://golang.org/pkg/context/
 // for more information on using Contexts.
-func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1WithContext(ctx aws.Context, input *OutputService1TestShapeOutputService1TestCaseOperation1Input, opts ...request.Option) (*OutputService1TestShapeOutputShape, error) {
+func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1WithContext(ctx aws.Context, input *OutputService1TestShapeOutputService1TestCaseOperation1Input, opts ...request.Option) (*OutputService1TestShapeOutputService1TestCaseOperation2Output, error) {
 	req, out := c.OutputService1TestCaseOperation1Request(input)
 	req.SetContext(ctx)
 	req.ApplyOptions(opts...)
@@ -173,19 +176,18 @@ const opOutputService1TestCaseOperation2 = "OperationName"
 
 // OutputService1TestCaseOperation2Request generates a "aws/request.Request" representing the
 // client's request for the OutputService1TestCaseOperation2 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService1TestCaseOperation2 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService1TestCaseOperation2 method directly
-// instead.
+// See OutputService1TestCaseOperation2 for more information on using the OutputService1TestCaseOperation2
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService1TestCaseOperation2Request method.
 //    req, resp := client.OutputService1TestCaseOperation2Request(params)
@@ -194,7 +196,7 @@ const opOutputService1TestCaseOperation2 = "OperationName"
 //    if err == nil { // resp is now filled
 //        fmt.Println(resp)
 //    }
-func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2Request(input *OutputService1TestShapeOutputService1TestCaseOperation2Input) (req *request.Request, output *OutputService1TestShapeOutputShape) {
+func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2Request(input *OutputService1TestShapeOutputService1TestCaseOperation2Input) (req *request.Request, output *OutputService1TestShapeOutputService1TestCaseOperation2Output) {
 	op := &request.Operation{
 		Name:     opOutputService1TestCaseOperation2,
 		HTTPPath: "/",
@@ -204,7 +206,7 @@ func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2Request(inp
 		input = &OutputService1TestShapeOutputService1TestCaseOperation2Input{}
 	}
 
-	output = &OutputService1TestShapeOutputShape{}
+	output = &OutputService1TestShapeOutputService1TestCaseOperation2Output{}
 	req = c.newRequest(op, input, output)
 	return
 }
@@ -217,7 +219,7 @@ func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2Request(inp
 //
 // See the AWS API reference guide for 's
 // API operation OutputService1TestCaseOperation2 for usage and error information.
-func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2(input *OutputService1TestShapeOutputService1TestCaseOperation2Input) (*OutputService1TestShapeOutputShape, error) {
+func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2(input *OutputService1TestShapeOutputService1TestCaseOperation2Input) (*OutputService1TestShapeOutputService1TestCaseOperation2Output, error) {
 	req, out := c.OutputService1TestCaseOperation2Request(input)
 	return out, req.Send()
 }
@@ -231,7 +233,7 @@ func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2(input *Out
 // the context is nil a panic will occur. In the future the SDK may create
 // sub-contexts for http.Requests. See https://golang.org/pkg/context/
 // for more information on using Contexts.
-func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2WithContext(ctx aws.Context, input *OutputService1TestShapeOutputService1TestCaseOperation2Input, opts ...request.Option) (*OutputService1TestShapeOutputShape, error) {
+func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2WithContext(ctx aws.Context, input *OutputService1TestShapeOutputService1TestCaseOperation2Input, opts ...request.Option) (*OutputService1TestShapeOutputService1TestCaseOperation2Output, error) {
 	req, out := c.OutputService1TestCaseOperation2Request(input)
 	req.SetContext(ctx)
 	req.ApplyOptions(opts...)
@@ -246,7 +248,7 @@ type OutputService1TestShapeOutputService1TestCaseOperation2Input struct {
 	_ struct{} `type:"structure"`
 }
 
-type OutputService1TestShapeOutputShape struct {
+type OutputService1TestShapeOutputService1TestCaseOperation2Output struct {
 	_ struct{} `type:"structure"`
 
 	Char *string `type:"character"`
@@ -273,73 +275,77 @@ type OutputService1TestShapeOutputShape struct {
 }
 
 // SetChar sets the Char field's value.
-func (s *OutputService1TestShapeOutputShape) SetChar(v string) *OutputService1TestShapeOutputShape {
+func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetChar(v string) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
 	s.Char = &v
 	return s
 }
 
 // SetDouble sets the Double field's value.
-func (s *OutputService1TestShapeOutputShape) SetDouble(v float64) *OutputService1TestShapeOutputShape {
+func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetDouble(v float64) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
 	s.Double = &v
 	return s
 }
 
 // SetFalseBool sets the FalseBool field's value.
-func (s *OutputService1TestShapeOutputShape) SetFalseBool(v bool) *OutputService1TestShapeOutputShape {
+func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetFalseBool(v bool) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
 	s.FalseBool = &v
 	return s
 }
 
 // SetFloat sets the Float field's value.
-func (s *OutputService1TestShapeOutputShape) SetFloat(v float64) *OutputService1TestShapeOutputShape {
+func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetFloat(v float64) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
 	s.Float = &v
 	return s
 }
 
 // SetImaHeader sets the ImaHeader field's value.
-func (s *OutputService1TestShapeOutputShape) SetImaHeader(v string) *OutputService1TestShapeOutputShape {
+func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetImaHeader(v string) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
 	s.ImaHeader = &v
 	return s
 }
 
 // SetImaHeaderLocation sets the ImaHeaderLocation field's value.
-func (s *OutputService1TestShapeOutputShape) SetImaHeaderLocation(v string) *OutputService1TestShapeOutputShape {
+func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetImaHeaderLocation(v string) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
 	s.ImaHeaderLocation = &v
 	return s
 }
 
 // SetLong sets the Long field's value.
-func (s *OutputService1TestShapeOutputShape) SetLong(v int64) *OutputService1TestShapeOutputShape {
+func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetLong(v int64) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
 	s.Long = &v
 	return s
 }
 
 // SetNum sets the Num field's value.
-func (s *OutputService1TestShapeOutputShape) SetNum(v int64) *OutputService1TestShapeOutputShape {
+func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetNum(v int64) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
 	s.Num = &v
 	return s
 }
 
 // SetStr sets the Str field's value.
-func (s *OutputService1TestShapeOutputShape) SetStr(v string) *OutputService1TestShapeOutputShape {
+func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetStr(v string) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
 	s.Str = &v
 	return s
 }
 
 // SetTimestamp sets the Timestamp field's value.
-func (s *OutputService1TestShapeOutputShape) SetTimestamp(v time.Time) *OutputService1TestShapeOutputShape {
+func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetTimestamp(v time.Time) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
 	s.Timestamp = &v
 	return s
 }
 
 // SetTrueBool sets the TrueBool field's value.
-func (s *OutputService1TestShapeOutputShape) SetTrueBool(v bool) *OutputService1TestShapeOutputShape {
+func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetTrueBool(v bool) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
 	s.TrueBool = &v
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService2ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService2ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService2ProtocolTest struct {
 	*client.Client
 }
@@ -397,19 +403,18 @@ const opOutputService2TestCaseOperation1 = "OperationName"
 
 // OutputService2TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService2TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService2TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService2TestCaseOperation1 method directly
-// instead.
+// See OutputService2TestCaseOperation1 for more information on using the OutputService2TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService2TestCaseOperation1Request method.
 //    req, resp := client.OutputService2TestCaseOperation1Request(params)
@@ -479,8 +484,12 @@ func (s *OutputService2TestShapeOutputService2TestCaseOperation1Output) SetBlob(
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService3ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService3ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService3ProtocolTest struct {
 	*client.Client
 }
@@ -538,19 +547,18 @@ const opOutputService3TestCaseOperation1 = "OperationName"
 
 // OutputService3TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService3TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService3TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService3TestCaseOperation1 method directly
-// instead.
+// See OutputService3TestCaseOperation1 for more information on using the OutputService3TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService3TestCaseOperation1Request method.
 //    req, resp := client.OutputService3TestCaseOperation1Request(params)
@@ -619,8 +627,12 @@ func (s *OutputService3TestShapeOutputService3TestCaseOperation1Output) SetListM
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService4ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService4ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService4ProtocolTest struct {
 	*client.Client
 }
@@ -678,19 +690,18 @@ const opOutputService4TestCaseOperation1 = "OperationName"
 
 // OutputService4TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService4TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService4TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService4TestCaseOperation1 method directly
-// instead.
+// See OutputService4TestCaseOperation1 for more information on using the OutputService4TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService4TestCaseOperation1Request method.
 //    req, resp := client.OutputService4TestCaseOperation1Request(params)
@@ -759,8 +770,12 @@ func (s *OutputService4TestShapeOutputService4TestCaseOperation1Output) SetListM
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService5ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService5ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService5ProtocolTest struct {
 	*client.Client
 }
@@ -818,19 +833,18 @@ const opOutputService5TestCaseOperation1 = "OperationName"
 
 // OutputService5TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService5TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService5TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService5TestCaseOperation1 method directly
-// instead.
+// See OutputService5TestCaseOperation1 for more information on using the OutputService5TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService5TestCaseOperation1Request method.
 //    req, resp := client.OutputService5TestCaseOperation1Request(params)
@@ -899,8 +913,12 @@ func (s *OutputService5TestShapeOutputService5TestCaseOperation1Output) SetListM
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService6ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService6ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService6ProtocolTest struct {
 	*client.Client
 }
@@ -958,19 +976,18 @@ const opOutputService6TestCaseOperation1 = "OperationName"
 
 // OutputService6TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService6TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService6TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService6TestCaseOperation1 method directly
-// instead.
+// See OutputService6TestCaseOperation1 for more information on using the OutputService6TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService6TestCaseOperation1Request method.
 //    req, resp := client.OutputService6TestCaseOperation1Request(params)
@@ -1051,8 +1068,12 @@ func (s *OutputService6TestShapeSingleStructure) SetFoo(v string) *OutputService
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService7ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService7ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService7ProtocolTest struct {
 	*client.Client
 }
@@ -1110,19 +1131,18 @@ const opOutputService7TestCaseOperation1 = "OperationName"
 
 // OutputService7TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService7TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService7TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService7TestCaseOperation1 method directly
-// instead.
+// See OutputService7TestCaseOperation1 for more information on using the OutputService7TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService7TestCaseOperation1Request method.
 //    req, resp := client.OutputService7TestCaseOperation1Request(params)
@@ -1191,8 +1211,12 @@ func (s *OutputService7TestShapeOutputService7TestCaseOperation1Output) SetMap(v
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService8ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService8ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService8ProtocolTest struct {
 	*client.Client
 }
@@ -1250,19 +1274,18 @@ const opOutputService8TestCaseOperation1 = "OperationName"
 
 // OutputService8TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService8TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService8TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService8TestCaseOperation1 method directly
-// instead.
+// See OutputService8TestCaseOperation1 for more information on using the OutputService8TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService8TestCaseOperation1Request method.
 //    req, resp := client.OutputService8TestCaseOperation1Request(params)
@@ -1331,8 +1354,12 @@ func (s *OutputService8TestShapeOutputService8TestCaseOperation1Output) SetMap(v
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService9ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService9ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService9ProtocolTest struct {
 	*client.Client
 }
@@ -1390,19 +1417,18 @@ const opOutputService9TestCaseOperation1 = "OperationName"
 
 // OutputService9TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService9TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService9TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService9TestCaseOperation1 method directly
-// instead.
+// See OutputService9TestCaseOperation1 for more information on using the OutputService9TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService9TestCaseOperation1Request method.
 //    req, resp := client.OutputService9TestCaseOperation1Request(params)
@@ -1491,8 +1517,12 @@ func (s *OutputService9TestShapeSingleStructure) SetFoo(v string) *OutputService
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService10ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService10ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService10ProtocolTest struct {
 	*client.Client
 }
@@ -1550,19 +1580,18 @@ const opOutputService10TestCaseOperation1 = "OperationName"
 
 // OutputService10TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService10TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService10TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService10TestCaseOperation1 method directly
-// instead.
+// See OutputService10TestCaseOperation1 for more information on using the OutputService10TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService10TestCaseOperation1Request method.
 //    req, resp := client.OutputService10TestCaseOperation1Request(params)
@@ -1631,8 +1660,12 @@ func (s *OutputService10TestShapeOutputService10TestCaseOperation1Output) SetStr
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService11ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService11ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService11ProtocolTest struct {
 	*client.Client
 }
@@ -1690,19 +1723,18 @@ const opOutputService11TestCaseOperation1 = "OperationName"
 
 // OutputService11TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService11TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService11TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService11TestCaseOperation1 method directly
-// instead.
+// See OutputService11TestCaseOperation1 for more information on using the OutputService11TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService11TestCaseOperation1Request method.
 //    req, resp := client.OutputService11TestCaseOperation1Request(params)
@@ -1835,8 +1867,12 @@ func (s *OutputService11TestShapeOutputService11TestCaseOperation1Output) SetTru
 	return s
 }
 
-// The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
+// OutputService12ProtocolTest provides the API operation methods for making requests to
+// . See this package's package overview docs
+// for details on the service.
+//
+// OutputService12ProtocolTest methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
 type OutputService12ProtocolTest struct {
 	*client.Client
 }
@@ -1894,19 +1930,18 @@ const opOutputService12TestCaseOperation1 = "OperationName"
 
 // OutputService12TestCaseOperation1Request generates a "aws/request.Request" representing the
 // client's request for the OutputService12TestCaseOperation1 operation. The "output" return
-// value can be used to capture response data after the request's "Send" method
-// is called.
+// value will be populated with the request's response once the request complets
+// successfuly.
 //
-// See OutputService12TestCaseOperation1 for usage and error information.
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
 //
-// Creating a request object using this method should be used when you want to inject
-// custom logic into the request's lifecycle using a custom handler, or if you want to
-// access properties on the request object before or after sending the request. If
-// you just want the service response, call the OutputService12TestCaseOperation1 method directly
-// instead.
+// See OutputService12TestCaseOperation1 for more information on using the OutputService12TestCaseOperation1
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
 //
-// Note: You must call the "Send" method on the returned request object in order
-// to execute the request.
 //
 //    // Example sending a request using the OutputService12TestCaseOperation1Request method.
 //    req, resp := client.OutputService12TestCaseOperation1Request(params)

vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/build.go

@@ -131,7 +131,6 @@ func (b *xmlBuilder) buildStruct(value reflect.Value, current *XMLNode, tag refl
 			continue
 		}
 
-
 		mTag := field.Tag
 		if mTag.Get("location") != "" { // skip non-body members
 			continue

vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/unmarshal.go

@@ -15,7 +15,10 @@ import (
 // needs to match the shape of the XML expected to be decoded.
 // If the shape doesn't match unmarshaling will fail.
 func UnmarshalXML(v interface{}, d *xml.Decoder, wrapper string) error {
-	n, _ := XMLToStruct(d, nil)
+	n, err := XMLToStruct(d, nil)
+	if err != nil {
+		return err
+	}
 	if n.Children != nil {
 		for _, root := range n.Children {
 			for _, c := range root {
@@ -23,7 +26,7 @@ func UnmarshalXML(v interface{}, d *xml.Decoder, wrapper string) error {
 					c = wrappedChild[0] // pull out wrapped element
 				}
 
-				err := parse(reflect.ValueOf(v), c, "")
+				err = parse(reflect.ValueOf(v), c, "")
 				if err != nil {
 					if err == io.EOF {
 						return nil

vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/unmarshal_test.go

@@ -0,0 +1,142 @@
+package xmlutil
+
+import (
+	"encoding/xml"
+	"fmt"
+	"io"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awsutil"
+)
+
+type mockBody struct {
+	DoneErr error
+	Body    io.Reader
+}
+
+func (m *mockBody) Read(p []byte) (int, error) {
+	n, err := m.Body.Read(p)
+	if (n == 0 || err == io.EOF) && m.DoneErr != nil {
+		return n, m.DoneErr
+	}
+
+	return n, err
+}
+
+type mockOutput struct {
+	_       struct{}          `type:"structure"`
+	String  *string           `type:"string"`
+	Integer *int64            `type:"integer"`
+	Nested  *mockNestedStruct `type:"structure"`
+	List    []*mockListElem   `locationName:"List" locationNameList:"Elem" type:"list"`
+	Closed  *mockClosedTags   `type:"structure"`
+}
+type mockNestedStruct struct {
+	_            struct{} `type:"structure"`
+	NestedString *string  `type:"string"`
+	NestedInt    *int64   `type:"integer"`
+}
+type mockClosedTags struct {
+	_    struct{} `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"`
+	Attr *string  `locationName:"xsi:attrval" type:"string" xmlAttribute:"true"`
+}
+type mockListElem struct {
+	_          struct{}            `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"`
+	String     *string             `type:"string"`
+	NestedElem *mockNestedListElem `type:"structure"`
+}
+type mockNestedListElem struct {
+	_ struct{} `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"`
+
+	String *string `type:"string"`
+	Type   *string `locationName:"xsi:type" type:"string" xmlAttribute:"true"`
+}
+
+func TestUnmarshal(t *testing.T) {
+	const xmlBodyStr = `<?xml version="1.0" encoding="UTF-8"?>
+<MockResponse xmlns="http://xmlns.example.com">
+	<String>string value</String>
+	<Integer>123</Integer>
+	<Closed xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:attrval="attr value"/>
+	<Nested>
+		<NestedString>nested string value</NestedString>
+		<NestedInt>321</NestedInt>
+	</Nested>
+	<List>
+		<Elem>
+			<NestedElem xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="type">
+				<String>nested elem string value</String>
+			</NestedElem>
+			<String>elem string value</String>
+		</Elem>
+	</List>
+</MockResponse>`
+
+	expect := mockOutput{
+		String:  aws.String("string value"),
+		Integer: aws.Int64(123),
+		Closed: &mockClosedTags{
+			Attr: aws.String("attr value"),
+		},
+		Nested: &mockNestedStruct{
+			NestedString: aws.String("nested string value"),
+			NestedInt:    aws.Int64(321),
+		},
+		List: []*mockListElem{
+			{
+				String: aws.String("elem string value"),
+				NestedElem: &mockNestedListElem{
+					String: aws.String("nested elem string value"),
+					Type:   aws.String("type"),
+				},
+			},
+		},
+	}
+
+	actual := mockOutput{}
+	decoder := xml.NewDecoder(strings.NewReader(xmlBodyStr))
+	err := UnmarshalXML(&actual, decoder, "")
+	if err != nil {
+		t.Fatalf("expect no error, got %v", err)
+	}
+
+	if !reflect.DeepEqual(expect, actual) {
+		t.Errorf("expect unmarshal to match\nExpect: %s\nActual: %s",
+			awsutil.Prettify(expect), awsutil.Prettify(actual))
+	}
+}
+
+func TestUnmarshal_UnexpectedEOF(t *testing.T) {
+	const partialXMLBody = `<?xml version="1.0" encoding="UTF-8"?>
+	<First>first value</First>
+	<Second>Second val`
+
+	out := struct {
+		First  *string `locationName:"First" type:"string"`
+		Second *string `locationName:"Second" type:"string"`
+	}{}
+
+	expect := out
+	expect.First = aws.String("first")
+	expect.Second = aws.String("second")
+
+	expectErr := fmt.Errorf("expected read error")
+
+	body := &mockBody{
+		DoneErr: expectErr,
+		Body:    strings.NewReader(partialXMLBody),
+	}
+
+	decoder := xml.NewDecoder(body)
+	err := UnmarshalXML(&out, decoder, "")
+
+	if err == nil {
+		t.Fatalf("expect error, got none")
+	}
+	if e, a := expectErr, err; e != a {
+		t.Errorf("expect %v error in %v, but was not", e, a)
+	}
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/xml_to_struct.go

@@ -40,11 +40,16 @@ 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
+			if err == io.EOF {
+				break
+			} else {
+				return out, err
+			}
+		}
+
+		if tok == nil {
+			break
 		}
 
 		switch typed := tok.(type) {

vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/xml_to_struct_test.go

@@ -14,8 +14,21 @@ import (
 
 func TestUnmarshal(t *testing.T) {
 	xmlVal := []byte(`<?xml version="1.0" encoding="UTF-8"?>
-	<AccessControlPolicy xmlns="http://s3.amazonaws.com/doc/2006-03-01/"><Owner><ID>foo-id</ID><DisplayName>user</DisplayName></Owner><AccessControlList><Grant><Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="type"><ID>foo-id</ID><DisplayName>user</DisplayName></Grantee><Permission>FULL_CONTROL</Permission></Grant></AccessControlList><
-	/AccessControlPolicy>`)
+<AccessControlPolicy xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+	<Owner>
+		<ID>foo-id</ID>
+		<DisplayName>user</DisplayName>
+	</Owner>
+	<AccessControlList>
+		<Grant>
+		<Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="type">
+			<ID>foo-id</ID>
+			<DisplayName>user</DisplayName>
+		</Grantee>
+		<Permission>FULL_CONTROL</Permission>
+		</Grant>
+	</AccessControlList>
+</AccessControlPolicy>`)
 
 	var server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.Write(xmlVal)