Initial transfer of provider code

101 files changed, 37182 insertions, 0 deletions

diff --git a/vendor/github.com/aws/aws-sdk-go/LICENSE.txt b/vendor/github.com/aws/aws-sdk-go/LICENSE.txt
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/LICENSE.txt
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/vendor/github.com/aws/aws-sdk-go/NOTICE.txt b/vendor/github.com/aws/aws-sdk-go/NOTICE.txt
new file mode 100644
index 0000000..5f14d11
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/NOTICE.txt
@@ -0,0 +1,3 @@
+AWS SDK for Go
+Copyright 2015 Amazon.com, Inc. or its affiliates. All Rights Reserved. 
+Copyright 2014-2015 Stripe, Inc.
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/awserr/error.go b/vendor/github.com/aws/aws-sdk-go/aws/awserr/error.go
new file mode 100644
index 0000000..56fdfc2
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/awserr/error.go
@@ -0,0 +1,145 @@
+// Package awserr represents API error interface accessors for the SDK.
+package awserr
+
+// An Error wraps lower level errors with code, message and an original error.
+// The underlying concrete error type may also satisfy other interfaces which
+// can be to used to obtain more specific information about the error.
+//
+// Calling Error() or String() will always include the full information about
+// an error based on its underlying type.
+//
+// Example:
+//
+//     output, err := s3manage.Upload(svc, input, opts)
+//     if err != nil {
+//         if awsErr, ok := err.(awserr.Error); ok {
+//             // Get error details
+//             log.Println("Error:", awsErr.Code(), awsErr.Message())
+//
+//             // Prints out full error message, including original error if there was one.
+//             log.Println("Error:", awsErr.Error())
+//
+//             // Get original error
+//             if origErr := awsErr.OrigErr(); origErr != nil {
+//                 // operate on original error.
+//             }
+//         } else {
+//             fmt.Println(err.Error())
+//         }
+//     }
+//
+type Error interface {
+        // Satisfy the generic error interface.
+        error
+
+        // Returns the short phrase depicting the classification of the error.
+        Code() string
+
+        // Returns the error details message.
+        Message() string
+
+        // Returns the original error if one was set.  Nil is returned if not set.
+        OrigErr() error
+}
+
+// BatchError is a batch of errors which also wraps lower level errors with
+// code, message, and original errors. Calling Error() will include all errors
+// that occurred in the batch.
+//
+// Deprecated: Replaced with BatchedErrors. Only defined for backwards
+// compatibility.
+type BatchError interface {
+        // Satisfy the generic error interface.
+        error
+
+        // Returns the short phrase depicting the classification of the error.
+        Code() string
+
+        // Returns the error details message.
+        Message() string
+
+        // Returns the original error if one was set.  Nil is returned if not set.
+        OrigErrs() []error
+}
+
+// BatchedErrors is a batch of errors which also wraps lower level errors with
+// code, message, and original errors. Calling Error() will include all errors
+// that occurred in the batch.
+//
+// Replaces BatchError
+type BatchedErrors interface {
+        // Satisfy the base Error interface.
+        Error
+
+        // Returns the original error if one was set.  Nil is returned if not set.
+        OrigErrs() []error
+}
+
+// New returns an Error object described by the code, message, and origErr.
+//
+// If origErr satisfies the Error interface it will not be wrapped within a new
+// Error object and will instead be returned.
+func New(code, message string, origErr error) Error {
+        var errs []error
+        if origErr != nil {
+                errs = append(errs, origErr)
+        }
+        return newBaseError(code, message, errs)
+}
+
+// NewBatchError returns an BatchedErrors with a collection of errors as an
+// array of errors.
+func NewBatchError(code, message string, errs []error) BatchedErrors {
+        return newBaseError(code, message, errs)
+}
+
+// A RequestFailure is an interface to extract request failure information from
+// an Error such as the request ID of the failed request returned by a service.
+// RequestFailures may not always have a requestID value if the request failed
+// prior to reaching the service such as a connection error.
+//
+// Example:
+//
+//     output, err := s3manage.Upload(svc, input, opts)
+//     if err != nil {
+//         if reqerr, ok := err.(RequestFailure); ok {
+//             log.Println("Request failed", reqerr.Code(), reqerr.Message(), reqerr.RequestID())
+//         } else {
+//             log.Println("Error:", err.Error())
+//         }
+//     }
+//
+// Combined with awserr.Error:
+//
+//    output, err := s3manage.Upload(svc, input, opts)
+//    if err != nil {
+//        if awsErr, ok := err.(awserr.Error); ok {
+//            // Generic AWS Error with Code, Message, and original error (if any)
+//            fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
+//
+//            if reqErr, ok := err.(awserr.RequestFailure); ok {
+//                // A service error occurred
+//                fmt.Println(reqErr.StatusCode(), reqErr.RequestID())
+//            }
+//        } else {
+//            fmt.Println(err.Error())
+//        }
+//    }
+//
+type RequestFailure interface {
+        Error
+
+        // The status code of the HTTP response.
+        StatusCode() int
+
+        // The request ID returned by the service for a request failure. This will
+        // be empty if no request ID is available such as the request failed due
+        // to a connection error.
+        RequestID() string
+}
+
+// NewRequestFailure returns a new request error wrapper for the given Error
+// provided.
+func NewRequestFailure(err Error, statusCode int, reqID string) RequestFailure {
+        return newRequestError(err, statusCode, reqID)
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/awserr/types.go b/vendor/github.com/aws/aws-sdk-go/aws/awserr/types.go
new file mode 100644
index 0000000..0202a00
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/awserr/types.go
@@ -0,0 +1,194 @@
+package awserr
+
+import "fmt"
+
+// SprintError returns a string of the formatted error code.
+//
+// Both extra and origErr are optional.  If they are included their lines
+// will be added, but if they are not included their lines will be ignored.
+func SprintError(code, message, extra string, origErr error) string {
+        msg := fmt.Sprintf("%s: %s", code, message)
+        if extra != "" {
+                msg = fmt.Sprintf("%s\n\t%s", msg, extra)
+        }
+        if origErr != nil {
+                msg = fmt.Sprintf("%s\ncaused by: %s", msg, origErr.Error())
+        }
+        return msg
+}
+
+// A baseError wraps the code and message which defines an error. It also
+// can be used to wrap an original error object.
+//
+// Should be used as the root for errors satisfying the awserr.Error. Also
+// for any error which does not fit into a specific error wrapper type.
+type baseError struct {
+        // Classification of error
+        code string
+
+        // Detailed information about error
+        message string
+
+        // Optional original error this error is based off of. Allows building
+        // chained errors.
+        errs []error
+}
+
+// newBaseError returns an error object for the code, message, and errors.
+//
+// code is a short no whitespace phrase depicting the classification of
+// the error that is being created.
+//
+// message is the free flow string containing detailed information about the
+// error.
+//
+// origErrs is the error objects which will be nested under the new errors to
+// be returned.
+func newBaseError(code, message string, origErrs []error) *baseError {
+        b := &baseError{
+                code:    code,
+                message: message,
+                errs:    origErrs,
+        }
+
+        return b
+}
+
+// Error returns the string representation of the error.
+//
+// See ErrorWithExtra for formatting.
+//
+// Satisfies the error interface.
+func (b baseError) Error() string {
+        size := len(b.errs)
+        if size > 0 {
+                return SprintError(b.code, b.message, "", errorList(b.errs))
+        }
+
+        return SprintError(b.code, b.message, "", nil)
+}
+
+// String returns the string representation of the error.
+// Alias for Error to satisfy the stringer interface.
+func (b baseError) String() string {
+        return b.Error()
+}
+
+// Code returns the short phrase depicting the classification of the error.
+func (b baseError) Code() string {
+        return b.code
+}
+
+// Message returns the error details message.
+func (b baseError) Message() string {
+        return b.message
+}
+
+// OrigErr returns the original error if one was set. Nil is returned if no
+// error was set. This only returns the first element in the list. If the full
+// list is needed, use BatchedErrors.
+func (b baseError) OrigErr() error {
+        switch len(b.errs) {
+        case 0:
+                return nil
+        case 1:
+                return b.errs[0]
+        default:
+                if err, ok := b.errs[0].(Error); ok {
+                        return NewBatchError(err.Code(), err.Message(), b.errs[1:])
+                }
+                return NewBatchError("BatchedErrors",
+                        "multiple errors occurred", b.errs)
+        }
+}
+
+// OrigErrs returns the original errors if one was set. An empty slice is
+// returned if no error was set.
+func (b baseError) OrigErrs() []error {
+        return b.errs
+}
+
+// So that the Error interface type can be included as an anonymous field
+// in the requestError struct and not conflict with the error.Error() method.
+type awsError Error
+
+// A requestError wraps a request or service error.
+//
+// Composed of baseError for code, message, and original error.
+type requestError struct {
+        awsError
+        statusCode int
+        requestID  string
+}
+
+// newRequestError returns a wrapped error with additional information for
+// request status code, and service requestID.
+//
+// Should be used to wrap all request which involve service requests. Even if
+// the request failed without a service response, but had an HTTP status code
+// that may be meaningful.
+//
+// Also wraps original errors via the baseError.
+func newRequestError(err Error, statusCode int, requestID string) *requestError {
+        return &requestError{
+                awsError:   err,
+                statusCode: statusCode,
+                requestID:  requestID,
+        }
+}
+
+// Error returns the string representation of the error.
+// Satisfies the error interface.
+func (r requestError) Error() string {
+        extra := fmt.Sprintf("status code: %d, request id: %s",
+                r.statusCode, r.requestID)
+        return SprintError(r.Code(), r.Message(), extra, r.OrigErr())
+}
+
+// String returns the string representation of the error.
+// Alias for Error to satisfy the stringer interface.
+func (r requestError) String() string {
+        return r.Error()
+}
+
+// StatusCode returns the wrapped status code for the error
+func (r requestError) StatusCode() int {
+        return r.statusCode
+}
+
+// RequestID returns the wrapped requestID
+func (r requestError) RequestID() string {
+        return r.requestID
+}
+
+// OrigErrs returns the original errors if one was set. An empty slice is
+// returned if no error was set.
+func (r requestError) OrigErrs() []error {
+        if b, ok := r.awsError.(BatchedErrors); ok {
+                return b.OrigErrs()
+        }
+        return []error{r.OrigErr()}
+}
+
+// An error list that satisfies the golang interface
+type errorList []error
+
+// Error returns the string representation of the error.
+//
+// Satisfies the error interface.
+func (e errorList) Error() string {
+        msg := ""
+        // How do we want to handle the array size being zero
+        if size := len(e); size > 0 {
+                for i := 0; i < size; i++ {
+                        msg += fmt.Sprintf("%s", e[i].Error())
+                        // We check the next index to see if it is within the slice.
+                        // If it is, then we append a newline. We do this, because unit tests
+                        // could be broken with the additional '\n'
+                        if i+1 < size {
+                                msg += "\n"
+                        }
+                }
+        }
+        return msg
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/awsutil/copy.go b/vendor/github.com/aws/aws-sdk-go/aws/awsutil/copy.go
new file mode 100644
index 0000000..1a3d106
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/awsutil/copy.go
@@ -0,0 +1,108 @@
+package awsutil
+
+import (
+        "io"
+        "reflect"
+        "time"
+)
+
+// Copy deeply copies a src structure to dst. Useful for copying request and
+// response structures.
+//
+// Can copy between structs of different type, but will only copy fields which
+// are assignable, and exist in both structs. Fields which are not assignable,
+// or do not exist in both structs are ignored.
+func Copy(dst, src interface{}) {
+        dstval := reflect.ValueOf(dst)
+        if !dstval.IsValid() {
+                panic("Copy dst cannot be nil")
+        }
+
+        rcopy(dstval, reflect.ValueOf(src), true)
+}
+
+// CopyOf returns a copy of src while also allocating the memory for dst.
+// src must be a pointer type or this operation will fail.
+func CopyOf(src interface{}) (dst interface{}) {
+        dsti := reflect.New(reflect.TypeOf(src).Elem())
+        dst = dsti.Interface()
+        rcopy(dsti, reflect.ValueOf(src), true)
+        return
+}
+
+// rcopy performs a recursive copy of values from the source to destination.
+//
+// root is used to skip certain aspects of the copy which are not valid
+// for the root node of a object.
+func rcopy(dst, src reflect.Value, root bool) {
+        if !src.IsValid() {
+                return
+        }
+
+        switch src.Kind() {
+        case reflect.Ptr:
+                if _, ok := src.Interface().(io.Reader); ok {
+                        if dst.Kind() == reflect.Ptr && dst.Elem().CanSet() {
+                                dst.Elem().Set(src)
+                        } else if dst.CanSet() {
+                                dst.Set(src)
+                        }
+                } else {
+                        e := src.Type().Elem()
+                        if dst.CanSet() && !src.IsNil() {
+                                if _, ok := src.Interface().(*time.Time); !ok {
+                                        dst.Set(reflect.New(e))
+                                } else {
+                                        tempValue := reflect.New(e)
+                                        tempValue.Elem().Set(src.Elem())
+                                        // Sets time.Time's unexported values
+                                        dst.Set(tempValue)
+                                }
+                        }
+                        if src.Elem().IsValid() {
+                                // Keep the current root state since the depth hasn't changed
+                                rcopy(dst.Elem(), src.Elem(), root)
+                        }
+                }
+        case reflect.Struct:
+                t := dst.Type()
+                for i := 0; i < t.NumField(); i++ {
+                        name := t.Field(i).Name
+                        srcVal := src.FieldByName(name)
+                        dstVal := dst.FieldByName(name)
+                        if srcVal.IsValid() && dstVal.CanSet() {
+                                rcopy(dstVal, srcVal, false)
+                        }
+                }
+        case reflect.Slice:
+                if src.IsNil() {
+                        break
+                }
+
+                s := reflect.MakeSlice(src.Type(), src.Len(), src.Cap())
+                dst.Set(s)
+                for i := 0; i < src.Len(); i++ {
+                        rcopy(dst.Index(i), src.Index(i), false)
+                }
+        case reflect.Map:
+                if src.IsNil() {
+                        break
+                }
+
+                s := reflect.MakeMap(src.Type())
+                dst.Set(s)
+                for _, k := range src.MapKeys() {
+                        v := src.MapIndex(k)
+                        v2 := reflect.New(v.Type()).Elem()
+                        rcopy(v2, v, false)
+                        dst.SetMapIndex(k, v2)
+                }
+        default:
+                // Assign the value if possible. If its not assignable, the value would
+                // need to be converted and the impact of that may be unexpected, or is
+                // not compatible with the dst type.
+                if src.Type().AssignableTo(dst.Type()) {
+                        dst.Set(src)
+                }
+        }
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/awsutil/equal.go b/vendor/github.com/aws/aws-sdk-go/aws/awsutil/equal.go
new file mode 100644
index 0000000..59fa4a5
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/awsutil/equal.go
@@ -0,0 +1,27 @@
+package awsutil
+
+import (
+        "reflect"
+)
+
+// DeepEqual returns if the two values are deeply equal like reflect.DeepEqual.
+// In addition to this, this method will also dereference the input values if
+// possible so the DeepEqual performed will not fail if one parameter is a
+// pointer and the other is not.
+//
+// DeepEqual will not perform indirection of nested values of the input parameters.
+func DeepEqual(a, b interface{}) bool {
+        ra := reflect.Indirect(reflect.ValueOf(a))
+        rb := reflect.Indirect(reflect.ValueOf(b))
+
+        if raValid, rbValid := ra.IsValid(), rb.IsValid(); !raValid && !rbValid {
+                // If the elements are both nil, and of the same type the are equal
+                // If they are of different types they are not equal
+                return reflect.TypeOf(a) == reflect.TypeOf(b)
+        } else if raValid != rbValid {
+                // Both values must be valid to be equal
+                return false
+        }
+
+        return reflect.DeepEqual(ra.Interface(), rb.Interface())
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/awsutil/path_value.go b/vendor/github.com/aws/aws-sdk-go/aws/awsutil/path_value.go
new file mode 100644
index 0000000..11c52c3
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/awsutil/path_value.go
@@ -0,0 +1,222 @@
+package awsutil
+
+import (
+        "reflect"
+        "regexp"
+        "strconv"
+        "strings"
+
+        "github.com/jmespath/go-jmespath"
+)
+
+var indexRe = regexp.MustCompile(`(.+)\[(-?\d+)?\]$`)
+
+// rValuesAtPath returns a slice of values found in value v. The values
+// in v are explored recursively so all nested values are collected.
+func rValuesAtPath(v interface{}, path string, createPath, caseSensitive, nilTerm bool) []reflect.Value {
+        pathparts := strings.Split(path, "||")
+        if len(pathparts) > 1 {
+                for _, pathpart := range pathparts {
+                        vals := rValuesAtPath(v, pathpart, createPath, caseSensitive, nilTerm)
+                        if len(vals) > 0 {
+                                return vals
+                        }
+                }
+                return nil
+        }
+
+        values := []reflect.Value{reflect.Indirect(reflect.ValueOf(v))}
+        components := strings.Split(path, ".")
+        for len(values) > 0 && len(components) > 0 {
+                var index *int64
+                var indexStar bool
+                c := strings.TrimSpace(components[0])
+                if c == "" { // no actual component, illegal syntax
+                        return nil
+                } else if caseSensitive && c != "*" && strings.ToLower(c[0:1]) == c[0:1] {
+                        // TODO normalize case for user
+                        return nil // don't support unexported fields
+                }
+
+                // parse this component
+                if m := indexRe.FindStringSubmatch(c); m != nil {
+                        c = m[1]
+                        if m[2] == "" {
+                                index = nil
+                                indexStar = true
+                        } else {
+                                i, _ := strconv.ParseInt(m[2], 10, 32)
+                                index = &i
+                                indexStar = false
+                        }
+                }
+
+                nextvals := []reflect.Value{}
+                for _, value := range values {
+                        // pull component name out of struct member
+                        if value.Kind() != reflect.Struct {
+                                continue
+                        }
+
+                        if c == "*" { // pull all members
+                                for i := 0; i < value.NumField(); i++ {
+                                        if f := reflect.Indirect(value.Field(i)); f.IsValid() {
+                                                nextvals = append(nextvals, f)
+                                        }
+                                }
+                                continue
+                        }
+
+                        value = value.FieldByNameFunc(func(name string) bool {
+                                if c == name {
+                                        return true
+                                } else if !caseSensitive && strings.ToLower(name) == strings.ToLower(c) {
+                                        return true
+                                }
+                                return false
+                        })
+
+                        if nilTerm && value.Kind() == reflect.Ptr && len(components[1:]) == 0 {
+                                if !value.IsNil() {
+                                        value.Set(reflect.Zero(value.Type()))
+                                }
+                                return []reflect.Value{value}
+                        }
+
+                        if createPath && value.Kind() == reflect.Ptr && value.IsNil() {
+                                // TODO if the value is the terminus it should not be created
+                                // if the value to be set to its position is nil.
+                                value.Set(reflect.New(value.Type().Elem()))
+                                value = value.Elem()
+                        } else {
+                                value = reflect.Indirect(value)
+                        }
+
+                        if value.Kind() == reflect.Slice || value.Kind() == reflect.Map {
+                                if !createPath && value.IsNil() {
+                                        value = reflect.ValueOf(nil)
+                                }
+                        }
+
+                        if value.IsValid() {
+                                nextvals = append(nextvals, value)
+                        }
+                }
+                values = nextvals
+
+                if indexStar || index != nil {
+                        nextvals = []reflect.Value{}
+                        for _, valItem := range values {
+                                value := reflect.Indirect(valItem)
+                                if value.Kind() != reflect.Slice {
+                                        continue
+                                }
+
+                                if indexStar { // grab all indices
+                                        for i := 0; i < value.Len(); i++ {
+                                                idx := reflect.Indirect(value.Index(i))
+                                                if idx.IsValid() {
+                                                        nextvals = append(nextvals, idx)
+                                                }
+                                        }
+                                        continue
+                                }
+
+                                // pull out index
+                                i := int(*index)
+                                if i >= value.Len() { // check out of bounds
+                                        if createPath {
+                                                // TODO resize slice
+                                        } else {
+                                                continue
+                                        }
+                                } else if i < 0 { // support negative indexing
+                                        i = value.Len() + i
+                                }
+                                value = reflect.Indirect(value.Index(i))
+
+                                if value.Kind() == reflect.Slice || value.Kind() == reflect.Map {
+                                        if !createPath && value.IsNil() {
+                                                value = reflect.ValueOf(nil)
+                                        }
+                                }
+
+                                if value.IsValid() {
+                                        nextvals = append(nextvals, value)
+                                }
+                        }
+                        values = nextvals
+                }
+
+                components = components[1:]
+        }
+        return values
+}
+
+// ValuesAtPath returns a list of values at the case insensitive lexical
+// path inside of a structure.
+func ValuesAtPath(i interface{}, path string) ([]interface{}, error) {
+        result, err := jmespath.Search(path, i)
+        if err != nil {
+                return nil, err
+        }
+
+        v := reflect.ValueOf(result)
+        if !v.IsValid() || (v.Kind() == reflect.Ptr && v.IsNil()) {
+                return nil, nil
+        }
+        if s, ok := result.([]interface{}); ok {
+                return s, err
+        }
+        if v.Kind() == reflect.Map && v.Len() == 0 {
+                return nil, nil
+        }
+        if v.Kind() == reflect.Slice {
+                out := make([]interface{}, v.Len())
+                for i := 0; i < v.Len(); i++ {
+                        out[i] = v.Index(i).Interface()
+                }
+                return out, nil
+        }
+
+        return []interface{}{result}, nil
+}
+
+// SetValueAtPath sets a value at the case insensitive lexical path inside
+// of a structure.
+func SetValueAtPath(i interface{}, path string, v interface{}) {
+        if rvals := rValuesAtPath(i, path, true, false, v == nil); rvals != nil {
+                for _, rval := range rvals {
+                        if rval.Kind() == reflect.Ptr && rval.IsNil() {
+                                continue
+                        }
+                        setValue(rval, v)
+                }
+        }
+}
+
+func setValue(dstVal reflect.Value, src interface{}) {
+        if dstVal.Kind() == reflect.Ptr {
+                dstVal = reflect.Indirect(dstVal)
+        }
+        srcVal := reflect.ValueOf(src)
+
+        if !srcVal.IsValid() { // src is literal nil
+                if dstVal.CanAddr() {
+                        // Convert to pointer so that pointer's value can be nil'ed
+                        //                     dstVal = dstVal.Addr()
+                }
+                dstVal.Set(reflect.Zero(dstVal.Type()))
+
+        } else if srcVal.Kind() == reflect.Ptr {
+                if srcVal.IsNil() {
+                        srcVal = reflect.Zero(dstVal.Type())
+                } else {
+                        srcVal = reflect.ValueOf(src).Elem()
+                }
+                dstVal.Set(srcVal)
+        } else {
+                dstVal.Set(srcVal)
+        }
+
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/awsutil/prettify.go b/vendor/github.com/aws/aws-sdk-go/aws/awsutil/prettify.go
new file mode 100644
index 0000000..710eb43
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/awsutil/prettify.go
@@ -0,0 +1,113 @@
+package awsutil
+
+import (
+        "bytes"
+        "fmt"
+        "io"
+        "reflect"
+        "strings"
+)
+
+// Prettify returns the string representation of a value.
+func Prettify(i interface{}) string {
+        var buf bytes.Buffer
+        prettify(reflect.ValueOf(i), 0, &buf)
+        return buf.String()
+}
+
+// prettify will recursively walk value v to build a textual
+// representation of the value.
+func prettify(v reflect.Value, indent int, buf *bytes.Buffer) {
+        for v.Kind() == reflect.Ptr {
+                v = v.Elem()
+        }
+
+        switch v.Kind() {
+        case reflect.Struct:
+                strtype := v.Type().String()
+                if strtype == "time.Time" {
+                        fmt.Fprintf(buf, "%s", v.Interface())
+                        break
+                } else if strings.HasPrefix(strtype, "io.") {
+                        buf.WriteString("<buffer>")
+                        break
+                }
+
+                buf.WriteString("{\n")
+
+                names := []string{}
+                for i := 0; i < v.Type().NumField(); i++ {
+                        name := v.Type().Field(i).Name
+                        f := v.Field(i)
+                        if name[0:1] == strings.ToLower(name[0:1]) {
+                                continue // ignore unexported fields
+                        }
+                        if (f.Kind() == reflect.Ptr || f.Kind() == reflect.Slice || f.Kind() == reflect.Map) && f.IsNil() {
+                                continue // ignore unset fields
+                        }
+                        names = append(names, name)
+                }
+
+                for i, n := range names {
+                        val := v.FieldByName(n)
+                        buf.WriteString(strings.Repeat(" ", indent+2))
+                        buf.WriteString(n + ": ")
+                        prettify(val, indent+2, buf)
+
+                        if i < len(names)-1 {
+                                buf.WriteString(",\n")
+                        }
+                }
+
+                buf.WriteString("\n" + strings.Repeat(" ", indent) + "}")
+        case reflect.Slice:
+                strtype := v.Type().String()
+                if strtype == "[]uint8" {
+                        fmt.Fprintf(buf, "<binary> len %d", v.Len())
+                        break
+                }
+
+                nl, id, id2 := "", "", ""
+                if v.Len() > 3 {
+                        nl, id, id2 = "\n", strings.Repeat(" ", indent), strings.Repeat(" ", indent+2)
+                }
+                buf.WriteString("[" + nl)
+                for i := 0; i < v.Len(); i++ {
+                        buf.WriteString(id2)
+                        prettify(v.Index(i), indent+2, buf)
+
+                        if i < v.Len()-1 {
+                                buf.WriteString("," + nl)
+                        }
+                }
+
+                buf.WriteString(nl + id + "]")
+        case reflect.Map:
+                buf.WriteString("{\n")
+
+                for i, k := range v.MapKeys() {
+                        buf.WriteString(strings.Repeat(" ", indent+2))
+                        buf.WriteString(k.String() + ": ")
+                        prettify(v.MapIndex(k), indent+2, buf)
+
+                        if i < v.Len()-1 {
+                                buf.WriteString(",\n")
+                        }
+                }
+
+                buf.WriteString("\n" + strings.Repeat(" ", indent) + "}")
+        default:
+                if !v.IsValid() {
+                        fmt.Fprint(buf, "<invalid value>")
+                        return
+                }
+                format := "%v"
+                switch v.Interface().(type) {
+                case string:
+                        format = "%q"
+                case io.ReadSeeker, io.Reader:
+                        format = "buffer(%p)"
+                }
+                fmt.Fprintf(buf, format, v.Interface())
+        }
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/awsutil/string_value.go b/vendor/github.com/aws/aws-sdk-go/aws/awsutil/string_value.go
new file mode 100644
index 0000000..b6432f1
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/awsutil/string_value.go
@@ -0,0 +1,89 @@
+package awsutil
+
+import (
+        "bytes"
+        "fmt"
+        "reflect"
+        "strings"
+)
+
+// StringValue returns the string representation of a value.
+func StringValue(i interface{}) string {
+        var buf bytes.Buffer
+        stringValue(reflect.ValueOf(i), 0, &buf)
+        return buf.String()
+}
+
+func stringValue(v reflect.Value, indent int, buf *bytes.Buffer) {
+        for v.Kind() == reflect.Ptr {
+                v = v.Elem()
+        }
+
+        switch v.Kind() {
+        case reflect.Struct:
+                buf.WriteString("{\n")
+
+                names := []string{}
+                for i := 0; i < v.Type().NumField(); i++ {
+                        name := v.Type().Field(i).Name
+                        f := v.Field(i)
+                        if name[0:1] == strings.ToLower(name[0:1]) {
+                                continue // ignore unexported fields
+                        }
+                        if (f.Kind() == reflect.Ptr || f.Kind() == reflect.Slice) && f.IsNil() {
+                                continue // ignore unset fields
+                        }
+                        names = append(names, name)
+                }
+
+                for i, n := range names {
+                        val := v.FieldByName(n)
+                        buf.WriteString(strings.Repeat(" ", indent+2))
+                        buf.WriteString(n + ": ")
+                        stringValue(val, indent+2, buf)
+
+                        if i < len(names)-1 {
+                                buf.WriteString(",\n")
+                        }
+                }
+
+                buf.WriteString("\n" + strings.Repeat(" ", indent) + "}")
+        case reflect.Slice:
+                nl, id, id2 := "", "", ""
+                if v.Len() > 3 {
+                        nl, id, id2 = "\n", strings.Repeat(" ", indent), strings.Repeat(" ", indent+2)
+                }
+                buf.WriteString("[" + nl)
+                for i := 0; i < v.Len(); i++ {
+                        buf.WriteString(id2)
+                        stringValue(v.Index(i), indent+2, buf)
+
+                        if i < v.Len()-1 {
+                                buf.WriteString("," + nl)
+                        }
+                }
+
+                buf.WriteString(nl + id + "]")
+        case reflect.Map:
+                buf.WriteString("{\n")
+
+                for i, k := range v.MapKeys() {
+                        buf.WriteString(strings.Repeat(" ", indent+2))
+                        buf.WriteString(k.String() + ": ")
+                        stringValue(v.MapIndex(k), indent+2, buf)
+
+                        if i < v.Len()-1 {
+                                buf.WriteString(",\n")
+                        }
+                }
+
+                buf.WriteString("\n" + strings.Repeat(" ", indent) + "}")
+        default:
+                format := "%v"
+                switch v.Interface().(type) {
+                case string:
+                        format = "%q"
+                }
+                fmt.Fprintf(buf, format, v.Interface())
+        }
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/client/client.go b/vendor/github.com/aws/aws-sdk-go/aws/client/client.go
new file mode 100644
index 0000000..48b0fbd
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/client/client.go
@@ -0,0 +1,149 @@
+package client
+
+import (
+        "fmt"
+        "net/http/httputil"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/client/metadata"
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+// A Config provides configuration to a service client instance.
+type Config struct {
+        Config        *aws.Config
+        Handlers      request.Handlers
+        Endpoint      string
+        SigningRegion string
+        SigningName   string
+}
+
+// ConfigProvider provides a generic way for a service client to receive
+// the ClientConfig without circular dependencies.
+type ConfigProvider interface {
+        ClientConfig(serviceName string, cfgs ...*aws.Config) Config
+}
+
+// ConfigNoResolveEndpointProvider same as ConfigProvider except it will not
+// resolve the endpoint automatically. The service client's endpoint must be
+// provided via the aws.Config.Endpoint field.
+type ConfigNoResolveEndpointProvider interface {
+        ClientConfigNoResolveEndpoint(cfgs ...*aws.Config) Config
+}
+
+// A Client implements the base client request and response handling
+// used by all service clients.
+type Client struct {
+        request.Retryer
+        metadata.ClientInfo
+
+        Config   aws.Config
+        Handlers request.Handlers
+}
+
+// New will return a pointer to a new initialized service client.
+func New(cfg aws.Config, info metadata.ClientInfo, handlers request.Handlers, options ...func(*Client)) *Client {
+        svc := &Client{
+                Config:     cfg,
+                ClientInfo: info,
+                Handlers:   handlers.Copy(),
+        }
+
+        switch retryer, ok := cfg.Retryer.(request.Retryer); {
+        case ok:
+                svc.Retryer = retryer
+        case cfg.Retryer != nil && cfg.Logger != nil:
+                s := fmt.Sprintf("WARNING: %T does not implement request.Retryer; using DefaultRetryer instead", cfg.Retryer)
+                cfg.Logger.Log(s)
+                fallthrough
+        default:
+                maxRetries := aws.IntValue(cfg.MaxRetries)
+                if cfg.MaxRetries == nil || maxRetries == aws.UseServiceDefaultRetries {
+                        maxRetries = 3
+                }
+                svc.Retryer = DefaultRetryer{NumMaxRetries: maxRetries}
+        }
+
+        svc.AddDebugHandlers()
+
+        for _, option := range options {
+                option(svc)
+        }
+
+        return svc
+}
+
+// NewRequest returns a new Request pointer for the service API
+// operation and parameters.
+func (c *Client) NewRequest(operation *request.Operation, params interface{}, data interface{}) *request.Request {
+        return request.New(c.Config, c.ClientInfo, c.Handlers, c.Retryer, operation, params, data)
+}
+
+// AddDebugHandlers injects debug logging handlers into the service to log request
+// debug information.
+func (c *Client) AddDebugHandlers() {
+        if !c.Config.LogLevel.AtLeast(aws.LogDebug) {
+                return
+        }
+
+        c.Handlers.Send.PushFrontNamed(request.NamedHandler{Name: "awssdk.client.LogRequest", Fn: logRequest})
+        c.Handlers.Send.PushBackNamed(request.NamedHandler{Name: "awssdk.client.LogResponse", Fn: logResponse})
+}
+
+const logReqMsg = `DEBUG: Request %s/%s Details:
+---[ REQUEST POST-SIGN ]-----------------------------
+%s
+-----------------------------------------------------`
+
+const logReqErrMsg = `DEBUG ERROR: Request %s/%s:
+---[ REQUEST DUMP ERROR ]-----------------------------
+%s
+-----------------------------------------------------`
+
+func logRequest(r *request.Request) {
+        logBody := r.Config.LogLevel.Matches(aws.LogDebugWithHTTPBody)
+        dumpedBody, err := httputil.DumpRequestOut(r.HTTPRequest, logBody)
+        if err != nil {
+                r.Config.Logger.Log(fmt.Sprintf(logReqErrMsg, r.ClientInfo.ServiceName, r.Operation.Name, err))
+                r.Error = awserr.New(request.ErrCodeRead, "an error occurred during request body reading", err)
+                return
+        }
+
+        if logBody {
+                // Reset the request body because dumpRequest will re-wrap the r.HTTPRequest's
+                // Body as a NoOpCloser and will not be reset after read by the HTTP
+                // client reader.
+                r.ResetBody()
+        }
+
+        r.Config.Logger.Log(fmt.Sprintf(logReqMsg, r.ClientInfo.ServiceName, r.Operation.Name, string(dumpedBody)))
+}
+
+const logRespMsg = `DEBUG: Response %s/%s Details:
+---[ RESPONSE ]--------------------------------------
+%s
+-----------------------------------------------------`
+
+const logRespErrMsg = `DEBUG ERROR: Response %s/%s:
+---[ RESPONSE DUMP ERROR ]-----------------------------
+%s
+-----------------------------------------------------`
+
+func logResponse(r *request.Request) {
+        var msg = "no response data"
+        if r.HTTPResponse != nil {
+                logBody := r.Config.LogLevel.Matches(aws.LogDebugWithHTTPBody)
+                dumpedBody, err := httputil.DumpResponse(r.HTTPResponse, logBody)
+                if err != nil {
+                        r.Config.Logger.Log(fmt.Sprintf(logRespErrMsg, r.ClientInfo.ServiceName, r.Operation.Name, err))
+                        r.Error = awserr.New(request.ErrCodeRead, "an error occurred during response body reading", err)
+                        return
+                }
+
+                msg = string(dumpedBody)
+        } else if r.Error != nil {
+                msg = r.Error.Error()
+        }
+        r.Config.Logger.Log(fmt.Sprintf(logRespMsg, r.ClientInfo.ServiceName, r.Operation.Name, msg))
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/client/default_retryer.go b/vendor/github.com/aws/aws-sdk-go/aws/client/default_retryer.go
new file mode 100644
index 0000000..1313478
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/client/default_retryer.go
@@ -0,0 +1,96 @@
+package client
+
+import (
+        "math/rand"
+        "sync"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+// DefaultRetryer implements basic retry logic using exponential backoff for
+// most services. If you want to implement custom retry logic, implement the
+// request.Retryer interface or create a structure type that composes this
+// struct and override the specific methods. For example, to override only
+// the MaxRetries method:
+//
+//              type retryer struct {
+//      service.DefaultRetryer
+//    }
+//
+//    // This implementation always has 100 max retries
+//    func (d retryer) MaxRetries() uint { return 100 }
+type DefaultRetryer struct {
+        NumMaxRetries int
+}
+
+// MaxRetries returns the number of maximum returns the service will use to make
+// an individual API request.
+func (d DefaultRetryer) MaxRetries() int {
+        return d.NumMaxRetries
+}
+
+var seededRand = rand.New(&lockedSource{src: rand.NewSource(time.Now().UnixNano())})
+
+// RetryRules returns the delay duration before retrying this request again
+func (d DefaultRetryer) RetryRules(r *request.Request) time.Duration {
+        // Set the upper limit of delay in retrying at ~five minutes
+        minTime := 30
+        throttle := d.shouldThrottle(r)
+        if throttle {
+                minTime = 500
+        }
+
+        retryCount := r.RetryCount
+        if retryCount > 13 {
+                retryCount = 13
+        } else if throttle && retryCount > 8 {
+                retryCount = 8
+        }
+
+        delay := (1 << uint(retryCount)) * (seededRand.Intn(minTime) + minTime)
+        return time.Duration(delay) * time.Millisecond
+}
+
+// ShouldRetry returns true if the request should be retried.
+func (d DefaultRetryer) ShouldRetry(r *request.Request) bool {
+        // If one of the other handlers already set the retry state
+        // we don't want to override it based on the service's state
+        if r.Retryable != nil {
+                return *r.Retryable
+        }
+
+        if r.HTTPResponse.StatusCode >= 500 {
+                return true
+        }
+        return r.IsErrorRetryable() || d.shouldThrottle(r)
+}
+
+// ShouldThrottle returns true if the request should be throttled.
+func (d DefaultRetryer) shouldThrottle(r *request.Request) bool {
+        if r.HTTPResponse.StatusCode == 502 ||
+                r.HTTPResponse.StatusCode == 503 ||
+                r.HTTPResponse.StatusCode == 504 {
+                return true
+        }
+        return r.IsErrorThrottle()
+}
+
+// lockedSource is a thread-safe implementation of rand.Source
+type lockedSource struct {
+        lk  sync.Mutex
+        src rand.Source
+}
+
+func (r *lockedSource) Int63() (n int64) {
+        r.lk.Lock()
+        n = r.src.Int63()
+        r.lk.Unlock()
+        return
+}
+
+func (r *lockedSource) Seed(seed int64) {
+        r.lk.Lock()
+        r.src.Seed(seed)
+        r.lk.Unlock()
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/client/metadata/client_info.go b/vendor/github.com/aws/aws-sdk-go/aws/client/metadata/client_info.go
new file mode 100644
index 0000000..4778056
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/client/metadata/client_info.go
@@ -0,0 +1,12 @@
+package metadata
+
+// ClientInfo wraps immutable data from the client.Client structure.
+type ClientInfo struct {
+        ServiceName   string
+        APIVersion    string
+        Endpoint      string
+        SigningName   string
+        SigningRegion string
+        JSONVersion   string
+        TargetPrefix  string
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/config.go b/vendor/github.com/aws/aws-sdk-go/aws/config.go
new file mode 100644
index 0000000..d1f31f1
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/config.go
@@ -0,0 +1,470 @@
+package aws
+
+import (
+        "net/http"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws/credentials"
+        "github.com/aws/aws-sdk-go/aws/endpoints"
+)
+
+// UseServiceDefaultRetries instructs the config to use the service's own
+// default number of retries. This will be the default action if
+// Config.MaxRetries is nil also.
+const UseServiceDefaultRetries = -1
+
+// RequestRetryer is an alias for a type that implements the request.Retryer
+// interface.
+type RequestRetryer interface{}
+
+// A Config provides service configuration for service clients. By default,
+// all clients will use the defaults.DefaultConfig tructure.
+//
+//     // Create Session with MaxRetry configuration to be shared by multiple
+//     // service clients.
+//     sess := session.Must(session.NewSession(&aws.Config{
+//         MaxRetries: aws.Int(3),
+//     }))
+//
+//     // Create S3 service client with a specific Region.
+//     svc := s3.New(sess, &aws.Config{
+//         Region: aws.String("us-west-2"),
+//     })
+type Config struct {
+        // Enables verbose error printing of all credential chain errors.
+        // Should be used when wanting to see all errors while attempting to
+        // retrieve credentials.
+        CredentialsChainVerboseErrors *bool
+
+        // The credentials object to use when signing requests. Defaults to a
+        // chain of credential providers to search for credentials in environment
+        // variables, shared credential file, and EC2 Instance Roles.
+        Credentials *credentials.Credentials
+
+        // An optional endpoint URL (hostname only or fully qualified URI)
+        // that overrides the default generated endpoint for a client. Set this
+        // to `""` to use the default generated endpoint.
+        //
+        // @note You must still provide a `Region` value when specifying an
+        //   endpoint for a client.
+        Endpoint *string
+
+        // The resolver to use for looking up endpoints for AWS service clients
+        // to use based on region.
+        EndpointResolver endpoints.Resolver
+
+        // EnforceShouldRetryCheck is used in the AfterRetryHandler to always call
+        // ShouldRetry regardless of whether or not if request.Retryable is set.
+        // This will utilize ShouldRetry method of custom retryers. If EnforceShouldRetryCheck
+        // is not set, then ShouldRetry will only be called if request.Retryable is nil.
+        // Proper handling of the request.Retryable field is important when setting this field.
+        EnforceShouldRetryCheck *bool
+
+        // The region to send requests to. This parameter is required and must
+        // be configured globally or on a per-client basis unless otherwise
+        // noted. A full list of regions is found in the "Regions and Endpoints"
+        // document.
+        //
+        // @see http://docs.aws.amazon.com/general/latest/gr/rande.html
+        //   AWS Regions and Endpoints
+        Region *string
+
+        // Set this to `true` to disable SSL when sending requests. Defaults
+        // to `false`.
+        DisableSSL *bool
+
+        // The HTTP client to use when sending requests. Defaults to
+        // `http.DefaultClient`.
+        HTTPClient *http.Client
+
+        // An integer value representing the logging level. The default log level
+        // is zero (LogOff), which represents no logging. To enable logging set
+        // to a LogLevel Value.
+        LogLevel *LogLevelType
+
+        // The logger writer interface to write logging messages to. Defaults to
+        // standard out.
+        Logger Logger
+
+        // The maximum number of times that a request will be retried for failures.
+        // Defaults to -1, which defers the max retry setting to the service
+        // specific configuration.
+        MaxRetries *int
+
+        // Retryer guides how HTTP requests should be retried in case of
+        // recoverable failures.
+        //
+        // When nil or the value does not implement the request.Retryer interface,
+        // the request.DefaultRetryer will be used.
+        //
+        // When both Retryer and MaxRetries are non-nil, the former is used and
+        // the latter ignored.
+        //
+        // To set the Retryer field in a type-safe manner and with chaining, use
+        // the request.WithRetryer helper function:
+        //
+        //   cfg := request.WithRetryer(aws.NewConfig(), myRetryer)
+        //
+        Retryer RequestRetryer
+
+        // Disables semantic parameter validation, which validates input for
+        // missing required fields and/or other semantic request input errors.
+        DisableParamValidation *bool
+
+        // Disables the computation of request and response checksums, e.g.,
+        // CRC32 checksums in Amazon DynamoDB.
+        DisableComputeChecksums *bool
+
+        // Set this to `true` to force the request to use path-style addressing,
+        // i.e., `http://s3.amazonaws.com/BUCKET/KEY`. By default, the S3 client
+        // will use virtual hosted bucket addressing when possible
+        // (`http://BUCKET.s3.amazonaws.com/KEY`).
+        //
+        // @note This configuration option is specific to the Amazon S3 service.
+        // @see http://docs.aws.amazon.com/AmazonS3/latest/dev/VirtualHosting.html
+        //   Amazon S3: Virtual Hosting of Buckets
+        S3ForcePathStyle *bool
+
+        // Set this to `true` to disable the SDK adding the `Expect: 100-Continue`
+        // header to PUT requests over 2MB of content. 100-Continue instructs the
+        // HTTP client not to send the body until the service responds with a
+        // `continue` status. This is useful to prevent sending the request body
+        // until after the request is authenticated, and validated.
+        //
+        // http://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html
+        //
+        // 100-Continue is only enabled for Go 1.6 and above. See `http.Transport`'s
+        // `ExpectContinueTimeout` for information on adjusting the continue wait
+        // timeout. https://golang.org/pkg/net/http/#Transport
+        //
+        // You should use this flag to disble 100-Continue if you experience issues
+        // with proxies or third party S3 compatible services.
+        S3Disable100Continue *bool
+
+        // Set this to `true` to enable S3 Accelerate feature. For all operations
+        // compatible with S3 Accelerate will use the accelerate endpoint for
+        // requests. Requests not compatible will fall back to normal S3 requests.
+        //
+        // The bucket must be enable for accelerate to be used with S3 client with
+        // accelerate enabled. If the bucket is not enabled for accelerate an error
+        // will be returned. The bucket name must be DNS compatible to also work
+        // with accelerate.
+        S3UseAccelerate *bool
+
+        // Set this to `true` to disable the EC2Metadata client from overriding the
+        // default http.Client's Timeout. This is helpful if you do not want the
+        // EC2Metadata client to create a new http.Client. This options is only
+        // meaningful if you're not already using a custom HTTP client with the
+        // SDK. Enabled by default.
+        //
+        // Must be set and provided to the session.NewSession() in order to disable
+        // the EC2Metadata overriding the timeout for default credentials chain.
+        //
+        // Example:
+        //    sess := session.Must(session.NewSession(aws.NewConfig()
+        //       .WithEC2MetadataDiableTimeoutOverride(true)))
+        //
+        //    svc := s3.New(sess)
+        //
+        EC2MetadataDisableTimeoutOverride *bool
+
+        // Instructs the endpiont to be generated for a service client to
+        // be the dual stack endpoint. The dual stack endpoint will support
+        // both IPv4 and IPv6 addressing.
+        //
+        // Setting this for a service which does not support dual stack will fail
+        // to make requets. It is not recommended to set this value on the session
+        // as it will apply to all service clients created with the session. Even
+        // services which don't support dual stack endpoints.
+        //
+        // If the Endpoint config value is also provided the UseDualStack flag
+        // will be ignored.
+        //
+        // Only supported with.
+        //
+        //     sess := session.Must(session.NewSession())
+        //
+        //     svc := s3.New(sess, &aws.Config{
+        //         UseDualStack: aws.Bool(true),
+        //     })
+        UseDualStack *bool
+
+        // SleepDelay is an override for the func the SDK will call when sleeping
+        // during the lifecycle of a request. Specifically this will be used for
+        // request delays. This value should only be used for testing. To adjust
+        // the delay of a request see the aws/client.DefaultRetryer and
+        // aws/request.Retryer.
+        //
+        // SleepDelay will prevent any Context from being used for canceling retry
+        // delay of an API operation. It is recommended to not use SleepDelay at all
+        // and specify a Retryer instead.
+        SleepDelay func(time.Duration)
+
+        // DisableRestProtocolURICleaning will not clean the URL path when making rest protocol requests.
+        // Will default to false. This would only be used for empty directory names in s3 requests.
+        //
+        // Example:
+        //    sess := session.Must(session.NewSession(&aws.Config{
+        //         DisableRestProtocolURICleaning: aws.Bool(true),
+        //    }))
+        //
+        //    svc := s3.New(sess)
+        //    out, err := svc.GetObject(&s3.GetObjectInput {
+        //      Bucket: aws.String("bucketname"),
+        //      Key: aws.String("//foo//bar//moo"),
+        //    })
+        DisableRestProtocolURICleaning *bool
+}
+
+// NewConfig returns a new Config pointer that can be chained with builder
+// methods to set multiple configuration values inline without using pointers.
+//
+//     // Create Session with MaxRetry configuration to be shared by multiple
+//     // service clients.
+//     sess := session.Must(session.NewSession(aws.NewConfig().
+//         WithMaxRetries(3),
+//     ))
+//
+//     // Create S3 service client with a specific Region.
+//     svc := s3.New(sess, aws.NewConfig().
+//         WithRegion("us-west-2"),
+//     )
+func NewConfig() *Config {
+        return &Config{}
+}
+
+// WithCredentialsChainVerboseErrors sets a config verbose errors boolean and returning
+// a Config pointer.
+func (c *Config) WithCredentialsChainVerboseErrors(verboseErrs bool) *Config {
+        c.CredentialsChainVerboseErrors = &verboseErrs
+        return c
+}
+
+// WithCredentials sets a config Credentials value returning a Config pointer
+// for chaining.
+func (c *Config) WithCredentials(creds *credentials.Credentials) *Config {
+        c.Credentials = creds
+        return c
+}
+
+// WithEndpoint sets a config Endpoint value returning a Config pointer for
+// chaining.
+func (c *Config) WithEndpoint(endpoint string) *Config {
+        c.Endpoint = &endpoint
+        return c
+}
+
+// WithEndpointResolver sets a config EndpointResolver value returning a
+// Config pointer for chaining.
+func (c *Config) WithEndpointResolver(resolver endpoints.Resolver) *Config {
+        c.EndpointResolver = resolver
+        return c
+}
+
+// WithRegion sets a config Region value returning a Config pointer for
+// chaining.
+func (c *Config) WithRegion(region string) *Config {
+        c.Region = &region
+        return c
+}
+
+// WithDisableSSL sets a config DisableSSL value returning a Config pointer
+// for chaining.
+func (c *Config) WithDisableSSL(disable bool) *Config {
+        c.DisableSSL = &disable
+        return c
+}
+
+// WithHTTPClient sets a config HTTPClient value returning a Config pointer
+// for chaining.
+func (c *Config) WithHTTPClient(client *http.Client) *Config {
+        c.HTTPClient = client
+        return c
+}
+
+// WithMaxRetries sets a config MaxRetries value returning a Config pointer
+// for chaining.
+func (c *Config) WithMaxRetries(max int) *Config {
+        c.MaxRetries = &max
+        return c
+}
+
+// WithDisableParamValidation sets a config DisableParamValidation value
+// returning a Config pointer for chaining.
+func (c *Config) WithDisableParamValidation(disable bool) *Config {
+        c.DisableParamValidation = &disable
+        return c
+}
+
+// WithDisableComputeChecksums sets a config DisableComputeChecksums value
+// returning a Config pointer for chaining.
+func (c *Config) WithDisableComputeChecksums(disable bool) *Config {
+        c.DisableComputeChecksums = &disable
+        return c
+}
+
+// WithLogLevel sets a config LogLevel value returning a Config pointer for
+// chaining.
+func (c *Config) WithLogLevel(level LogLevelType) *Config {
+        c.LogLevel = &level
+        return c
+}
+
+// WithLogger sets a config Logger value returning a Config pointer for
+// chaining.
+func (c *Config) WithLogger(logger Logger) *Config {
+        c.Logger = logger
+        return c
+}
+
+// WithS3ForcePathStyle sets a config S3ForcePathStyle value returning a Config
+// pointer for chaining.
+func (c *Config) WithS3ForcePathStyle(force bool) *Config {
+        c.S3ForcePathStyle = &force
+        return c
+}
+
+// WithS3Disable100Continue sets a config S3Disable100Continue value returning
+// a Config pointer for chaining.
+func (c *Config) WithS3Disable100Continue(disable bool) *Config {
+        c.S3Disable100Continue = &disable
+        return c
+}
+
+// WithS3UseAccelerate sets a config S3UseAccelerate value returning a Config
+// pointer for chaining.
+func (c *Config) WithS3UseAccelerate(enable bool) *Config {
+        c.S3UseAccelerate = &enable
+        return c
+}
+
+// WithUseDualStack sets a config UseDualStack value returning a Config
+// pointer for chaining.
+func (c *Config) WithUseDualStack(enable bool) *Config {
+        c.UseDualStack = &enable
+        return c
+}
+
+// WithEC2MetadataDisableTimeoutOverride sets a config EC2MetadataDisableTimeoutOverride value
+// returning a Config pointer for chaining.
+func (c *Config) WithEC2MetadataDisableTimeoutOverride(enable bool) *Config {
+        c.EC2MetadataDisableTimeoutOverride = &enable
+        return c
+}
+
+// WithSleepDelay overrides the function used to sleep while waiting for the
+// next retry. Defaults to time.Sleep.
+func (c *Config) WithSleepDelay(fn func(time.Duration)) *Config {
+        c.SleepDelay = fn
+        return c
+}
+
+// MergeIn merges the passed in configs into the existing config object.
+func (c *Config) MergeIn(cfgs ...*Config) {
+        for _, other := range cfgs {
+                mergeInConfig(c, other)
+        }
+}
+
+func mergeInConfig(dst *Config, other *Config) {
+        if other == nil {
+                return
+        }
+
+        if other.CredentialsChainVerboseErrors != nil {
+                dst.CredentialsChainVerboseErrors = other.CredentialsChainVerboseErrors
+        }
+
+        if other.Credentials != nil {
+                dst.Credentials = other.Credentials
+        }
+
+        if other.Endpoint != nil {
+                dst.Endpoint = other.Endpoint
+        }
+
+        if other.EndpointResolver != nil {
+                dst.EndpointResolver = other.EndpointResolver
+        }
+
+        if other.Region != nil {
+                dst.Region = other.Region
+        }
+
+        if other.DisableSSL != nil {
+                dst.DisableSSL = other.DisableSSL
+        }
+
+        if other.HTTPClient != nil {
+                dst.HTTPClient = other.HTTPClient
+        }
+
+        if other.LogLevel != nil {
+                dst.LogLevel = other.LogLevel
+        }
+
+        if other.Logger != nil {
+                dst.Logger = other.Logger
+        }
+
+        if other.MaxRetries != nil {
+                dst.MaxRetries = other.MaxRetries
+        }
+
+        if other.Retryer != nil {
+                dst.Retryer = other.Retryer
+        }
+
+        if other.DisableParamValidation != nil {
+                dst.DisableParamValidation = other.DisableParamValidation
+        }
+
+        if other.DisableComputeChecksums != nil {
+                dst.DisableComputeChecksums = other.DisableComputeChecksums
+        }
+
+        if other.S3ForcePathStyle != nil {
+                dst.S3ForcePathStyle = other.S3ForcePathStyle
+        }
+
+        if other.S3Disable100Continue != nil {
+                dst.S3Disable100Continue = other.S3Disable100Continue
+        }
+
+        if other.S3UseAccelerate != nil {
+                dst.S3UseAccelerate = other.S3UseAccelerate
+        }
+
+        if other.UseDualStack != nil {
+                dst.UseDualStack = other.UseDualStack
+        }
+
+        if other.EC2MetadataDisableTimeoutOverride != nil {
+                dst.EC2MetadataDisableTimeoutOverride = other.EC2MetadataDisableTimeoutOverride
+        }
+
+        if other.SleepDelay != nil {
+                dst.SleepDelay = other.SleepDelay
+        }
+
+        if other.DisableRestProtocolURICleaning != nil {
+                dst.DisableRestProtocolURICleaning = other.DisableRestProtocolURICleaning
+        }
+
+        if other.EnforceShouldRetryCheck != nil {
+                dst.EnforceShouldRetryCheck = other.EnforceShouldRetryCheck
+        }
+}
+
+// Copy will return a shallow copy of the Config object. If any additional
+// configurations are provided they will be merged into the new config returned.
+func (c *Config) Copy(cfgs ...*Config) *Config {
+        dst := &Config{}
+        dst.MergeIn(c)
+
+        for _, cfg := range cfgs {
+                dst.MergeIn(cfg)
+        }
+
+        return dst
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/context.go b/vendor/github.com/aws/aws-sdk-go/aws/context.go
new file mode 100644
index 0000000..79f4268
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/context.go
@@ -0,0 +1,71 @@
+package aws
+
+import (
+        "time"
+)
+
+// Context is an copy of the Go v1.7 stdlib's context.Context interface.
+// It is represented as a SDK interface to enable you to use the "WithContext"
+// API methods with Go v1.6 and a Context type such as golang.org/x/net/context.
+//
+// See https://golang.org/pkg/context on how to use contexts.
+type Context interface {
+        // Deadline returns the time when work done on behalf of this context
+        // should be canceled. Deadline returns ok==false when no deadline is
+        // set. Successive calls to Deadline return the same results.
+        Deadline() (deadline time.Time, ok bool)
+
+        // Done returns a channel that's closed when work done on behalf of this
+        // context should be canceled. Done may return nil if this context can
+        // never be canceled. Successive calls to Done return the same value.
+        Done() <-chan struct{}
+
+        // Err returns a non-nil error value after Done is closed. Err returns
+        // Canceled if the context was canceled or DeadlineExceeded if the
+        // context's deadline passed. No other values for Err are defined.
+        // After Done is closed, successive calls to Err return the same value.
+        Err() error
+
+        // Value returns the value associated with this context for key, or nil
+        // if no value is associated with key. Successive calls to Value with
+        // the same key returns the same result.
+        //
+        // Use context values only for request-scoped data that transits
+        // processes and API boundaries, not for passing optional parameters to
+        // functions.
+        Value(key interface{}) interface{}
+}
+
+// BackgroundContext returns a context that will never be canceled, has no
+// values, and no deadline. This context is used by the SDK to provide
+// backwards compatibility with non-context API operations and functionality.
+//
+// Go 1.6 and before:
+// This context function is equivalent to context.Background in the Go stdlib.
+//
+// Go 1.7 and later:
+// The context returned will be the value returned by context.Background()
+//
+// See https://golang.org/pkg/context for more information on Contexts.
+func BackgroundContext() Context {
+        return backgroundCtx
+}
+
+// SleepWithContext will wait for the timer duration to expire, or the context
+// is canceled. Which ever happens first. If the context is canceled the Context's
+// error will be returned.
+//
+// Expects Context to always return a non-nil error if the Done channel is closed.
+func SleepWithContext(ctx Context, dur time.Duration) error {
+        t := time.NewTimer(dur)
+        defer t.Stop()
+
+        select {
+        case <-t.C:
+                break
+        case <-ctx.Done():
+                return ctx.Err()
+        }
+
+        return nil
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/context_1_6.go b/vendor/github.com/aws/aws-sdk-go/aws/context_1_6.go
new file mode 100644
index 0000000..e8cf93d
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/context_1_6.go
@@ -0,0 +1,41 @@
+// +build !go1.7
+
+package aws
+
+import "time"
+
+// An emptyCtx is a copy of the the Go 1.7 context.emptyCtx type. This
+// is copied to provide a 1.6 and 1.5 safe version of context that is compatible
+// with Go 1.7's Context.
+//
+// An emptyCtx is never canceled, has no values, and has no deadline. It is not
+// struct{}, since vars of this type must have distinct addresses.
+type emptyCtx int
+
+func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {
+        return
+}
+
+func (*emptyCtx) Done() <-chan struct{} {
+        return nil
+}
+
+func (*emptyCtx) Err() error {
+        return nil
+}
+
+func (*emptyCtx) Value(key interface{}) interface{} {
+        return nil
+}
+
+func (e *emptyCtx) String() string {
+        switch e {
+        case backgroundCtx:
+                return "aws.BackgroundContext"
+        }
+        return "unknown empty Context"
+}
+
+var (
+        backgroundCtx = new(emptyCtx)
+)
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/context_1_7.go b/vendor/github.com/aws/aws-sdk-go/aws/context_1_7.go
new file mode 100644
index 0000000..064f75c
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/context_1_7.go
@@ -0,0 +1,9 @@
+// +build go1.7
+
+package aws
+
+import "context"
+
+var (
+        backgroundCtx = context.Background()
+)
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/convert_types.go b/vendor/github.com/aws/aws-sdk-go/aws/convert_types.go
new file mode 100644
index 0000000..3b73a7d
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/convert_types.go
@@ -0,0 +1,369 @@
+package aws
+
+import "time"
+
+// String returns a pointer to the string value passed in.
+func String(v string) *string {
+        return &v
+}
+
+// StringValue returns the value of the string pointer passed in or
+// "" if the pointer is nil.
+func StringValue(v *string) string {
+        if v != nil {
+                return *v
+        }
+        return ""
+}
+
+// StringSlice converts a slice of string values into a slice of
+// string pointers
+func StringSlice(src []string) []*string {
+        dst := make([]*string, len(src))
+        for i := 0; i < len(src); i++ {
+                dst[i] = &(src[i])
+        }
+        return dst
+}
+
+// StringValueSlice converts a slice of string pointers into a slice of
+// string values
+func StringValueSlice(src []*string) []string {
+        dst := make([]string, len(src))
+        for i := 0; i < len(src); i++ {
+                if src[i] != nil {
+                        dst[i] = *(src[i])
+                }
+        }
+        return dst
+}
+
+// StringMap converts a string map of string values into a string
+// map of string pointers
+func StringMap(src map[string]string) map[string]*string {
+        dst := make(map[string]*string)
+        for k, val := range src {
+                v := val
+                dst[k] = &v
+        }
+        return dst
+}
+
+// StringValueMap converts a string map of string pointers into a string
+// map of string values
+func StringValueMap(src map[string]*string) map[string]string {
+        dst := make(map[string]string)
+        for k, val := range src {
+                if val != nil {
+                        dst[k] = *val
+                }
+        }
+        return dst
+}
+
+// Bool returns a pointer to the bool value passed in.
+func Bool(v bool) *bool {
+        return &v
+}
+
+// BoolValue returns the value of the bool pointer passed in or
+// false if the pointer is nil.
+func BoolValue(v *bool) bool {
+        if v != nil {
+                return *v
+        }
+        return false
+}
+
+// BoolSlice converts a slice of bool values into a slice of
+// bool pointers
+func BoolSlice(src []bool) []*bool {
+        dst := make([]*bool, len(src))
+        for i := 0; i < len(src); i++ {
+                dst[i] = &(src[i])
+        }
+        return dst
+}
+
+// BoolValueSlice converts a slice of bool pointers into a slice of
+// bool values
+func BoolValueSlice(src []*bool) []bool {
+        dst := make([]bool, len(src))
+        for i := 0; i < len(src); i++ {
+                if src[i] != nil {
+                        dst[i] = *(src[i])
+                }
+        }
+        return dst
+}
+
+// BoolMap converts a string map of bool values into a string
+// map of bool pointers
+func BoolMap(src map[string]bool) map[string]*bool {
+        dst := make(map[string]*bool)
+        for k, val := range src {
+                v := val
+                dst[k] = &v
+        }
+        return dst
+}
+
+// BoolValueMap converts a string map of bool pointers into a string
+// map of bool values
+func BoolValueMap(src map[string]*bool) map[string]bool {
+        dst := make(map[string]bool)
+        for k, val := range src {
+                if val != nil {
+                        dst[k] = *val
+                }
+        }
+        return dst
+}
+
+// Int returns a pointer to the int value passed in.
+func Int(v int) *int {
+        return &v
+}
+
+// IntValue returns the value of the int pointer passed in or
+// 0 if the pointer is nil.
+func IntValue(v *int) int {
+        if v != nil {
+                return *v
+        }
+        return 0
+}
+
+// IntSlice converts a slice of int values into a slice of
+// int pointers
+func IntSlice(src []int) []*int {
+        dst := make([]*int, len(src))
+        for i := 0; i < len(src); i++ {
+                dst[i] = &(src[i])
+        }
+        return dst
+}
+
+// IntValueSlice converts a slice of int pointers into a slice of
+// int values
+func IntValueSlice(src []*int) []int {
+        dst := make([]int, len(src))
+        for i := 0; i < len(src); i++ {
+                if src[i] != nil {
+                        dst[i] = *(src[i])
+                }
+        }
+        return dst
+}
+
+// IntMap converts a string map of int values into a string
+// map of int pointers
+func IntMap(src map[string]int) map[string]*int {
+        dst := make(map[string]*int)
+        for k, val := range src {
+                v := val
+                dst[k] = &v
+        }
+        return dst
+}
+
+// IntValueMap converts a string map of int pointers into a string
+// map of int values
+func IntValueMap(src map[string]*int) map[string]int {
+        dst := make(map[string]int)
+        for k, val := range src {
+                if val != nil {
+                        dst[k] = *val
+                }
+        }
+        return dst
+}
+
+// Int64 returns a pointer to the int64 value passed in.
+func Int64(v int64) *int64 {
+        return &v
+}
+
+// Int64Value returns the value of the int64 pointer passed in or
+// 0 if the pointer is nil.
+func Int64Value(v *int64) int64 {
+        if v != nil {
+                return *v
+        }
+        return 0
+}
+
+// Int64Slice converts a slice of int64 values into a slice of
+// int64 pointers
+func Int64Slice(src []int64) []*int64 {
+        dst := make([]*int64, len(src))
+        for i := 0; i < len(src); i++ {
+                dst[i] = &(src[i])
+        }
+        return dst
+}
+
+// Int64ValueSlice converts a slice of int64 pointers into a slice of
+// int64 values
+func Int64ValueSlice(src []*int64) []int64 {
+        dst := make([]int64, len(src))
+        for i := 0; i < len(src); i++ {
+                if src[i] != nil {
+                        dst[i] = *(src[i])
+                }
+        }
+        return dst
+}
+
+// Int64Map converts a string map of int64 values into a string
+// map of int64 pointers
+func Int64Map(src map[string]int64) map[string]*int64 {
+        dst := make(map[string]*int64)
+        for k, val := range src {
+                v := val
+                dst[k] = &v
+        }
+        return dst
+}
+
+// Int64ValueMap converts a string map of int64 pointers into a string
+// map of int64 values
+func Int64ValueMap(src map[string]*int64) map[string]int64 {
+        dst := make(map[string]int64)
+        for k, val := range src {
+                if val != nil {
+                        dst[k] = *val
+                }
+        }
+        return dst
+}
+
+// Float64 returns a pointer to the float64 value passed in.
+func Float64(v float64) *float64 {
+        return &v
+}
+
+// Float64Value returns the value of the float64 pointer passed in or
+// 0 if the pointer is nil.
+func Float64Value(v *float64) float64 {
+        if v != nil {
+                return *v
+        }
+        return 0
+}
+
+// Float64Slice converts a slice of float64 values into a slice of
+// float64 pointers
+func Float64Slice(src []float64) []*float64 {
+        dst := make([]*float64, len(src))
+        for i := 0; i < len(src); i++ {
+                dst[i] = &(src[i])
+        }
+        return dst
+}
+
+// Float64ValueSlice converts a slice of float64 pointers into a slice of
+// float64 values
+func Float64ValueSlice(src []*float64) []float64 {
+        dst := make([]float64, len(src))
+        for i := 0; i < len(src); i++ {
+                if src[i] != nil {
+                        dst[i] = *(src[i])
+                }
+        }
+        return dst
+}
+
+// Float64Map converts a string map of float64 values into a string
+// map of float64 pointers
+func Float64Map(src map[string]float64) map[string]*float64 {
+        dst := make(map[string]*float64)
+        for k, val := range src {
+                v := val
+                dst[k] = &v
+        }
+        return dst
+}
+
+// Float64ValueMap converts a string map of float64 pointers into a string
+// map of float64 values
+func Float64ValueMap(src map[string]*float64) map[string]float64 {
+        dst := make(map[string]float64)
+        for k, val := range src {
+                if val != nil {
+                        dst[k] = *val
+                }
+        }
+        return dst
+}
+
+// Time returns a pointer to the time.Time value passed in.
+func Time(v time.Time) *time.Time {
+        return &v
+}
+
+// TimeValue returns the value of the time.Time pointer passed in or
+// time.Time{} if the pointer is nil.
+func TimeValue(v *time.Time) time.Time {
+        if v != nil {
+                return *v
+        }
+        return time.Time{}
+}
+
+// TimeUnixMilli returns a Unix timestamp in milliseconds from "January 1, 1970 UTC".
+// The result is undefined if the Unix time cannot be represented by an int64.
+// Which includes calling TimeUnixMilli on a zero Time is undefined.
+//
+// This utility is useful for service API's such as CloudWatch Logs which require
+// their unix time values to be in milliseconds.
+//
+// See Go stdlib https://golang.org/pkg/time/#Time.UnixNano for more information.
+func TimeUnixMilli(t time.Time) int64 {
+        return t.UnixNano() / int64(time.Millisecond/time.Nanosecond)
+}
+
+// TimeSlice converts a slice of time.Time values into a slice of
+// time.Time pointers
+func TimeSlice(src []time.Time) []*time.Time {
+        dst := make([]*time.Time, len(src))
+        for i := 0; i < len(src); i++ {
+                dst[i] = &(src[i])
+        }
+        return dst
+}
+
+// TimeValueSlice converts a slice of time.Time pointers into a slice of
+// time.Time values
+func TimeValueSlice(src []*time.Time) []time.Time {
+        dst := make([]time.Time, len(src))
+        for i := 0; i < len(src); i++ {
+                if src[i] != nil {
+                        dst[i] = *(src[i])
+                }
+        }
+        return dst
+}
+
+// TimeMap converts a string map of time.Time values into a string
+// map of time.Time pointers
+func TimeMap(src map[string]time.Time) map[string]*time.Time {
+        dst := make(map[string]*time.Time)
+        for k, val := range src {
+                v := val
+                dst[k] = &v
+        }
+        return dst
+}
+
+// TimeValueMap converts a string map of time.Time pointers into a string
+// map of time.Time values
+func TimeValueMap(src map[string]*time.Time) map[string]time.Time {
+        dst := make(map[string]time.Time)
+        for k, val := range src {
+                if val != nil {
+                        dst[k] = *val
+                }
+        }
+        return dst
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/corehandlers/handlers.go b/vendor/github.com/aws/aws-sdk-go/aws/corehandlers/handlers.go
new file mode 100644
index 0000000..25b461c
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/corehandlers/handlers.go
@@ -0,0 +1,226 @@
+package corehandlers
+
+import (
+        "bytes"
+        "fmt"
+        "io"
+        "io/ioutil"
+        "net/http"
+        "net/url"
+        "regexp"
+        "runtime"
+        "strconv"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/credentials"
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+// Interface for matching types which also have a Len method.
+type lener interface {
+        Len() int
+}
+
+// BuildContentLengthHandler builds the content length of a request based on the body,
+// or will use the HTTPRequest.Header's "Content-Length" if defined. If unable
+// to determine request body length and no "Content-Length" was specified it will panic.
+//
+// The Content-Length will only be added to the request if the length of the body
+// is greater than 0. If the body is empty or the current `Content-Length`
+// header is <= 0, the header will also be stripped.
+var BuildContentLengthHandler = request.NamedHandler{Name: "core.BuildContentLengthHandler", Fn: func(r *request.Request) {
+        var length int64
+
+        if slength := r.HTTPRequest.Header.Get("Content-Length"); slength != "" {
+                length, _ = strconv.ParseInt(slength, 10, 64)
+        } else {
+                switch body := r.Body.(type) {
+                case nil:
+                        length = 0
+                case lener:
+                        length = int64(body.Len())
+                case io.Seeker:
+                        r.BodyStart, _ = body.Seek(0, 1)
+                        end, _ := body.Seek(0, 2)
+                        body.Seek(r.BodyStart, 0) // make sure to seek back to original location
+                        length = end - r.BodyStart
+                default:
+                        panic("Cannot get length of body, must provide `ContentLength`")
+                }
+        }
+
+        if length > 0 {
+                r.HTTPRequest.ContentLength = length
+                r.HTTPRequest.Header.Set("Content-Length", fmt.Sprintf("%d", length))
+        } else {
+                r.HTTPRequest.ContentLength = 0
+                r.HTTPRequest.Header.Del("Content-Length")
+        }
+}}
+
+// SDKVersionUserAgentHandler is a request handler for adding the SDK Version to the user agent.
+var SDKVersionUserAgentHandler = request.NamedHandler{
+        Name: "core.SDKVersionUserAgentHandler",
+        Fn: request.MakeAddToUserAgentHandler(aws.SDKName, aws.SDKVersion,
+                runtime.Version(), runtime.GOOS, runtime.GOARCH),
+}
+
+var reStatusCode = regexp.MustCompile(`^(\d{3})`)
+
+// ValidateReqSigHandler is a request handler to ensure that the request's
+// signature doesn't expire before it is sent. This can happen when a request
+// is built and signed significantly before it is sent. Or significant delays
+// occur when retrying requests that would cause the signature to expire.
+var ValidateReqSigHandler = request.NamedHandler{
+        Name: "core.ValidateReqSigHandler",
+        Fn: func(r *request.Request) {
+                // Unsigned requests are not signed
+                if r.Config.Credentials == credentials.AnonymousCredentials {
+                        return
+                }
+
+                signedTime := r.Time
+                if !r.LastSignedAt.IsZero() {
+                        signedTime = r.LastSignedAt
+                }
+
+                // 10 minutes to allow for some clock skew/delays in transmission.
+                // Would be improved with aws/aws-sdk-go#423
+                if signedTime.Add(10 * time.Minute).After(time.Now()) {
+                        return
+                }
+
+                fmt.Println("request expired, resigning")
+                r.Sign()
+        },
+}
+
+// SendHandler is a request handler to send service request using HTTP client.
+var SendHandler = request.NamedHandler{
+        Name: "core.SendHandler",
+        Fn: func(r *request.Request) {
+                sender := sendFollowRedirects
+                if r.DisableFollowRedirects {
+                        sender = sendWithoutFollowRedirects
+                }
+
+                var err error
+                r.HTTPResponse, err = sender(r)
+                if err != nil {
+                        handleSendError(r, err)
+                }
+        },
+}
+
+func sendFollowRedirects(r *request.Request) (*http.Response, error) {
+        return r.Config.HTTPClient.Do(r.HTTPRequest)
+}
+
+func sendWithoutFollowRedirects(r *request.Request) (*http.Response, error) {
+        transport := r.Config.HTTPClient.Transport
+        if transport == nil {
+                transport = http.DefaultTransport
+        }
+
+        return transport.RoundTrip(r.HTTPRequest)
+}
+
+func handleSendError(r *request.Request, err error) {
+        // Prevent leaking if an HTTPResponse was returned. Clean up
+        // the body.
+        if r.HTTPResponse != nil {
+                r.HTTPResponse.Body.Close()
+        }
+        // Capture the case where url.Error is returned for error processing
+        // response. e.g. 301 without location header comes back as string
+        // error and r.HTTPResponse is nil. Other URL redirect errors will
+        // comeback in a similar method.
+        if e, ok := err.(*url.Error); ok && e.Err != nil {
+                if s := reStatusCode.FindStringSubmatch(e.Err.Error()); s != nil {
+                        code, _ := strconv.ParseInt(s[1], 10, 64)
+                        r.HTTPResponse = &http.Response{
+                                StatusCode: int(code),
+                                Status:     http.StatusText(int(code)),
+                                Body:       ioutil.NopCloser(bytes.NewReader([]byte{})),
+                        }
+                        return
+                }
+        }
+        if r.HTTPResponse == nil {
+                // Add a dummy request response object to ensure the HTTPResponse
+                // value is consistent.
+                r.HTTPResponse = &http.Response{
+                        StatusCode: int(0),
+                        Status:     http.StatusText(int(0)),
+                        Body:       ioutil.NopCloser(bytes.NewReader([]byte{})),
+                }
+        }
+        // Catch all other request errors.
+        r.Error = awserr.New("RequestError", "send request failed", err)
+        r.Retryable = aws.Bool(true) // network errors are retryable
+
+        // Override the error with a context canceled error, if that was canceled.
+        ctx := r.Context()
+        select {
+        case <-ctx.Done():
+                r.Error = awserr.New(request.CanceledErrorCode,
+                        "request context canceled", ctx.Err())
+                r.Retryable = aws.Bool(false)
+        default:
+        }
+}
+
+// ValidateResponseHandler is a request handler to validate service response.
+var ValidateResponseHandler = request.NamedHandler{Name: "core.ValidateResponseHandler", Fn: func(r *request.Request) {
+        if r.HTTPResponse.StatusCode == 0 || r.HTTPResponse.StatusCode >= 300 {
+                // this may be replaced by an UnmarshalError handler
+                r.Error = awserr.New("UnknownError", "unknown error", nil)
+        }
+}}
+
+// AfterRetryHandler performs final checks to determine if the request should
+// be retried and how long to delay.
+var AfterRetryHandler = request.NamedHandler{Name: "core.AfterRetryHandler", Fn: func(r *request.Request) {
+        // If one of the other handlers already set the retry state
+        // we don't want to override it based on the service's state
+        if r.Retryable == nil || aws.BoolValue(r.Config.EnforceShouldRetryCheck) {
+                r.Retryable = aws.Bool(r.ShouldRetry(r))
+        }
+
+        if r.WillRetry() {
+                r.RetryDelay = r.RetryRules(r)
+
+                if sleepFn := r.Config.SleepDelay; sleepFn != nil {
+                        // Support SleepDelay for backwards compatibility and testing
+                        sleepFn(r.RetryDelay)
+                } else if err := aws.SleepWithContext(r.Context(), r.RetryDelay); err != nil {
+                        r.Error = awserr.New(request.CanceledErrorCode,
+                                "request context canceled", err)
+                        r.Retryable = aws.Bool(false)
+                        return
+                }
+
+                // when the expired token exception occurs the credentials
+                // need to be expired locally so that the next request to
+                // get credentials will trigger a credentials refresh.
+                if r.IsErrorExpired() {
+                        r.Config.Credentials.Expire()
+                }
+
+                r.RetryCount++
+                r.Error = nil
+        }
+}}
+
+// ValidateEndpointHandler is a request handler to validate a request had the
+// appropriate Region and Endpoint set. Will set r.Error if the endpoint or
+// region is not valid.
+var ValidateEndpointHandler = request.NamedHandler{Name: "core.ValidateEndpointHandler", Fn: func(r *request.Request) {
+        if r.ClientInfo.SigningRegion == "" && aws.StringValue(r.Config.Region) == "" {
+                r.Error = aws.ErrMissingRegion
+        } else if r.ClientInfo.Endpoint == "" {
+                r.Error = aws.ErrMissingEndpoint
+        }
+}}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/corehandlers/param_validator.go b/vendor/github.com/aws/aws-sdk-go/aws/corehandlers/param_validator.go
new file mode 100644
index 0000000..7d50b15
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/corehandlers/param_validator.go
@@ -0,0 +1,17 @@
+package corehandlers
+
+import "github.com/aws/aws-sdk-go/aws/request"
+
+// ValidateParametersHandler is a request handler to validate the input parameters.
+// Validating parameters only has meaning if done prior to the request being sent.
+var ValidateParametersHandler = request.NamedHandler{Name: "core.ValidateParametersHandler", Fn: func(r *request.Request) {
+        if !r.ParamsFilled() {
+                return
+        }
+
+        if v, ok := r.Params.(request.Validator); ok {
+                if err := v.Validate(); err != nil {
+                        r.Error = err
+                }
+        }
+}}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/credentials/chain_provider.go b/vendor/github.com/aws/aws-sdk-go/aws/credentials/chain_provider.go
new file mode 100644
index 0000000..f298d65
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/credentials/chain_provider.go
@@ -0,0 +1,102 @@
+package credentials
+
+import (
+        "github.com/aws/aws-sdk-go/aws/awserr"
+)
+
+var (
+        // ErrNoValidProvidersFoundInChain Is returned when there are no valid
+        // providers in the ChainProvider.
+        //
+        // This has been deprecated. For verbose error messaging set
+        // aws.Config.CredentialsChainVerboseErrors to true
+        //
+        // @readonly
+        ErrNoValidProvidersFoundInChain = awserr.New("NoCredentialProviders",
+                `no valid providers in chain. Deprecated.
+        For verbose messaging see aws.Config.CredentialsChainVerboseErrors`,
+                nil)
+)
+
+// A ChainProvider will search for a provider which returns credentials
+// and cache that provider until Retrieve is called again.
+//
+// The ChainProvider provides a way of chaining multiple providers together
+// which will pick the first available using priority order of the Providers
+// in the list.
+//
+// If none of the Providers retrieve valid credentials Value, ChainProvider's
+// Retrieve() will return the error ErrNoValidProvidersFoundInChain.
+//
+// If a Provider is found which returns valid credentials Value ChainProvider
+// will cache that Provider for all calls to IsExpired(), until Retrieve is
+// called again.
+//
+// Example of ChainProvider to be used with an EnvProvider and EC2RoleProvider.
+// In this example EnvProvider will first check if any credentials are available
+// via the environment variables. If there are none ChainProvider will check
+// the next Provider in the list, EC2RoleProvider in this case. If EC2RoleProvider
+// does not return any credentials ChainProvider will return the error
+// ErrNoValidProvidersFoundInChain
+//
+//     creds := credentials.NewChainCredentials(
+//         []credentials.Provider{
+//             &credentials.EnvProvider{},
+//             &ec2rolecreds.EC2RoleProvider{
+//                 Client: ec2metadata.New(sess),
+//             },
+//         })
+//
+//     // Usage of ChainCredentials with aws.Config
+//     svc := ec2.New(session.Must(session.NewSession(&aws.Config{
+//       Credentials: creds,
+//     })))
+//
+type ChainProvider struct {
+        Providers     []Provider
+        curr          Provider
+        VerboseErrors bool
+}
+
+// NewChainCredentials returns a pointer to a new Credentials object
+// wrapping a chain of providers.
+func NewChainCredentials(providers []Provider) *Credentials {
+        return NewCredentials(&ChainProvider{
+                Providers: append([]Provider{}, providers...),
+        })
+}
+
+// Retrieve returns the credentials value or error if no provider returned
+// without error.
+//
+// If a provider is found it will be cached and any calls to IsExpired()
+// will return the expired state of the cached provider.
+func (c *ChainProvider) Retrieve() (Value, error) {
+        var errs []error
+        for _, p := range c.Providers {
+                creds, err := p.Retrieve()
+                if err == nil {
+                        c.curr = p
+                        return creds, nil
+                }
+                errs = append(errs, err)
+        }
+        c.curr = nil
+
+        var err error
+        err = ErrNoValidProvidersFoundInChain
+        if c.VerboseErrors {
+                err = awserr.NewBatchError("NoCredentialProviders", "no valid providers in chain", errs)
+        }
+        return Value{}, err
+}
+
+// IsExpired will returned the expired state of the currently cached provider
+// if there is one.  If there is no current provider, true will be returned.
+func (c *ChainProvider) IsExpired() bool {
+        if c.curr != nil {
+                return c.curr.IsExpired()
+        }
+
+        return true
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/credentials/credentials.go b/vendor/github.com/aws/aws-sdk-go/aws/credentials/credentials.go
new file mode 100644
index 0000000..42416fc
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/credentials/credentials.go
@@ -0,0 +1,246 @@
+// Package credentials provides credential retrieval and management
+//
+// The Credentials is the primary method of getting access to and managing
+// credentials Values. Using dependency injection retrieval of the credential
+// values is handled by a object which satisfies the Provider interface.
+//
+// By default the Credentials.Get() will cache the successful result of a
+// Provider's Retrieve() until Provider.IsExpired() returns true. At which
+// point Credentials will call Provider's Retrieve() to get new credential Value.
+//
+// The Provider is responsible for determining when credentials Value have expired.
+// It is also important to note that Credentials will always call Retrieve the
+// first time Credentials.Get() is called.
+//
+// Example of using the environment variable credentials.
+//
+//     creds := credentials.NewEnvCredentials()
+//
+//     // Retrieve the credentials value
+//     credValue, err := creds.Get()
+//     if err != nil {
+//         // handle error
+//     }
+//
+// Example of forcing credentials to expire and be refreshed on the next Get().
+// This may be helpful to proactively expire credentials and refresh them sooner
+// than they would naturally expire on their own.
+//
+//     creds := credentials.NewCredentials(&ec2rolecreds.EC2RoleProvider{})
+//     creds.Expire()
+//     credsValue, err := creds.Get()
+//     // New credentials will be retrieved instead of from cache.
+//
+//
+// Custom Provider
+//
+// Each Provider built into this package also provides a helper method to generate
+// a Credentials pointer setup with the provider. To use a custom Provider just
+// create a type which satisfies the Provider interface and pass it to the
+// NewCredentials method.
+//
+//     type MyProvider struct{}
+//     func (m *MyProvider) Retrieve() (Value, error) {...}
+//     func (m *MyProvider) IsExpired() bool {...}
+//
+//     creds := credentials.NewCredentials(&MyProvider{})
+//     credValue, err := creds.Get()
+//
+package credentials
+
+import (
+        "sync"
+        "time"
+)
+
+// AnonymousCredentials is an empty Credential object that can be used as
+// dummy placeholder credentials for requests that do not need signed.
+//
+// This Credentials can be used to configure a service to not sign requests
+// when making service API calls. For example, when accessing public
+// s3 buckets.
+//
+//     svc := s3.New(session.Must(session.NewSession(&aws.Config{
+//       Credentials: credentials.AnonymousCredentials,
+//     })))
+//     // Access public S3 buckets.
+//
+// @readonly
+var AnonymousCredentials = NewStaticCredentials("", "", "")
+
+// A Value is the AWS credentials value for individual credential fields.
+type Value struct {
+        // AWS Access key ID
+        AccessKeyID string
+
+        // AWS Secret Access Key
+        SecretAccessKey string
+
+        // AWS Session Token
+        SessionToken string
+
+        // Provider used to get credentials
+        ProviderName string
+}
+
+// A Provider is the interface for any component which will provide credentials
+// Value. A provider is required to manage its own Expired state, and what to
+// be expired means.
+//
+// The Provider should not need to implement its own mutexes, because
+// that will be managed by Credentials.
+type Provider interface {
+        // Retrieve returns nil if it successfully retrieved the value.
+        // Error is returned if the value were not obtainable, or empty.
+        Retrieve() (Value, error)
+
+        // IsExpired returns if the credentials are no longer valid, and need
+        // to be retrieved.
+        IsExpired() bool
+}
+
+// An ErrorProvider is a stub credentials provider that always returns an error
+// this is used by the SDK when construction a known provider is not possible
+// due to an error.
+type ErrorProvider struct {
+        // The error to be returned from Retrieve
+        Err error
+
+        // The provider name to set on the Retrieved returned Value
+        ProviderName string
+}
+
+// Retrieve will always return the error that the ErrorProvider was created with.
+func (p ErrorProvider) Retrieve() (Value, error) {
+        return Value{ProviderName: p.ProviderName}, p.Err
+}
+
+// IsExpired will always return not expired.
+func (p ErrorProvider) IsExpired() bool {
+        return false
+}
+
+// A Expiry provides shared expiration logic to be used by credentials
+// providers to implement expiry functionality.
+//
+// The best method to use this struct is as an anonymous field within the
+// provider's struct.
+//
+// Example:
+//     type EC2RoleProvider struct {
+//         Expiry
+//         ...
+//     }
+type Expiry struct {
+        // The date/time when to expire on
+        expiration time.Time
+
+        // If set will be used by IsExpired to determine the current time.
+        // Defaults to time.Now if CurrentTime is not set.  Available for testing
+        // to be able to mock out the current time.
+        CurrentTime func() time.Time
+}
+
+// SetExpiration sets the expiration IsExpired will check when called.
+//
+// If window is greater than 0 the expiration time will be reduced by the
+// window value.
+//
+// Using a window is helpful to trigger credentials to expire sooner than
+// the expiration time given to ensure no requests are made with expired
+// tokens.
+func (e *Expiry) SetExpiration(expiration time.Time, window time.Duration) {
+        e.expiration = expiration
+        if window > 0 {
+                e.expiration = e.expiration.Add(-window)
+        }
+}
+
+// IsExpired returns if the credentials are expired.
+func (e *Expiry) IsExpired() bool {
+        if e.CurrentTime == nil {
+                e.CurrentTime = time.Now
+        }
+        return e.expiration.Before(e.CurrentTime())
+}
+
+// A Credentials provides synchronous safe retrieval of AWS credentials Value.
+// Credentials will cache the credentials value until they expire. Once the value
+// expires the next Get will attempt to retrieve valid credentials.
+//
+// Credentials is safe to use across multiple goroutines and will manage the
+// synchronous state so the Providers do not need to implement their own
+// synchronization.
+//
+// The first Credentials.Get() will always call Provider.Retrieve() to get the
+// first instance of the credentials Value. All calls to Get() after that
+// will return the cached credentials Value until IsExpired() returns true.
+type Credentials struct {
+        creds        Value
+        forceRefresh bool
+        m            sync.Mutex
+
+        provider Provider
+}
+
+// NewCredentials returns a pointer to a new Credentials with the provider set.
+func NewCredentials(provider Provider) *Credentials {
+        return &Credentials{
+                provider:     provider,
+                forceRefresh: true,
+        }
+}
+
+// Get returns the credentials value, or error if the credentials Value failed
+// to be retrieved.
+//
+// Will return the cached credentials Value if it has not expired. If the
+// credentials Value has expired the Provider's Retrieve() will be called
+// to refresh the credentials.
+//
+// If Credentials.Expire() was called the credentials Value will be force
+// expired, and the next call to Get() will cause them to be refreshed.
+func (c *Credentials) Get() (Value, error) {
+        c.m.Lock()
+        defer c.m.Unlock()
+
+        if c.isExpired() {
+                creds, err := c.provider.Retrieve()
+                if err != nil {
+                        return Value{}, err
+                }
+                c.creds = creds
+                c.forceRefresh = false
+        }
+
+        return c.creds, nil
+}
+
+// Expire expires the credentials and forces them to be retrieved on the
+// next call to Get().
+//
+// This will override the Provider's expired state, and force Credentials
+// to call the Provider's Retrieve().
+func (c *Credentials) Expire() {
+        c.m.Lock()
+        defer c.m.Unlock()
+
+        c.forceRefresh = true
+}
+
+// IsExpired returns if the credentials are no longer valid, and need
+// to be retrieved.
+//
+// If the Credentials were forced to be expired with Expire() this will
+// reflect that override.
+func (c *Credentials) IsExpired() bool {
+        c.m.Lock()
+        defer c.m.Unlock()
+
+        return c.isExpired()
+}
+
+// isExpired helper method wrapping the definition of expired credentials.
+func (c *Credentials) isExpired() bool {
+        return c.forceRefresh || c.provider.IsExpired()
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds/ec2_role_provider.go b/vendor/github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds/ec2_role_provider.go
new file mode 100644
index 0000000..c397495
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds/ec2_role_provider.go
@@ -0,0 +1,178 @@
+package ec2rolecreds
+
+import (
+        "bufio"
+        "encoding/json"
+        "fmt"
+        "path"
+        "strings"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/client"
+        "github.com/aws/aws-sdk-go/aws/credentials"
+        "github.com/aws/aws-sdk-go/aws/ec2metadata"
+)
+
+// ProviderName provides a name of EC2Role provider
+const ProviderName = "EC2RoleProvider"
+
+// A EC2RoleProvider retrieves credentials from the EC2 service, and keeps track if
+// those credentials are expired.
+//
+// Example how to configure the EC2RoleProvider with custom http Client, Endpoint
+// or ExpiryWindow
+//
+//     p := &ec2rolecreds.EC2RoleProvider{
+//         // Pass in a custom timeout to be used when requesting
+//         // IAM EC2 Role credentials.
+//         Client: ec2metadata.New(sess, aws.Config{
+//             HTTPClient: &http.Client{Timeout: 10 * time.Second},
+//         }),
+//
+//         // Do not use early expiry of credentials. If a non zero value is
+//         // specified the credentials will be expired early
+//         ExpiryWindow: 0,
+//     }
+type EC2RoleProvider struct {
+        credentials.Expiry
+
+        // Required EC2Metadata client to use when connecting to EC2 metadata service.
+        Client *ec2metadata.EC2Metadata
+
+        // ExpiryWindow will allow the credentials to trigger refreshing prior to
+        // the credentials actually expiring. This is beneficial so race conditions
+        // with expiring credentials do not cause request to fail unexpectedly
+        // due to ExpiredTokenException exceptions.
+        //
+        // So a ExpiryWindow of 10s would cause calls to IsExpired() to return true
+        // 10 seconds before the credentials are actually expired.
+        //
+        // If ExpiryWindow is 0 or less it will be ignored.
+        ExpiryWindow time.Duration
+}
+
+// NewCredentials returns a pointer to a new Credentials object wrapping
+// the EC2RoleProvider. Takes a ConfigProvider to create a EC2Metadata client.
+// The ConfigProvider is satisfied by the session.Session type.
+func NewCredentials(c client.ConfigProvider, options ...func(*EC2RoleProvider)) *credentials.Credentials {
+        p := &EC2RoleProvider{
+                Client: ec2metadata.New(c),
+        }
+
+        for _, option := range options {
+                option(p)
+        }
+
+        return credentials.NewCredentials(p)
+}
+
+// NewCredentialsWithClient returns a pointer to a new Credentials object wrapping
+// the EC2RoleProvider. Takes a EC2Metadata client to use when connecting to EC2
+// metadata service.
+func NewCredentialsWithClient(client *ec2metadata.EC2Metadata, options ...func(*EC2RoleProvider)) *credentials.Credentials {
+        p := &EC2RoleProvider{
+                Client: client,
+        }
+
+        for _, option := range options {
+                option(p)
+        }
+
+        return credentials.NewCredentials(p)
+}
+
+// Retrieve retrieves credentials from the EC2 service.
+// Error will be returned if the request fails, or unable to extract
+// the desired credentials.
+func (m *EC2RoleProvider) Retrieve() (credentials.Value, error) {
+        credsList, err := requestCredList(m.Client)
+        if err != nil {
+                return credentials.Value{ProviderName: ProviderName}, err
+        }
+
+        if len(credsList) == 0 {
+                return credentials.Value{ProviderName: ProviderName}, awserr.New("EmptyEC2RoleList", "empty EC2 Role list", nil)
+        }
+        credsName := credsList[0]
+
+        roleCreds, err := requestCred(m.Client, credsName)
+        if err != nil {
+                return credentials.Value{ProviderName: ProviderName}, err
+        }
+
+        m.SetExpiration(roleCreds.Expiration, m.ExpiryWindow)
+
+        return credentials.Value{
+                AccessKeyID:     roleCreds.AccessKeyID,
+                SecretAccessKey: roleCreds.SecretAccessKey,
+                SessionToken:    roleCreds.Token,
+                ProviderName:    ProviderName,
+        }, nil
+}
+
+// A ec2RoleCredRespBody provides the shape for unmarshaling credential
+// request responses.
+type ec2RoleCredRespBody struct {
+        // Success State
+        Expiration      time.Time
+        AccessKeyID     string
+        SecretAccessKey string
+        Token           string
+
+        // Error state
+        Code    string
+        Message string
+}
+
+const iamSecurityCredsPath = "/iam/security-credentials"
+
+// requestCredList requests a list of credentials from the EC2 service.
+// If there are no credentials, or there is an error making or receiving the request
+func requestCredList(client *ec2metadata.EC2Metadata) ([]string, error) {
+        resp, err := client.GetMetadata(iamSecurityCredsPath)
+        if err != nil {
+                return nil, awserr.New("EC2RoleRequestError", "no EC2 instance role found", err)
+        }
+
+        credsList := []string{}
+        s := bufio.NewScanner(strings.NewReader(resp))
+        for s.Scan() {
+                credsList = append(credsList, s.Text())
+        }
+
+        if err := s.Err(); err != nil {
+                return nil, awserr.New("SerializationError", "failed to read EC2 instance role from metadata service", err)
+        }
+
+        return credsList, nil
+}
+
+// requestCred requests the credentials for a specific credentials from the EC2 service.
+//
+// If the credentials cannot be found, or there is an error reading the response
+// and error will be returned.
+func requestCred(client *ec2metadata.EC2Metadata, credsName string) (ec2RoleCredRespBody, error) {
+        resp, err := client.GetMetadata(path.Join(iamSecurityCredsPath, credsName))
+        if err != nil {
+                return ec2RoleCredRespBody{},
+                        awserr.New("EC2RoleRequestError",
+                                fmt.Sprintf("failed to get %s EC2 instance role credentials", credsName),
+                                err)
+        }
+
+        respCreds := ec2RoleCredRespBody{}
+        if err := json.NewDecoder(strings.NewReader(resp)).Decode(&respCreds); err != nil {
+                return ec2RoleCredRespBody{},
+                        awserr.New("SerializationError",
+                                fmt.Sprintf("failed to decode %s EC2 instance role credentials", credsName),
+                                err)
+        }
+
+        if respCreds.Code != "Success" {
+                // If an error code was returned something failed requesting the role.
+                return ec2RoleCredRespBody{}, awserr.New(respCreds.Code, respCreds.Message, nil)
+        }
+
+        return respCreds, nil
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/credentials/endpointcreds/provider.go b/vendor/github.com/aws/aws-sdk-go/aws/credentials/endpointcreds/provider.go
new file mode 100644
index 0000000..a4cec5c
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/credentials/endpointcreds/provider.go
@@ -0,0 +1,191 @@
+// Package endpointcreds provides support for retrieving credentials from an
+// arbitrary HTTP endpoint.
+//
+// The credentials endpoint Provider can receive both static and refreshable
+// credentials that will expire. Credentials are static when an "Expiration"
+// value is not provided in the endpoint's response.
+//
+// Static credentials will never expire once they have been retrieved. The format
+// of the static credentials response:
+//    {
+//        "AccessKeyId" : "MUA...",
+//        "SecretAccessKey" : "/7PC5om....",
+//    }
+//
+// Refreshable credentials will expire within the "ExpiryWindow" of the Expiration
+// value in the response. The format of the refreshable credentials response:
+//    {
+//        "AccessKeyId" : "MUA...",
+//        "SecretAccessKey" : "/7PC5om....",
+//        "Token" : "AQoDY....=",
+//        "Expiration" : "2016-02-25T06:03:31Z"
+//    }
+//
+// Errors should be returned in the following format and only returned with 400
+// or 500 HTTP status codes.
+//    {
+//        "code": "ErrorCode",
+//        "message": "Helpful error message."
+//    }
+package endpointcreds
+
+import (
+        "encoding/json"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/client"
+        "github.com/aws/aws-sdk-go/aws/client/metadata"
+        "github.com/aws/aws-sdk-go/aws/credentials"
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+// ProviderName is the name of the credentials provider.
+const ProviderName = `CredentialsEndpointProvider`
+
+// Provider satisfies the credentials.Provider interface, and is a client to
+// retrieve credentials from an arbitrary endpoint.
+type Provider struct {
+        staticCreds bool
+        credentials.Expiry
+
+        // Requires a AWS Client to make HTTP requests to the endpoint with.
+        // the Endpoint the request will be made to is provided by the aws.Config's
+        // Endpoint value.
+        Client *client.Client
+
+        // ExpiryWindow will allow the credentials to trigger refreshing prior to
+        // the credentials actually expiring. This is beneficial so race conditions
+        // with expiring credentials do not cause request to fail unexpectedly
+        // due to ExpiredTokenException exceptions.
+        //
+        // So a ExpiryWindow of 10s would cause calls to IsExpired() to return true
+        // 10 seconds before the credentials are actually expired.
+        //
+        // If ExpiryWindow is 0 or less it will be ignored.
+        ExpiryWindow time.Duration
+}
+
+// NewProviderClient returns a credentials Provider for retrieving AWS credentials
+// from arbitrary endpoint.
+func NewProviderClient(cfg aws.Config, handlers request.Handlers, endpoint string, options ...func(*Provider)) credentials.Provider {
+        p := &Provider{
+                Client: client.New(
+                        cfg,
+                        metadata.ClientInfo{
+                                ServiceName: "CredentialsEndpoint",
+                                Endpoint:    endpoint,
+                        },
+                        handlers,
+                ),
+        }
+
+        p.Client.Handlers.Unmarshal.PushBack(unmarshalHandler)
+        p.Client.Handlers.UnmarshalError.PushBack(unmarshalError)
+        p.Client.Handlers.Validate.Clear()
+        p.Client.Handlers.Validate.PushBack(validateEndpointHandler)
+
+        for _, option := range options {
+                option(p)
+        }
+
+        return p
+}
+
+// NewCredentialsClient returns a Credentials wrapper for retrieving credentials
+// from an arbitrary endpoint concurrently. The client will request the
+func NewCredentialsClient(cfg aws.Config, handlers request.Handlers, endpoint string, options ...func(*Provider)) *credentials.Credentials {
+        return credentials.NewCredentials(NewProviderClient(cfg, handlers, endpoint, options...))
+}
+
+// IsExpired returns true if the credentials retrieved are expired, or not yet
+// retrieved.
+func (p *Provider) IsExpired() bool {
+        if p.staticCreds {
+                return false
+        }
+        return p.Expiry.IsExpired()
+}
+
+// Retrieve will attempt to request the credentials from the endpoint the Provider
+// was configured for. And error will be returned if the retrieval fails.
+func (p *Provider) Retrieve() (credentials.Value, error) {
+        resp, err := p.getCredentials()
+        if err != nil {
+                return credentials.Value{ProviderName: ProviderName},
+                        awserr.New("CredentialsEndpointError", "failed to load credentials", err)
+        }
+
+        if resp.Expiration != nil {
+                p.SetExpiration(*resp.Expiration, p.ExpiryWindow)
+        } else {
+                p.staticCreds = true
+        }
+
+        return credentials.Value{
+                AccessKeyID:     resp.AccessKeyID,
+                SecretAccessKey: resp.SecretAccessKey,
+                SessionToken:    resp.Token,
+                ProviderName:    ProviderName,
+        }, nil
+}
+
+type getCredentialsOutput struct {
+        Expiration      *time.Time
+        AccessKeyID     string
+        SecretAccessKey string
+        Token           string
+}
+
+type errorOutput struct {
+        Code    string `json:"code"`
+        Message string `json:"message"`
+}
+
+func (p *Provider) getCredentials() (*getCredentialsOutput, error) {
+        op := &request.Operation{
+                Name:       "GetCredentials",
+                HTTPMethod: "GET",
+        }
+
+        out := &getCredentialsOutput{}
+        req := p.Client.NewRequest(op, nil, out)
+        req.HTTPRequest.Header.Set("Accept", "application/json")
+
+        return out, req.Send()
+}
+
+func validateEndpointHandler(r *request.Request) {
+        if len(r.ClientInfo.Endpoint) == 0 {
+                r.Error = aws.ErrMissingEndpoint
+        }
+}
+
+func unmarshalHandler(r *request.Request) {
+        defer r.HTTPResponse.Body.Close()
+
+        out := r.Data.(*getCredentialsOutput)
+        if err := json.NewDecoder(r.HTTPResponse.Body).Decode(&out); err != nil {
+                r.Error = awserr.New("SerializationError",
+                        "failed to decode endpoint credentials",
+                        err,
+                )
+        }
+}
+
+func unmarshalError(r *request.Request) {
+        defer r.HTTPResponse.Body.Close()
+
+        var errOut errorOutput
+        if err := json.NewDecoder(r.HTTPResponse.Body).Decode(&errOut); err != nil {
+                r.Error = awserr.New("SerializationError",
+                        "failed to decode endpoint credentials",
+                        err,
+                )
+        }
+
+        // Response body format is not consistent between metadata endpoints.
+        // Grab the error message as a string and include that as the source error
+        r.Error = awserr.New(errOut.Code, errOut.Message, nil)
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/credentials/env_provider.go b/vendor/github.com/aws/aws-sdk-go/aws/credentials/env_provider.go
new file mode 100644
index 0000000..c14231a
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/credentials/env_provider.go
@@ -0,0 +1,78 @@
+package credentials
+
+import (
+        "os"
+
+        "github.com/aws/aws-sdk-go/aws/awserr"
+)
+
+// EnvProviderName provides a name of Env provider
+const EnvProviderName = "EnvProvider"
+
+var (
+        // ErrAccessKeyIDNotFound is returned when the AWS Access Key ID can't be
+        // found in the process's environment.
+        //
+        // @readonly
+        ErrAccessKeyIDNotFound = awserr.New("EnvAccessKeyNotFound", "AWS_ACCESS_KEY_ID or AWS_ACCESS_KEY not found in environment", nil)
+
+        // ErrSecretAccessKeyNotFound is returned when the AWS Secret Access Key
+        // can't be found in the process's environment.
+        //
+        // @readonly
+        ErrSecretAccessKeyNotFound = awserr.New("EnvSecretNotFound", "AWS_SECRET_ACCESS_KEY or AWS_SECRET_KEY not found in environment", nil)
+)
+
+// A EnvProvider retrieves credentials from the environment variables of the
+// running process. Environment credentials never expire.
+//
+// Environment variables used:
+//
+// * Access Key ID:     AWS_ACCESS_KEY_ID or AWS_ACCESS_KEY
+//
+// * Secret Access Key: AWS_SECRET_ACCESS_KEY or AWS_SECRET_KEY
+type EnvProvider struct {
+        retrieved bool
+}
+
+// NewEnvCredentials returns a pointer to a new Credentials object
+// wrapping the environment variable provider.
+func NewEnvCredentials() *Credentials {
+        return NewCredentials(&EnvProvider{})
+}
+
+// Retrieve retrieves the keys from the environment.
+func (e *EnvProvider) Retrieve() (Value, error) {
+        e.retrieved = false
+
+        id := os.Getenv("AWS_ACCESS_KEY_ID")
+        if id == "" {
+                id = os.Getenv("AWS_ACCESS_KEY")
+        }
+
+        secret := os.Getenv("AWS_SECRET_ACCESS_KEY")
+        if secret == "" {
+                secret = os.Getenv("AWS_SECRET_KEY")
+        }
+
+        if id == "" {
+                return Value{ProviderName: EnvProviderName}, ErrAccessKeyIDNotFound
+        }
+
+        if secret == "" {
+                return Value{ProviderName: EnvProviderName}, ErrSecretAccessKeyNotFound
+        }
+
+        e.retrieved = true
+        return Value{
+                AccessKeyID:     id,
+                SecretAccessKey: secret,
+                SessionToken:    os.Getenv("AWS_SESSION_TOKEN"),
+                ProviderName:    EnvProviderName,
+        }, nil
+}
+
+// IsExpired returns if the credentials have been retrieved.
+func (e *EnvProvider) IsExpired() bool {
+        return !e.retrieved
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/credentials/example.ini b/vendor/github.com/aws/aws-sdk-go/aws/credentials/example.ini
new file mode 100644
index 0000000..7fc91d9
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/credentials/example.ini
@@ -0,0 +1,12 @@
+[default]
+aws_access_key_id = accessKey
+aws_secret_access_key = secret
+aws_session_token = token
+
+[no_token]
+aws_access_key_id = accessKey
+aws_secret_access_key = secret
+
+[with_colon]
+aws_access_key_id: accessKey
+aws_secret_access_key: secret
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/credentials/shared_credentials_provider.go b/vendor/github.com/aws/aws-sdk-go/aws/credentials/shared_credentials_provider.go
new file mode 100644
index 0000000..7fb7cbf
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/credentials/shared_credentials_provider.go
@@ -0,0 +1,151 @@
+package credentials
+
+import (
+        "fmt"
+        "os"
+        "path/filepath"
+
+        "github.com/go-ini/ini"
+
+        "github.com/aws/aws-sdk-go/aws/awserr"
+)
+
+// SharedCredsProviderName provides a name of SharedCreds provider
+const SharedCredsProviderName = "SharedCredentialsProvider"
+
+var (
+        // ErrSharedCredentialsHomeNotFound is emitted when the user directory cannot be found.
+        //
+        // @readonly
+        ErrSharedCredentialsHomeNotFound = awserr.New("UserHomeNotFound", "user home directory not found.", nil)
+)
+
+// A SharedCredentialsProvider retrieves credentials from the current user's home
+// directory, and keeps track if those credentials are expired.
+//
+// Profile ini file example: $HOME/.aws/credentials
+type SharedCredentialsProvider struct {
+        // Path to the shared credentials file.
+        //
+        // If empty will look for "AWS_SHARED_CREDENTIALS_FILE" env variable. If the
+        // env value is empty will default to current user's home directory.
+        // Linux/OSX: "$HOME/.aws/credentials"
+        // Windows:   "%USERPROFILE%\.aws\credentials"
+        Filename string
+
+        // AWS Profile to extract credentials from the shared credentials file. If empty
+        // will default to environment variable "AWS_PROFILE" or "default" if
+        // environment variable is also not set.
+        Profile string
+
+        // retrieved states if the credentials have been successfully retrieved.
+        retrieved bool
+}
+
+// NewSharedCredentials returns a pointer to a new Credentials object
+// wrapping the Profile file provider.
+func NewSharedCredentials(filename, profile string) *Credentials {
+        return NewCredentials(&SharedCredentialsProvider{
+                Filename: filename,
+                Profile:  profile,
+        })
+}
+
+// Retrieve reads and extracts the shared credentials from the current
+// users home directory.
+func (p *SharedCredentialsProvider) Retrieve() (Value, error) {
+        p.retrieved = false
+
+        filename, err := p.filename()
+        if err != nil {
+                return Value{ProviderName: SharedCredsProviderName}, err
+        }
+
+        creds, err := loadProfile(filename, p.profile())
+        if err != nil {
+                return Value{ProviderName: SharedCredsProviderName}, err
+        }
+
+        p.retrieved = true
+        return creds, nil
+}
+
+// IsExpired returns if the shared credentials have expired.
+func (p *SharedCredentialsProvider) IsExpired() bool {
+        return !p.retrieved
+}
+
+// loadProfiles loads from the file pointed to by shared credentials filename for profile.
+// The credentials retrieved from the profile will be returned or error. Error will be
+// returned if it fails to read from the file, or the data is invalid.
+func loadProfile(filename, profile string) (Value, error) {
+        config, err := ini.Load(filename)
+        if err != nil {
+                return Value{ProviderName: SharedCredsProviderName}, awserr.New("SharedCredsLoad", "failed to load shared credentials file", err)
+        }
+        iniProfile, err := config.GetSection(profile)
+        if err != nil {
+                return Value{ProviderName: SharedCredsProviderName}, awserr.New("SharedCredsLoad", "failed to get profile", err)
+        }
+
+        id, err := iniProfile.GetKey("aws_access_key_id")
+        if err != nil {
+                return Value{ProviderName: SharedCredsProviderName}, awserr.New("SharedCredsAccessKey",
+                        fmt.Sprintf("shared credentials %s in %s did not contain aws_access_key_id", profile, filename),
+                        err)
+        }
+
+        secret, err := iniProfile.GetKey("aws_secret_access_key")
+        if err != nil {
+                return Value{ProviderName: SharedCredsProviderName}, awserr.New("SharedCredsSecret",
+                        fmt.Sprintf("shared credentials %s in %s did not contain aws_secret_access_key", profile, filename),
+                        nil)
+        }
+
+        // Default to empty string if not found
+        token := iniProfile.Key("aws_session_token")
+
+        return Value{
+                AccessKeyID:     id.String(),
+                SecretAccessKey: secret.String(),
+                SessionToken:    token.String(),
+                ProviderName:    SharedCredsProviderName,
+        }, nil
+}
+
+// filename returns the filename to use to read AWS shared credentials.
+//
+// Will return an error if the user's home directory path cannot be found.
+func (p *SharedCredentialsProvider) filename() (string, error) {
+        if p.Filename == "" {
+                if p.Filename = os.Getenv("AWS_SHARED_CREDENTIALS_FILE"); p.Filename != "" {
+                        return p.Filename, nil
+                }
+
+                homeDir := os.Getenv("HOME") // *nix
+                if homeDir == "" {           // Windows
+                        homeDir = os.Getenv("USERPROFILE")
+                }
+                if homeDir == "" {
+                        return "", ErrSharedCredentialsHomeNotFound
+                }
+
+                p.Filename = filepath.Join(homeDir, ".aws", "credentials")
+        }
+
+        return p.Filename, nil
+}
+
+// profile returns the AWS shared credentials profile.  If empty will read
+// environment variable "AWS_PROFILE". If that is not set profile will
+// return "default".
+func (p *SharedCredentialsProvider) profile() string {
+        if p.Profile == "" {
+                p.Profile = os.Getenv("AWS_PROFILE")
+        }
+        if p.Profile == "" {
+                p.Profile = "default"
+        }
+
+        return p.Profile
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/credentials/static_provider.go b/vendor/github.com/aws/aws-sdk-go/aws/credentials/static_provider.go
new file mode 100644
index 0000000..4f5dab3
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/credentials/static_provider.go
@@ -0,0 +1,57 @@
+package credentials
+
+import (
+        "github.com/aws/aws-sdk-go/aws/awserr"
+)
+
+// StaticProviderName provides a name of Static provider
+const StaticProviderName = "StaticProvider"
+
+var (
+        // ErrStaticCredentialsEmpty is emitted when static credentials are empty.
+        //
+        // @readonly
+        ErrStaticCredentialsEmpty = awserr.New("EmptyStaticCreds", "static credentials are empty", nil)
+)
+
+// A StaticProvider is a set of credentials which are set programmatically,
+// and will never expire.
+type StaticProvider struct {
+        Value
+}
+
+// NewStaticCredentials returns a pointer to a new Credentials object
+// wrapping a static credentials value provider.
+func NewStaticCredentials(id, secret, token string) *Credentials {
+        return NewCredentials(&StaticProvider{Value: Value{
+                AccessKeyID:     id,
+                SecretAccessKey: secret,
+                SessionToken:    token,
+        }})
+}
+
+// NewStaticCredentialsFromCreds returns a pointer to a new Credentials object
+// wrapping the static credentials value provide. Same as NewStaticCredentials
+// but takes the creds Value instead of individual fields
+func NewStaticCredentialsFromCreds(creds Value) *Credentials {
+        return NewCredentials(&StaticProvider{Value: creds})
+}
+
+// Retrieve returns the credentials or error if the credentials are invalid.
+func (s *StaticProvider) Retrieve() (Value, error) {
+        if s.AccessKeyID == "" || s.SecretAccessKey == "" {
+                return Value{ProviderName: StaticProviderName}, ErrStaticCredentialsEmpty
+        }
+
+        if len(s.Value.ProviderName) == 0 {
+                s.Value.ProviderName = StaticProviderName
+        }
+        return s.Value, nil
+}
+
+// IsExpired returns if the credentials are expired.
+//
+// For StaticProvider, the credentials never expired.
+func (s *StaticProvider) IsExpired() bool {
+        return false
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/credentials/stscreds/assume_role_provider.go b/vendor/github.com/aws/aws-sdk-go/aws/credentials/stscreds/assume_role_provider.go
new file mode 100644
index 0000000..4108e43
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/credentials/stscreds/assume_role_provider.go
@@ -0,0 +1,298 @@
+/*
+Package stscreds are credential Providers to retrieve STS AWS credentials.
+
+STS provides multiple ways to retrieve credentials which can be used when making
+future AWS service API operation calls.
+
+The SDK will ensure that per instance of credentials.Credentials all requests
+to refresh the credentials will be synchronized. But, the SDK is unable to
+ensure synchronous usage of the AssumeRoleProvider if the value is shared
+between multiple Credentials, Sessions or service clients.
+
+Assume Role
+
+To assume an IAM role using STS with the SDK you can create a new Credentials
+with the SDKs's stscreds package.
+
+        // Initial credentials loaded from SDK's default credential chain. Such as
+        // the environment, shared credentials (~/.aws/credentials), or EC2 Instance
+        // Role. These credentials will be used to to make the STS Assume Role API.
+        sess := session.Must(session.NewSession())
+
+        // Create the credentials from AssumeRoleProvider to assume the role
+        // referenced by the "myRoleARN" ARN.
+        creds := stscreds.NewCredentials(sess, "myRoleArn")
+
+        // Create service client value configured for credentials
+        // from assumed role.
+        svc := s3.New(sess, &aws.Config{Credentials: creds})
+
+Assume Role with static MFA Token
+
+To assume an IAM role with a MFA token you can either specify a MFA token code
+directly or provide a function to prompt the user each time the credentials
+need to refresh the role's credentials. Specifying the TokenCode should be used
+for short lived operations that will not need to be refreshed, and when you do
+not want to have direct control over the user provides their MFA token.
+
+With TokenCode the AssumeRoleProvider will be not be able to refresh the role's
+credentials.
+
+        // Create the credentials from AssumeRoleProvider to assume the role
+        // referenced by the "myRoleARN" ARN using the MFA token code provided.
+        creds := stscreds.NewCredentials(sess, "myRoleArn", func(p *stscreds.AssumeRoleProvider) {
+                p.SerialNumber = aws.String("myTokenSerialNumber")
+                p.TokenCode = aws.String("00000000")
+        })
+
+        // Create service client value configured for credentials
+        // from assumed role.
+        svc := s3.New(sess, &aws.Config{Credentials: creds})
+
+Assume Role with MFA Token Provider
+
+To assume an IAM role with MFA for longer running tasks where the credentials
+may need to be refreshed setting the TokenProvider field of AssumeRoleProvider
+will allow the credential provider to prompt for new MFA token code when the
+role's credentials need to be refreshed.
+
+The StdinTokenProvider function is available to prompt on stdin to retrieve
+the MFA token code from the user. You can also implement custom prompts by
+satisfing the TokenProvider function signature.
+
+Using StdinTokenProvider with multiple AssumeRoleProviders, or Credentials will
+have undesirable results as the StdinTokenProvider will not be synchronized. A
+single Credentials with an AssumeRoleProvider can be shared safely.
+
+        // Create the credentials from AssumeRoleProvider to assume the role
+        // referenced by the "myRoleARN" ARN. Prompting for MFA token from stdin.
+        creds := stscreds.NewCredentials(sess, "myRoleArn", func(p *stscreds.AssumeRoleProvider) {
+                p.SerialNumber = aws.String("myTokenSerialNumber")
+                p.TokenProvider = stscreds.StdinTokenProvider
+        })
+
+        // Create service client value configured for credentials
+        // from assumed role.
+        svc := s3.New(sess, &aws.Config{Credentials: creds})
+
+*/
+package stscreds
+
+import (
+        "fmt"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/client"
+        "github.com/aws/aws-sdk-go/aws/credentials"
+        "github.com/aws/aws-sdk-go/service/sts"
+)
+
+// StdinTokenProvider will prompt on stdout and read from stdin for a string value.
+// An error is returned if reading from stdin fails.
+//
+// Use this function go read MFA tokens from stdin. The function makes no attempt
+// to make atomic prompts from stdin across multiple gorouties.
+//
+// Using StdinTokenProvider with multiple AssumeRoleProviders, or Credentials will
+// have undesirable results as the StdinTokenProvider will not be synchronized. A
+// single Credentials with an AssumeRoleProvider can be shared safely
+//
+// Will wait forever until something is provided on the stdin.
+func StdinTokenProvider() (string, error) {
+        var v string
+        fmt.Printf("Assume Role MFA token code: ")
+        _, err := fmt.Scanln(&v)
+
+        return v, err
+}
+
+// ProviderName provides a name of AssumeRole provider
+const ProviderName = "AssumeRoleProvider"
+
+// AssumeRoler represents the minimal subset of the STS client API used by this provider.
+type AssumeRoler interface {
+        AssumeRole(input *sts.AssumeRoleInput) (*sts.AssumeRoleOutput, error)
+}
+
+// DefaultDuration is the default amount of time in minutes that the credentials
+// will be valid for.
+var DefaultDuration = time.Duration(15) * time.Minute
+
+// AssumeRoleProvider retrieves temporary credentials from the STS service, and
+// keeps track of their expiration time.
+//
+// This credential provider will be used by the SDKs default credential change
+// when shared configuration is enabled, and the shared config or shared credentials
+// file configure assume role. See Session docs for how to do this.
+//
+// AssumeRoleProvider does not provide any synchronization and it is not safe
+// to share this value across multiple Credentials, Sessions, or service clients
+// without also sharing the same Credentials instance.
+type AssumeRoleProvider struct {
+        credentials.Expiry
+
+        // STS client to make assume role request with.
+        Client AssumeRoler
+
+        // Role to be assumed.
+        RoleARN string
+
+        // Session name, if you wish to reuse the credentials elsewhere.
+        RoleSessionName string
+
+        // Expiry duration of the STS credentials. Defaults to 15 minutes if not set.
+        Duration time.Duration
+
+        // Optional ExternalID to pass along, defaults to nil if not set.
+        ExternalID *string
+
+        // The policy plain text must be 2048 bytes or shorter. However, an internal
+        // conversion compresses it into a packed binary format with a separate limit.
+        // The PackedPolicySize response element indicates by percentage how close to
+        // the upper size limit the policy is, with 100% equaling the maximum allowed
+        // size.
+        Policy *string
+
+        // The identification number of the MFA device that is associated with the user
+        // who is making the AssumeRole call. Specify this value if the trust policy
+        // of the role being assumed includes a condition that requires MFA authentication.
+        // The value is either the serial number for a hardware device (such as GAHT12345678)
+        // or an Amazon Resource Name (ARN) for a virtual device (such as arn:aws:iam::123456789012:mfa/user).
+        SerialNumber *string
+
+        // The value provided by the MFA device, if the trust policy of the role being
+        // assumed requires MFA (that is, if the policy includes a condition that tests
+        // for MFA). If the role being assumed requires MFA and if the TokenCode value
+        // is missing or expired, the AssumeRole call returns an "access denied" error.
+        //
+        // If SerialNumber is set and neither TokenCode nor TokenProvider are also
+        // set an error will be returned.
+        TokenCode *string
+
+        // Async method of providing MFA token code for assuming an IAM role with MFA.
+        // The value returned by the function will be used as the TokenCode in the Retrieve
+        // call. See StdinTokenProvider for a provider that prompts and reads from stdin.
+        //
+        // This token provider will be called when ever the assumed role's
+        // credentials need to be refreshed when SerialNumber is also set and
+        // TokenCode is not set.
+        //
+        // If both TokenCode and TokenProvider is set, TokenProvider will be used and
+        // TokenCode is ignored.
+        TokenProvider func() (string, error)
+
+        // ExpiryWindow will allow the credentials to trigger refreshing prior to
+        // the credentials actually expiring. This is beneficial so race conditions
+        // with expiring credentials do not cause request to fail unexpectedly
+        // due to ExpiredTokenException exceptions.
+        //
+        // So a ExpiryWindow of 10s would cause calls to IsExpired() to return true
+        // 10 seconds before the credentials are actually expired.
+        //
+        // If ExpiryWindow is 0 or less it will be ignored.
+        ExpiryWindow time.Duration
+}
+
+// NewCredentials returns a pointer to a new Credentials object wrapping the
+// AssumeRoleProvider. The credentials will expire every 15 minutes and the
+// role will be named after a nanosecond timestamp of this operation.
+//
+// Takes a Config provider to create the STS client. The ConfigProvider is
+// satisfied by the session.Session type.
+//
+// It is safe to share the returned Credentials with multiple Sessions and
+// service clients. All access to the credentials and refreshing them
+// will be synchronized.
+func NewCredentials(c client.ConfigProvider, roleARN string, options ...func(*AssumeRoleProvider)) *credentials.Credentials {
+        p := &AssumeRoleProvider{
+                Client:   sts.New(c),
+                RoleARN:  roleARN,
+                Duration: DefaultDuration,
+        }
+
+        for _, option := range options {
+                option(p)
+        }
+
+        return credentials.NewCredentials(p)
+}
+
+// NewCredentialsWithClient returns a pointer to a new Credentials object wrapping the
+// AssumeRoleProvider. The credentials will expire every 15 minutes and the
+// role will be named after a nanosecond timestamp of this operation.
+//
+// Takes an AssumeRoler which can be satisfied by the STS client.
+//
+// It is safe to share the returned Credentials with multiple Sessions and
+// service clients. All access to the credentials and refreshing them
+// will be synchronized.
+func NewCredentialsWithClient(svc AssumeRoler, roleARN string, options ...func(*AssumeRoleProvider)) *credentials.Credentials {
+        p := &AssumeRoleProvider{
+                Client:   svc,
+                RoleARN:  roleARN,
+                Duration: DefaultDuration,
+        }
+
+        for _, option := range options {
+                option(p)
+        }
+
+        return credentials.NewCredentials(p)
+}
+
+// Retrieve generates a new set of temporary credentials using STS.
+func (p *AssumeRoleProvider) Retrieve() (credentials.Value, error) {
+
+        // Apply defaults where parameters are not set.
+        if p.RoleSessionName == "" {
+                // Try to work out a role name that will hopefully end up unique.
+                p.RoleSessionName = fmt.Sprintf("%d", time.Now().UTC().UnixNano())
+        }
+        if p.Duration == 0 {
+                // Expire as often as AWS permits.
+                p.Duration = DefaultDuration
+        }
+        input := &sts.AssumeRoleInput{
+                DurationSeconds: aws.Int64(int64(p.Duration / time.Second)),
+                RoleArn:         aws.String(p.RoleARN),
+                RoleSessionName: aws.String(p.RoleSessionName),
+                ExternalId:      p.ExternalID,
+        }
+        if p.Policy != nil {
+                input.Policy = p.Policy
+        }
+        if p.SerialNumber != nil {
+                if p.TokenCode != nil {
+                        input.SerialNumber = p.SerialNumber
+                        input.TokenCode = p.TokenCode
+                } else if p.TokenProvider != nil {
+                        input.SerialNumber = p.SerialNumber
+                        code, err := p.TokenProvider()
+                        if err != nil {
+                                return credentials.Value{ProviderName: ProviderName}, err
+                        }
+                        input.TokenCode = aws.String(code)
+                } else {
+                        return credentials.Value{ProviderName: ProviderName},
+                                awserr.New("AssumeRoleTokenNotAvailable",
+                                        "assume role with MFA enabled, but neither TokenCode nor TokenProvider are set", nil)
+                }
+        }
+
+        roleOutput, err := p.Client.AssumeRole(input)
+        if err != nil {
+                return credentials.Value{ProviderName: ProviderName}, err
+        }
+
+        // We will proactively generate new credentials before they expire.
+        p.SetExpiration(*roleOutput.Credentials.Expiration, p.ExpiryWindow)
+
+        return credentials.Value{
+                AccessKeyID:     *roleOutput.Credentials.AccessKeyId,
+                SecretAccessKey: *roleOutput.Credentials.SecretAccessKey,
+                SessionToken:    *roleOutput.Credentials.SessionToken,
+                ProviderName:    ProviderName,
+        }, nil
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/defaults/defaults.go b/vendor/github.com/aws/aws-sdk-go/aws/defaults/defaults.go
new file mode 100644
index 0000000..07afe3b
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/defaults/defaults.go
@@ -0,0 +1,163 @@
+// Package defaults is a collection of helpers to retrieve the SDK's default
+// configuration and handlers.
+//
+// Generally this package shouldn't be used directly, but session.Session
+// instead. This package is useful when you need to reset the defaults
+// of a session or service client to the SDK defaults before setting
+// additional parameters.
+package defaults
+
+import (
+        "fmt"
+        "net/http"
+        "net/url"
+        "os"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/corehandlers"
+        "github.com/aws/aws-sdk-go/aws/credentials"
+        "github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds"
+        "github.com/aws/aws-sdk-go/aws/credentials/endpointcreds"
+        "github.com/aws/aws-sdk-go/aws/ec2metadata"
+        "github.com/aws/aws-sdk-go/aws/endpoints"
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+// A Defaults provides a collection of default values for SDK clients.
+type Defaults struct {
+        Config   *aws.Config
+        Handlers request.Handlers
+}
+
+// Get returns the SDK's default values with Config and handlers pre-configured.
+func Get() Defaults {
+        cfg := Config()
+        handlers := Handlers()
+        cfg.Credentials = CredChain(cfg, handlers)
+
+        return Defaults{
+                Config:   cfg,
+                Handlers: handlers,
+        }
+}
+
+// Config returns the default configuration without credentials.
+// To retrieve a config with credentials also included use
+// `defaults.Get().Config` instead.
+//
+// Generally you shouldn't need to use this method directly, but
+// is available if you need to reset the configuration of an
+// existing service client or session.
+func Config() *aws.Config {
+        return aws.NewConfig().
+                WithCredentials(credentials.AnonymousCredentials).
+                WithRegion(os.Getenv("AWS_REGION")).
+                WithHTTPClient(http.DefaultClient).
+                WithMaxRetries(aws.UseServiceDefaultRetries).
+                WithLogger(aws.NewDefaultLogger()).
+                WithLogLevel(aws.LogOff).
+                WithEndpointResolver(endpoints.DefaultResolver())
+}
+
+// Handlers returns the default request handlers.
+//
+// Generally you shouldn't need to use this method directly, but
+// is available if you need to reset the request handlers of an
+// existing service client or session.
+func Handlers() request.Handlers {
+        var handlers request.Handlers
+
+        handlers.Validate.PushBackNamed(corehandlers.ValidateEndpointHandler)
+        handlers.Validate.AfterEachFn = request.HandlerListStopOnError
+        handlers.Build.PushBackNamed(corehandlers.SDKVersionUserAgentHandler)
+        handlers.Build.AfterEachFn = request.HandlerListStopOnError
+        handlers.Sign.PushBackNamed(corehandlers.BuildContentLengthHandler)
+        handlers.Send.PushBackNamed(corehandlers.ValidateReqSigHandler)
+        handlers.Send.PushBackNamed(corehandlers.SendHandler)
+        handlers.AfterRetry.PushBackNamed(corehandlers.AfterRetryHandler)
+        handlers.ValidateResponse.PushBackNamed(corehandlers.ValidateResponseHandler)
+
+        return handlers
+}
+
+// CredChain returns the default credential chain.
+//
+// Generally you shouldn't need to use this method directly, but
+// is available if you need to reset the credentials of an
+// existing service client or session's Config.
+func CredChain(cfg *aws.Config, handlers request.Handlers) *credentials.Credentials {
+        return credentials.NewCredentials(&credentials.ChainProvider{
+                VerboseErrors: aws.BoolValue(cfg.CredentialsChainVerboseErrors),
+                Providers: []credentials.Provider{
+                        &credentials.EnvProvider{},
+                        &credentials.SharedCredentialsProvider{Filename: "", Profile: ""},
+                        RemoteCredProvider(*cfg, handlers),
+                },
+        })
+}
+
+const (
+        httpProviderEnvVar     = "AWS_CONTAINER_CREDENTIALS_FULL_URI"
+        ecsCredsProviderEnvVar = "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI"
+)
+
+// RemoteCredProvider returns a credentials provider for the default remote
+// endpoints such as EC2 or ECS Roles.
+func RemoteCredProvider(cfg aws.Config, handlers request.Handlers) credentials.Provider {
+        if u := os.Getenv(httpProviderEnvVar); len(u) > 0 {
+                return localHTTPCredProvider(cfg, handlers, u)
+        }
+
+        if uri := os.Getenv(ecsCredsProviderEnvVar); len(uri) > 0 {
+                u := fmt.Sprintf("http://169.254.170.2%s", uri)
+                return httpCredProvider(cfg, handlers, u)
+        }
+
+        return ec2RoleProvider(cfg, handlers)
+}
+
+func localHTTPCredProvider(cfg aws.Config, handlers request.Handlers, u string) credentials.Provider {
+        var errMsg string
+
+        parsed, err := url.Parse(u)
+        if err != nil {
+                errMsg = fmt.Sprintf("invalid URL, %v", err)
+        } else if host := aws.URLHostname(parsed); !(host == "localhost" || host == "127.0.0.1") {
+                errMsg = fmt.Sprintf("invalid host address, %q, only localhost and 127.0.0.1 are valid.", host)
+        }
+
+        if len(errMsg) > 0 {
+                if cfg.Logger != nil {
+                        cfg.Logger.Log("Ignoring, HTTP credential provider", errMsg, err)
+                }
+                return credentials.ErrorProvider{
+                        Err:          awserr.New("CredentialsEndpointError", errMsg, err),
+                        ProviderName: endpointcreds.ProviderName,
+                }
+        }
+
+        return httpCredProvider(cfg, handlers, u)
+}
+
+func httpCredProvider(cfg aws.Config, handlers request.Handlers, u string) credentials.Provider {
+        return endpointcreds.NewProviderClient(cfg, handlers, u,
+                func(p *endpointcreds.Provider) {
+                        p.ExpiryWindow = 5 * time.Minute
+                },
+        )
+}
+
+func ec2RoleProvider(cfg aws.Config, handlers request.Handlers) credentials.Provider {
+        resolver := cfg.EndpointResolver
+        if resolver == nil {
+                resolver = endpoints.DefaultResolver()
+        }
+
+        e, _ := resolver.EndpointFor(endpoints.Ec2metadataServiceID, "")
+        return &ec2rolecreds.EC2RoleProvider{
+                Client:       ec2metadata.NewClient(cfg, handlers, e.URL, e.SigningRegion),
+                ExpiryWindow: 5 * time.Minute,
+        }
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/doc.go b/vendor/github.com/aws/aws-sdk-go/aws/doc.go
new file mode 100644
index 0000000..4fcb616
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/doc.go
@@ -0,0 +1,56 @@
+// Package aws provides the core SDK's utilities and shared types. Use this package's
+// utilities to simplify setting and reading API operations parameters.
+//
+// Value and Pointer Conversion Utilities
+//
+// This package includes a helper conversion utility for each scalar type the SDK's
+// API use. These utilities make getting a pointer of the scalar, and dereferencing
+// a pointer easier.
+//
+// Each conversion utility comes in two forms. Value to Pointer and Pointer to Value.
+// The Pointer to value will safely dereference the pointer and return its value.
+// If the pointer was nil, the scalar's zero value will be returned.
+//
+// The value to pointer functions will be named after the scalar type. So get a
+// *string from a string value use the "String" function. This makes it easy to
+// to get pointer of a literal string value, because getting the address of a
+// literal requires assigning the value to a variable first.
+//
+//    var strPtr *string
+//
+//    // Without the SDK's conversion functions
+//    str := "my string"
+//    strPtr = &str
+//
+//    // With the SDK's conversion functions
+//    strPtr = aws.String("my string")
+//
+//    // Convert *string to string value
+//    str = aws.StringValue(strPtr)
+//
+// In addition to scalars the aws package also includes conversion utilities for
+// map and slice for commonly types used in API parameters. The map and slice
+// conversion functions use similar naming pattern as the scalar conversion
+// functions.
+//
+//    var strPtrs []*string
+//    var strs []string = []string{"Go", "Gophers", "Go"}
+//
+//    // Convert []string to []*string
+//    strPtrs = aws.StringSlice(strs)
+//
+//    // Convert []*string to []string
+//    strs = aws.StringValueSlice(strPtrs)
+//
+// SDK Default HTTP Client
+//
+// The SDK will use the http.DefaultClient if a HTTP client is not provided to
+// the SDK's Session, or service client constructor. This means that if the
+// http.DefaultClient is modified by other components of your application the
+// modifications will be picked up by the SDK as well.
+//
+// In some cases this might be intended, but it is a better practice to create
+// a custom HTTP Client to share explicitly through your application. You can
+// configure the SDK to use the custom HTTP Client by setting the HTTPClient
+// value of the SDK's Config type when creating a Session or service client.
+package aws
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/ec2metadata/api.go b/vendor/github.com/aws/aws-sdk-go/aws/ec2metadata/api.go
new file mode 100644
index 0000000..984407a
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/ec2metadata/api.go
@@ -0,0 +1,162 @@
+package ec2metadata
+
+import (
+        "encoding/json"
+        "fmt"
+        "net/http"
+        "path"
+        "strings"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+// GetMetadata uses the path provided to request information from the EC2
+// instance metdata service. The content will be returned as a string, or
+// error if the request failed.
+func (c *EC2Metadata) GetMetadata(p string) (string, error) {
+        op := &request.Operation{
+                Name:       "GetMetadata",
+                HTTPMethod: "GET",
+                HTTPPath:   path.Join("/", "meta-data", p),
+        }
+
+        output := &metadataOutput{}
+        req := c.NewRequest(op, nil, output)
+
+        return output.Content, req.Send()
+}
+
+// GetUserData returns the userdata that was configured for the service. If
+// there is no user-data setup for the EC2 instance a "NotFoundError" error
+// code will be returned.
+func (c *EC2Metadata) GetUserData() (string, error) {
+        op := &request.Operation{
+                Name:       "GetUserData",
+                HTTPMethod: "GET",
+                HTTPPath:   path.Join("/", "user-data"),
+        }
+
+        output := &metadataOutput{}
+        req := c.NewRequest(op, nil, output)
+        req.Handlers.UnmarshalError.PushBack(func(r *request.Request) {
+                if r.HTTPResponse.StatusCode == http.StatusNotFound {
+                        r.Error = awserr.New("NotFoundError", "user-data not found", r.Error)
+                }
+        })
+
+        return output.Content, req.Send()
+}
+
+// GetDynamicData uses the path provided to request information from the EC2
+// instance metadata service for dynamic data. The content will be returned
+// as a string, or error if the request failed.
+func (c *EC2Metadata) GetDynamicData(p string) (string, error) {
+        op := &request.Operation{
+                Name:       "GetDynamicData",
+                HTTPMethod: "GET",
+                HTTPPath:   path.Join("/", "dynamic", p),
+        }
+
+        output := &metadataOutput{}
+        req := c.NewRequest(op, nil, output)
+
+        return output.Content, req.Send()
+}
+
+// GetInstanceIdentityDocument retrieves an identity document describing an
+// instance. Error is returned if the request fails or is unable to parse
+// the response.
+func (c *EC2Metadata) GetInstanceIdentityDocument() (EC2InstanceIdentityDocument, error) {
+        resp, err := c.GetDynamicData("instance-identity/document")
+        if err != nil {
+                return EC2InstanceIdentityDocument{},
+                        awserr.New("EC2MetadataRequestError",
+                                "failed to get EC2 instance identity document", err)
+        }
+
+        doc := EC2InstanceIdentityDocument{}
+        if err := json.NewDecoder(strings.NewReader(resp)).Decode(&doc); err != nil {
+                return EC2InstanceIdentityDocument{},
+                        awserr.New("SerializationError",
+                                "failed to decode EC2 instance identity document", err)
+        }
+
+        return doc, nil
+}
+
+// IAMInfo retrieves IAM info from the metadata API
+func (c *EC2Metadata) IAMInfo() (EC2IAMInfo, error) {
+        resp, err := c.GetMetadata("iam/info")
+        if err != nil {
+                return EC2IAMInfo{},
+                        awserr.New("EC2MetadataRequestError",
+                                "failed to get EC2 IAM info", err)
+        }
+
+        info := EC2IAMInfo{}
+        if err := json.NewDecoder(strings.NewReader(resp)).Decode(&info); err != nil {
+                return EC2IAMInfo{},
+                        awserr.New("SerializationError",
+                                "failed to decode EC2 IAM info", err)
+        }
+
+        if info.Code != "Success" {
+                errMsg := fmt.Sprintf("failed to get EC2 IAM Info (%s)", info.Code)
+                return EC2IAMInfo{},
+                        awserr.New("EC2MetadataError", errMsg, nil)
+        }
+
+        return info, nil
+}
+
+// Region returns the region the instance is running in.
+func (c *EC2Metadata) Region() (string, error) {
+        resp, err := c.GetMetadata("placement/availability-zone")
+        if err != nil {
+                return "", err
+        }
+
+        // returns region without the suffix. Eg: us-west-2a becomes us-west-2
+        return resp[:len(resp)-1], nil
+}
+
+// Available returns if the application has access to the EC2 Metadata service.
+// Can be used to determine if application is running within an EC2 Instance and
+// the metadata service is available.
+func (c *EC2Metadata) Available() bool {
+        if _, err := c.GetMetadata("instance-id"); err != nil {
+                return false
+        }
+
+        return true
+}
+
+// An EC2IAMInfo provides the shape for unmarshaling
+// an IAM info from the metadata API
+type EC2IAMInfo struct {
+        Code               string
+        LastUpdated        time.Time
+        InstanceProfileArn string
+        InstanceProfileID  string
+}
+
+// An EC2InstanceIdentityDocument provides the shape for unmarshaling
+// an instance identity document
+type EC2InstanceIdentityDocument struct {
+        DevpayProductCodes []string  `json:"devpayProductCodes"`
+        AvailabilityZone   string    `json:"availabilityZone"`
+        PrivateIP          string    `json:"privateIp"`
+        Version            string    `json:"version"`
+        Region             string    `json:"region"`
+        InstanceID         string    `json:"instanceId"`
+        BillingProducts    []string  `json:"billingProducts"`
+        InstanceType       string    `json:"instanceType"`
+        AccountID          string    `json:"accountId"`
+        PendingTime        time.Time `json:"pendingTime"`
+        ImageID            string    `json:"imageId"`
+        KernelID           string    `json:"kernelId"`
+        RamdiskID          string    `json:"ramdiskId"`
+        Architecture       string    `json:"architecture"`
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/ec2metadata/service.go b/vendor/github.com/aws/aws-sdk-go/aws/ec2metadata/service.go
new file mode 100644
index 0000000..5b4379d
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/ec2metadata/service.go
@@ -0,0 +1,124 @@
+// Package ec2metadata provides the client for making API calls to the
+// EC2 Metadata service.
+package ec2metadata
+
+import (
+        "bytes"
+        "errors"
+        "io"
+        "net/http"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/client"
+        "github.com/aws/aws-sdk-go/aws/client/metadata"
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+// ServiceName is the name of the service.
+const ServiceName = "ec2metadata"
+
+// A EC2Metadata is an EC2 Metadata service Client.
+type EC2Metadata struct {
+        *client.Client
+}
+
+// New creates a new instance of the EC2Metadata client with a session.
+// This client is safe to use across multiple goroutines.
+//
+//
+// Example:
+//     // Create a EC2Metadata client from just a session.
+//     svc := ec2metadata.New(mySession)
+//
+//     // Create a EC2Metadata client with additional configuration
+//     svc := ec2metadata.New(mySession, aws.NewConfig().WithLogLevel(aws.LogDebugHTTPBody))
+func New(p client.ConfigProvider, cfgs ...*aws.Config) *EC2Metadata {
+        c := p.ClientConfig(ServiceName, cfgs...)
+        return NewClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+}
+
+// NewClient returns a new EC2Metadata client. Should be used to create
+// a client when not using a session. Generally using just New with a session
+// is preferred.
+//
+// If an unmodified HTTP client is provided from the stdlib default, or no client
+// the EC2RoleProvider's EC2Metadata HTTP client's timeout will be shortened.
+// To disable this set Config.EC2MetadataDisableTimeoutOverride to false. Enabled by default.
+func NewClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion string, opts ...func(*client.Client)) *EC2Metadata {
+        if !aws.BoolValue(cfg.EC2MetadataDisableTimeoutOverride) && httpClientZero(cfg.HTTPClient) {
+                // If the http client is unmodified and this feature is not disabled
+                // set custom timeouts for EC2Metadata requests.
+                cfg.HTTPClient = &http.Client{
+                        // use a shorter timeout than default because the metadata
+                        // service is local if it is running, and to fail faster
+                        // if not running on an ec2 instance.
+                        Timeout: 5 * time.Second,
+                }
+        }
+
+        svc := &EC2Metadata{
+                Client: client.New(
+                        cfg,
+                        metadata.ClientInfo{
+                                ServiceName: ServiceName,
+                                Endpoint:    endpoint,
+                                APIVersion:  "latest",
+                        },
+                        handlers,
+                ),
+        }
+
+        svc.Handlers.Unmarshal.PushBack(unmarshalHandler)
+        svc.Handlers.UnmarshalError.PushBack(unmarshalError)
+        svc.Handlers.Validate.Clear()
+        svc.Handlers.Validate.PushBack(validateEndpointHandler)
+
+        // Add additional options to the service config
+        for _, option := range opts {
+                option(svc.Client)
+        }
+
+        return svc
+}
+
+func httpClientZero(c *http.Client) bool {
+        return c == nil || (c.Transport == nil && c.CheckRedirect == nil && c.Jar == nil && c.Timeout == 0)
+}
+
+type metadataOutput struct {
+        Content string
+}
+
+func unmarshalHandler(r *request.Request) {
+        defer r.HTTPResponse.Body.Close()
+        b := &bytes.Buffer{}
+        if _, err := io.Copy(b, r.HTTPResponse.Body); err != nil {
+                r.Error = awserr.New("SerializationError", "unable to unmarshal EC2 metadata respose", err)
+                return
+        }
+
+        if data, ok := r.Data.(*metadataOutput); ok {
+                data.Content = b.String()
+        }
+}
+
+func unmarshalError(r *request.Request) {
+        defer r.HTTPResponse.Body.Close()
+        b := &bytes.Buffer{}
+        if _, err := io.Copy(b, r.HTTPResponse.Body); err != nil {
+                r.Error = awserr.New("SerializationError", "unable to unmarshal EC2 metadata error respose", err)
+                return
+        }
+
+        // Response body format is not consistent between metadata endpoints.
+        // Grab the error message as a string and include that as the source error
+        r.Error = awserr.New("EC2MetadataError", "failed to make EC2Metadata request", errors.New(b.String()))
+}
+
+func validateEndpointHandler(r *request.Request) {
+        if r.ClientInfo.Endpoint == "" {
+                r.Error = aws.ErrMissingEndpoint
+        }
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/endpoints/decode.go b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/decode.go
new file mode 100644
index 0000000..74f72de
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/decode.go
@@ -0,0 +1,133 @@
+package endpoints
+
+import (
+        "encoding/json"
+        "fmt"
+        "io"
+
+        "github.com/aws/aws-sdk-go/aws/awserr"
+)
+
+type modelDefinition map[string]json.RawMessage
+
+// A DecodeModelOptions are the options for how the endpoints model definition
+// are decoded.
+type DecodeModelOptions struct {
+        SkipCustomizations bool
+}
+
+// Set combines all of the option functions together.
+func (d *DecodeModelOptions) Set(optFns ...func(*DecodeModelOptions)) {
+        for _, fn := range optFns {
+                fn(d)
+        }
+}
+
+// DecodeModel unmarshals a Regions and Endpoint model definition file into
+// a endpoint Resolver. If the file format is not supported, or an error occurs
+// when unmarshaling the model an error will be returned.
+//
+// Casting the return value of this func to a EnumPartitions will
+// allow you to get a list of the partitions in the order the endpoints
+// will be resolved in.
+//
+//    resolver, err := endpoints.DecodeModel(reader)
+//
+//    partitions := resolver.(endpoints.EnumPartitions).Partitions()
+//    for _, p := range partitions {
+//        // ... inspect partitions
+//    }
+func DecodeModel(r io.Reader, optFns ...func(*DecodeModelOptions)) (Resolver, error) {
+        var opts DecodeModelOptions
+        opts.Set(optFns...)
+
+        // Get the version of the partition file to determine what
+        // unmarshaling model to use.
+        modelDef := modelDefinition{}
+        if err := json.NewDecoder(r).Decode(&modelDef); err != nil {
+                return nil, newDecodeModelError("failed to decode endpoints model", err)
+        }
+
+        var version string
+        if b, ok := modelDef["version"]; ok {
+                version = string(b)
+        } else {
+                return nil, newDecodeModelError("endpoints version not found in model", nil)
+        }
+
+        if version == "3" {
+                return decodeV3Endpoints(modelDef, opts)
+        }
+
+        return nil, newDecodeModelError(
+                fmt.Sprintf("endpoints version %s, not supported", version), nil)
+}
+
+func decodeV3Endpoints(modelDef modelDefinition, opts DecodeModelOptions) (Resolver, error) {
+        b, ok := modelDef["partitions"]
+        if !ok {
+                return nil, newDecodeModelError("endpoints model missing partitions", nil)
+        }
+
+        ps := partitions{}
+        if err := json.Unmarshal(b, &ps); err != nil {
+                return nil, newDecodeModelError("failed to decode endpoints model", err)
+        }
+
+        if opts.SkipCustomizations {
+                return ps, nil
+        }
+
+        // Customization
+        for i := 0; i < len(ps); i++ {
+                p := &ps[i]
+                custAddEC2Metadata(p)
+                custAddS3DualStack(p)
+                custRmIotDataService(p)
+        }
+
+        return ps, nil
+}
+
+func custAddS3DualStack(p *partition) {
+        if p.ID != "aws" {
+                return
+        }
+
+        s, ok := p.Services["s3"]
+        if !ok {
+                return
+        }
+
+        s.Defaults.HasDualStack = boxedTrue
+        s.Defaults.DualStackHostname = "{service}.dualstack.{region}.{dnsSuffix}"
+
+        p.Services["s3"] = s
+}
+
+func custAddEC2Metadata(p *partition) {
+        p.Services["ec2metadata"] = service{
+                IsRegionalized:    boxedFalse,
+                PartitionEndpoint: "aws-global",
+                Endpoints: endpoints{
+                        "aws-global": endpoint{
+                                Hostname:  "169.254.169.254/latest",
+                                Protocols: []string{"http"},
+                        },
+                },
+        }
+}
+
+func custRmIotDataService(p *partition) {
+        delete(p.Services, "data.iot")
+}
+
+type decodeModelError struct {
+        awsError
+}
+
+func newDecodeModelError(msg string, err error) decodeModelError {
+        return decodeModelError{
+                awsError: awserr.New("DecodeEndpointsModelError", msg, err),
+        }
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/endpoints/defaults.go b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/defaults.go
new file mode 100644
index 0000000..e6d7ede
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/defaults.go
@@ -0,0 +1,2174 @@
+// Code generated by aws/endpoints/v3model_codegen.go. DO NOT EDIT.
+
+package endpoints
+
+import (
+        "regexp"
+)
+
+// Partition identifiers
+const (
+        AwsPartitionID      = "aws"        // AWS Standard partition.
+        AwsCnPartitionID    = "aws-cn"     // AWS China partition.
+        AwsUsGovPartitionID = "aws-us-gov" // AWS GovCloud (US) partition.
+)
+
+// AWS Standard partition's regions.
+const (
+        ApNortheast1RegionID = "ap-northeast-1" // Asia Pacific (Tokyo).
+        ApNortheast2RegionID = "ap-northeast-2" // Asia Pacific (Seoul).
+        ApSouth1RegionID     = "ap-south-1"     // Asia Pacific (Mumbai).
+        ApSoutheast1RegionID = "ap-southeast-1" // Asia Pacific (Singapore).
+        ApSoutheast2RegionID = "ap-southeast-2" // Asia Pacific (Sydney).
+        CaCentral1RegionID   = "ca-central-1"   // Canada (Central).
+        EuCentral1RegionID   = "eu-central-1"   // EU (Frankfurt).
+        EuWest1RegionID      = "eu-west-1"      // EU (Ireland).
+        EuWest2RegionID      = "eu-west-2"      // EU (London).
+        SaEast1RegionID      = "sa-east-1"      // South America (Sao Paulo).
+        UsEast1RegionID      = "us-east-1"      // US East (N. Virginia).
+        UsEast2RegionID      = "us-east-2"      // US East (Ohio).
+        UsWest1RegionID      = "us-west-1"      // US West (N. California).
+        UsWest2RegionID      = "us-west-2"      // US West (Oregon).
+)
+
+// AWS China partition's regions.
+const (
+        CnNorth1RegionID = "cn-north-1" // China (Beijing).
+)
+
+// AWS GovCloud (US) partition's regions.
+const (
+        UsGovWest1RegionID = "us-gov-west-1" // AWS GovCloud (US).
+)
+
+// Service identifiers
+const (
+        AcmServiceID                          = "acm"                          // Acm.
+        ApigatewayServiceID                   = "apigateway"                   // Apigateway.
+        ApplicationAutoscalingServiceID       = "application-autoscaling"      // ApplicationAutoscaling.
+        Appstream2ServiceID                   = "appstream2"                   // Appstream2.
+        AutoscalingServiceID                  = "autoscaling"                  // Autoscaling.
+        BatchServiceID                        = "batch"                        // Batch.
+        BudgetsServiceID                      = "budgets"                      // Budgets.
+        ClouddirectoryServiceID               = "clouddirectory"               // Clouddirectory.
+        CloudformationServiceID               = "cloudformation"               // Cloudformation.
+        CloudfrontServiceID                   = "cloudfront"                   // Cloudfront.
+        CloudhsmServiceID                     = "cloudhsm"                     // Cloudhsm.
+        CloudsearchServiceID                  = "cloudsearch"                  // Cloudsearch.
+        CloudtrailServiceID                   = "cloudtrail"                   // Cloudtrail.
+        CodebuildServiceID                    = "codebuild"                    // Codebuild.
+        CodecommitServiceID                   = "codecommit"                   // Codecommit.
+        CodedeployServiceID                   = "codedeploy"                   // Codedeploy.
+        CodepipelineServiceID                 = "codepipeline"                 // Codepipeline.
+        CodestarServiceID                     = "codestar"                     // Codestar.
+        CognitoIdentityServiceID              = "cognito-identity"             // CognitoIdentity.
+        CognitoIdpServiceID                   = "cognito-idp"                  // CognitoIdp.
+        CognitoSyncServiceID                  = "cognito-sync"                 // CognitoSync.
+        ConfigServiceID                       = "config"                       // Config.
+        CurServiceID                          = "cur"                          // Cur.
+        DatapipelineServiceID                 = "datapipeline"                 // Datapipeline.
+        DevicefarmServiceID                   = "devicefarm"                   // Devicefarm.
+        DirectconnectServiceID                = "directconnect"                // Directconnect.
+        DiscoveryServiceID                    = "discovery"                    // Discovery.
+        DmsServiceID                          = "dms"                          // Dms.
+        DsServiceID                           = "ds"                           // Ds.
+        DynamodbServiceID                     = "dynamodb"                     // Dynamodb.
+        Ec2ServiceID                          = "ec2"                          // Ec2.
+        Ec2metadataServiceID                  = "ec2metadata"                  // Ec2metadata.
+        EcrServiceID                          = "ecr"                          // Ecr.
+        EcsServiceID                          = "ecs"                          // Ecs.
+        ElasticacheServiceID                  = "elasticache"                  // Elasticache.
+        ElasticbeanstalkServiceID             = "elasticbeanstalk"             // Elasticbeanstalk.
+        ElasticfilesystemServiceID            = "elasticfilesystem"            // Elasticfilesystem.
+        ElasticloadbalancingServiceID         = "elasticloadbalancing"         // Elasticloadbalancing.
+        ElasticmapreduceServiceID             = "elasticmapreduce"             // Elasticmapreduce.
+        ElastictranscoderServiceID            = "elastictranscoder"            // Elastictranscoder.
+        EmailServiceID                        = "email"                        // Email.
+        EntitlementMarketplaceServiceID       = "entitlement.marketplace"      // EntitlementMarketplace.
+        EsServiceID                           = "es"                           // Es.
+        EventsServiceID                       = "events"                       // Events.
+        FirehoseServiceID                     = "firehose"                     // Firehose.
+        GameliftServiceID                     = "gamelift"                     // Gamelift.
+        GlacierServiceID                      = "glacier"                      // Glacier.
+        HealthServiceID                       = "health"                       // Health.
+        IamServiceID                          = "iam"                          // Iam.
+        ImportexportServiceID                 = "importexport"                 // Importexport.
+        InspectorServiceID                    = "inspector"                    // Inspector.
+        IotServiceID                          = "iot"                          // Iot.
+        KinesisServiceID                      = "kinesis"                      // Kinesis.
+        KinesisanalyticsServiceID             = "kinesisanalytics"             // Kinesisanalytics.
+        KmsServiceID                          = "kms"                          // Kms.
+        LambdaServiceID                       = "lambda"                       // Lambda.
+        LightsailServiceID                    = "lightsail"                    // Lightsail.
+        LogsServiceID                         = "logs"                         // Logs.
+        MachinelearningServiceID              = "machinelearning"              // Machinelearning.
+        MarketplacecommerceanalyticsServiceID = "marketplacecommerceanalytics" // Marketplacecommerceanalytics.
+        MeteringMarketplaceServiceID          = "metering.marketplace"         // MeteringMarketplace.
+        MobileanalyticsServiceID              = "mobileanalytics"              // Mobileanalytics.
+        ModelsLexServiceID                    = "models.lex"                   // ModelsLex.
+        MonitoringServiceID                   = "monitoring"                   // Monitoring.
+        MturkRequesterServiceID               = "mturk-requester"              // MturkRequester.
+        OpsworksServiceID                     = "opsworks"                     // Opsworks.
+        OpsworksCmServiceID                   = "opsworks-cm"                  // OpsworksCm.
+        OrganizationsServiceID                = "organizations"                // Organizations.
+        PinpointServiceID                     = "pinpoint"                     // Pinpoint.
+        PollyServiceID                        = "polly"                        // Polly.
+        RdsServiceID                          = "rds"                          // Rds.
+        RedshiftServiceID                     = "redshift"                     // Redshift.
+        RekognitionServiceID                  = "rekognition"                  // Rekognition.
+        Route53ServiceID                      = "route53"                      // Route53.
+        Route53domainsServiceID               = "route53domains"               // Route53domains.
+        RuntimeLexServiceID                   = "runtime.lex"                  // RuntimeLex.
+        S3ServiceID                           = "s3"                           // S3.
+        SdbServiceID                          = "sdb"                          // Sdb.
+        ServicecatalogServiceID               = "servicecatalog"               // Servicecatalog.
+        ShieldServiceID                       = "shield"                       // Shield.
+        SmsServiceID                          = "sms"                          // Sms.
+        SnowballServiceID                     = "snowball"                     // Snowball.
+        SnsServiceID                          = "sns"                          // Sns.
+        SqsServiceID                          = "sqs"                          // Sqs.
+        SsmServiceID                          = "ssm"                          // Ssm.
+        StatesServiceID                       = "states"                       // States.
+        StoragegatewayServiceID               = "storagegateway"               // Storagegateway.
+        StreamsDynamodbServiceID              = "streams.dynamodb"             // StreamsDynamodb.
+        StsServiceID                          = "sts"                          // Sts.
+        SupportServiceID                      = "support"                      // Support.
+        SwfServiceID                          = "swf"                          // Swf.
+        TaggingServiceID                      = "tagging"                      // Tagging.
+        WafServiceID                          = "waf"                          // Waf.
+        WafRegionalServiceID                  = "waf-regional"                 // WafRegional.
+        WorkdocsServiceID                     = "workdocs"                     // Workdocs.
+        WorkspacesServiceID                   = "workspaces"                   // Workspaces.
+        XrayServiceID                         = "xray"                         // Xray.
+)
+
+// DefaultResolver returns an Endpoint resolver that will be able
+// to resolve endpoints for: AWS Standard, AWS China, and AWS GovCloud (US).
+//
+// Use DefaultPartitions() to get the list of the default partitions.
+func DefaultResolver() Resolver {
+        return defaultPartitions
+}
+
+// DefaultPartitions returns a list of the partitions the SDK is bundled
+// with. The available partitions are: AWS Standard, AWS China, and AWS GovCloud (US).
+//
+//    partitions := endpoints.DefaultPartitions
+//    for _, p := range partitions {
+//        // ... inspect partitions
+//    }
+func DefaultPartitions() []Partition {
+        return defaultPartitions.Partitions()
+}
+
+var defaultPartitions = partitions{
+        awsPartition,
+        awscnPartition,
+        awsusgovPartition,
+}
+
+// AwsPartition returns the Resolver for AWS Standard.
+func AwsPartition() Partition {
+        return awsPartition.Partition()
+}
+
+var awsPartition = partition{
+        ID:        "aws",
+        Name:      "AWS Standard",
+        DNSSuffix: "amazonaws.com",
+        RegionRegex: regionRegex{
+                Regexp: func() *regexp.Regexp {
+                        reg, _ := regexp.Compile("^(us|eu|ap|sa|ca)\\-\\w+\\-\\d+$")
+                        return reg
+                }(),
+        },
+        Defaults: endpoint{
+                Hostname:          "{service}.{region}.{dnsSuffix}",
+                Protocols:         []string{"https"},
+                SignatureVersions: []string{"v4"},
+        },
+        Regions: regions{
+                "ap-northeast-1": region{
+                        Description: "Asia Pacific (Tokyo)",
+                },
+                "ap-northeast-2": region{
+                        Description: "Asia Pacific (Seoul)",
+                },
+                "ap-south-1": region{
+                        Description: "Asia Pacific (Mumbai)",
+                },
+                "ap-southeast-1": region{
+                        Description: "Asia Pacific (Singapore)",
+                },
+                "ap-southeast-2": region{
+                        Description: "Asia Pacific (Sydney)",
+                },
+                "ca-central-1": region{
+                        Description: "Canada (Central)",
+                },
+                "eu-central-1": region{
+                        Description: "EU (Frankfurt)",
+                },
+                "eu-west-1": region{
+                        Description: "EU (Ireland)",
+                },
+                "eu-west-2": region{
+                        Description: "EU (London)",
+                },
+                "sa-east-1": region{
+                        Description: "South America (Sao Paulo)",
+                },
+                "us-east-1": region{
+                        Description: "US East (N. Virginia)",
+                },
+                "us-east-2": region{
+                        Description: "US East (Ohio)",
+                },
+                "us-west-1": region{
+                        Description: "US West (N. California)",
+                },
+                "us-west-2": region{
+                        Description: "US West (Oregon)",
+                },
+        },
+        Services: services{
+                "acm": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "apigateway": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "application-autoscaling": service{
+                        Defaults: endpoint{
+                                Hostname:  "autoscaling.{region}.amazonaws.com",
+                                Protocols: []string{"http", "https"},
+                                CredentialScope: credentialScope{
+                                        Service: "application-autoscaling",
+                                },
+                        },
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "appstream2": service{
+                        Defaults: endpoint{
+                                Protocols: []string{"https"},
+                                CredentialScope: credentialScope{
+                                        Service: "appstream",
+                                },
+                        },
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "autoscaling": service{
+                        Defaults: endpoint{
+                                Protocols: []string{"http", "https"},
+                        },
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "batch": service{
+
+                        Endpoints: endpoints{
+                                "us-east-1": endpoint{},
+                        },
+                },
+                "budgets": service{
+                        PartitionEndpoint: "aws-global",
+                        IsRegionalized:    boxedFalse,
+
+                        Endpoints: endpoints{
+                                "aws-global": endpoint{
+                                        Hostname: "budgets.amazonaws.com",
+                                        CredentialScope: credentialScope{
+                                                Region: "us-east-1",
+                                        },
+                                },
+                        },
+                },
+                "clouddirectory": service{
+
+                        Endpoints: endpoints{
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "cloudformation": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "cloudfront": service{
+                        PartitionEndpoint: "aws-global",
+                        IsRegionalized:    boxedFalse,
+
+                        Endpoints: endpoints{
+                                "aws-global": endpoint{
+                                        Hostname:  "cloudfront.amazonaws.com",
+                                        Protocols: []string{"http", "https"},
+                                        CredentialScope: credentialScope{
+                                                Region: "us-east-1",
+                                        },
+                                },
+                        },
+                },
+                "cloudhsm": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "cloudsearch": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "cloudtrail": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "codebuild": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "codecommit": service{
+
+                        Endpoints: endpoints{
+                                "eu-west-1": endpoint{},
+                                "us-east-1": endpoint{},
+                                "us-east-2": endpoint{},
+                                "us-west-2": endpoint{},
+                        },
+                },
+                "codedeploy": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "codepipeline": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "codestar": service{
+
+                        Endpoints: endpoints{
+                                "eu-west-1": endpoint{},
+                                "us-east-1": endpoint{},
+                                "us-east-2": endpoint{},
+                                "us-west-2": endpoint{},
+                        },
+                },
+                "cognito-identity": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "cognito-idp": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "cognito-sync": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "config": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "cur": service{
+
+                        Endpoints: endpoints{
+                                "us-east-1": endpoint{},
+                        },
+                },
+                "datapipeline": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "devicefarm": service{
+
+                        Endpoints: endpoints{
+                                "us-west-2": endpoint{},
+                        },
+                },
+                "directconnect": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "discovery": service{
+
+                        Endpoints: endpoints{
+                                "us-west-2": endpoint{},
+                        },
+                },
+                "dms": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "ds": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "dynamodb": service{
+                        Defaults: endpoint{
+                                Protocols: []string{"http", "https"},
+                        },
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "local": endpoint{
+                                        Hostname:  "localhost:8000",
+                                        Protocols: []string{"http"},
+                                        CredentialScope: credentialScope{
+                                                Region: "us-east-1",
+                                        },
+                                },
+                                "sa-east-1": endpoint{},
+                                "us-east-1": endpoint{},
+                                "us-east-2": endpoint{},
+                                "us-west-1": endpoint{},
+                                "us-west-2": endpoint{},
+                        },
+                },
+                "ec2": service{
+                        Defaults: endpoint{
+                                Protocols: []string{"http", "https"},
+                        },
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "ec2metadata": service{
+                        PartitionEndpoint: "aws-global",
+                        IsRegionalized:    boxedFalse,
+
+                        Endpoints: endpoints{
+                                "aws-global": endpoint{
+                                        Hostname:  "169.254.169.254/latest",
+                                        Protocols: []string{"http"},
+                                },
+                        },
+                },
+                "ecr": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "ecs": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "elasticache": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "elasticbeanstalk": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "elasticfilesystem": service{
+
+                        Endpoints: endpoints{
+                                "ap-southeast-2": endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "elasticloadbalancing": service{
+                        Defaults: endpoint{
+                                Protocols: []string{"http", "https"},
+                        },
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "elasticmapreduce": service{
+                        Defaults: endpoint{
+                                SSLCommonName: "{region}.{service}.{dnsSuffix}",
+                                Protocols:     []string{"http", "https"},
+                        },
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1": endpoint{
+                                        SSLCommonName: "{service}.{region}.{dnsSuffix}",
+                                },
+                                "eu-west-1": endpoint{},
+                                "eu-west-2": endpoint{},
+                                "sa-east-1": endpoint{},
+                                "us-east-1": endpoint{
+                                        SSLCommonName: "{service}.{region}.{dnsSuffix}",
+                                },
+                                "us-east-2": endpoint{},
+                                "us-west-1": endpoint{},
+                                "us-west-2": endpoint{},
+                        },
+                },
+                "elastictranscoder": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "email": service{
+
+                        Endpoints: endpoints{
+                                "eu-west-1": endpoint{},
+                                "us-east-1": endpoint{},
+                                "us-west-2": endpoint{},
+                        },
+                },
+                "entitlement.marketplace": service{
+                        Defaults: endpoint{
+                                CredentialScope: credentialScope{
+                                        Service: "aws-marketplace",
+                                },
+                        },
+                        Endpoints: endpoints{
+                                "us-east-1": endpoint{},
+                        },
+                },
+                "es": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "events": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "firehose": service{
+
+                        Endpoints: endpoints{
+                                "eu-west-1": endpoint{},
+                                "us-east-1": endpoint{},
+                                "us-west-2": endpoint{},
+                        },
+                },
+                "gamelift": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "glacier": service{
+                        Defaults: endpoint{
+                                Protocols: []string{"http", "https"},
+                        },
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "health": service{
+
+                        Endpoints: endpoints{
+                                "us-east-1": endpoint{},
+                        },
+                },
+                "iam": service{
+                        PartitionEndpoint: "aws-global",
+                        IsRegionalized:    boxedFalse,
+
+                        Endpoints: endpoints{
+                                "aws-global": endpoint{
+                                        Hostname: "iam.amazonaws.com",
+                                        CredentialScope: credentialScope{
+                                                Region: "us-east-1",
+                                        },
+                                },
+                        },
+                },
+                "importexport": service{
+                        PartitionEndpoint: "aws-global",
+                        IsRegionalized:    boxedFalse,
+
+                        Endpoints: endpoints{
+                                "aws-global": endpoint{
+                                        Hostname:          "importexport.amazonaws.com",
+                                        SignatureVersions: []string{"v2", "v4"},
+                                        CredentialScope: credentialScope{
+                                                Region:  "us-east-1",
+                                                Service: "IngestionService",
+                                        },
+                                },
+                        },
+                },
+                "inspector": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "iot": service{
+                        Defaults: endpoint{
+                                CredentialScope: credentialScope{
+                                        Service: "execute-api",
+                                },
+                        },
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "kinesis": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "kinesisanalytics": service{
+
+                        Endpoints: endpoints{
+                                "eu-west-1": endpoint{},
+                                "us-east-1": endpoint{},
+                                "us-west-2": endpoint{},
+                        },
+                },
+                "kms": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "lambda": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "lightsail": service{
+
+                        Endpoints: endpoints{
+                                "us-east-1": endpoint{},
+                        },
+                },
+                "logs": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "machinelearning": service{
+
+                        Endpoints: endpoints{
+                                "eu-west-1": endpoint{},
+                                "us-east-1": endpoint{},
+                        },
+                },
+                "marketplacecommerceanalytics": service{
+
+                        Endpoints: endpoints{
+                                "us-east-1": endpoint{},
+                        },
+                },
+                "metering.marketplace": service{
+                        Defaults: endpoint{
+                                CredentialScope: credentialScope{
+                                        Service: "aws-marketplace",
+                                },
+                        },
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "mobileanalytics": service{
+
+                        Endpoints: endpoints{
+                                "us-east-1": endpoint{},
+                        },
+                },
+                "models.lex": service{
+                        Defaults: endpoint{
+                                CredentialScope: credentialScope{
+                                        Service: "lex",
+                                },
+                        },
+                        Endpoints: endpoints{
+                                "us-east-1": endpoint{},
+                        },
+                },
+                "monitoring": service{
+                        Defaults: endpoint{
+                                Protocols: []string{"http", "https"},
+                        },
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "mturk-requester": service{
+                        IsRegionalized: boxedFalse,
+
+                        Endpoints: endpoints{
+                                "sandbox": endpoint{
+                                        Hostname: "mturk-requester-sandbox.us-east-1.amazonaws.com",
+                                },
+                                "us-east-1": endpoint{},
+                        },
+                },
+                "opsworks": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "opsworks-cm": service{
+
+                        Endpoints: endpoints{
+                                "eu-west-1": endpoint{},
+                                "us-east-1": endpoint{},
+                                "us-west-2": endpoint{},
+                        },
+                },
+                "organizations": service{
+                        PartitionEndpoint: "aws-global",
+                        IsRegionalized:    boxedFalse,
+
+                        Endpoints: endpoints{
+                                "aws-global": endpoint{
+                                        Hostname: "organizations.us-east-1.amazonaws.com",
+                                        CredentialScope: credentialScope{
+                                                Region: "us-east-1",
+                                        },
+                                },
+                        },
+                },
+                "pinpoint": service{
+                        Defaults: endpoint{
+                                CredentialScope: credentialScope{
+                                        Service: "mobiletargeting",
+                                },
+                        },
+                        Endpoints: endpoints{
+                                "us-east-1": endpoint{},
+                        },
+                },
+                "polly": service{
+
+                        Endpoints: endpoints{
+                                "eu-west-1": endpoint{},
+                                "us-east-1": endpoint{},
+                                "us-east-2": endpoint{},
+                                "us-west-2": endpoint{},
+                        },
+                },
+                "rds": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1": endpoint{
+                                        SSLCommonName: "{service}.{dnsSuffix}",
+                                },
+                                "us-east-2": endpoint{},
+                                "us-west-1": endpoint{},
+                                "us-west-2": endpoint{},
+                        },
+                },
+                "redshift": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "rekognition": service{
+
+                        Endpoints: endpoints{
+                                "eu-west-1": endpoint{},
+                                "us-east-1": endpoint{},
+                                "us-west-2": endpoint{},
+                        },
+                },
+                "route53": service{
+                        PartitionEndpoint: "aws-global",
+                        IsRegionalized:    boxedFalse,
+
+                        Endpoints: endpoints{
+                                "aws-global": endpoint{
+                                        Hostname: "route53.amazonaws.com",
+                                        CredentialScope: credentialScope{
+                                                Region: "us-east-1",
+                                        },
+                                },
+                        },
+                },
+                "route53domains": service{
+
+                        Endpoints: endpoints{
+                                "us-east-1": endpoint{},
+                        },
+                },
+                "runtime.lex": service{
+                        Defaults: endpoint{
+                                CredentialScope: credentialScope{
+                                        Service: "lex",
+                                },
+                        },
+                        Endpoints: endpoints{
+                                "us-east-1": endpoint{},
+                        },
+                },
+                "s3": service{
+                        PartitionEndpoint: "us-east-1",
+                        IsRegionalized:    boxedTrue,
+                        Defaults: endpoint{
+                                Protocols:         []string{"http", "https"},
+                                SignatureVersions: []string{"s3v4"},
+
+                                HasDualStack:      boxedTrue,
+                                DualStackHostname: "{service}.dualstack.{region}.{dnsSuffix}",
+                        },
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{
+                                        Hostname:          "s3-ap-northeast-1.amazonaws.com",
+                                        SignatureVersions: []string{"s3", "s3v4"},
+                                },
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{
+                                        Hostname:          "s3-ap-southeast-1.amazonaws.com",
+                                        SignatureVersions: []string{"s3", "s3v4"},
+                                },
+                                "ap-southeast-2": endpoint{
+                                        Hostname:          "s3-ap-southeast-2.amazonaws.com",
+                                        SignatureVersions: []string{"s3", "s3v4"},
+                                },
+                                "ca-central-1": endpoint{},
+                                "eu-central-1": endpoint{},
+                                "eu-west-1": endpoint{
+                                        Hostname:          "s3-eu-west-1.amazonaws.com",
+                                        SignatureVersions: []string{"s3", "s3v4"},
+                                },
+                                "eu-west-2": endpoint{},
+                                "s3-external-1": endpoint{
+                                        Hostname:          "s3-external-1.amazonaws.com",
+                                        SignatureVersions: []string{"s3", "s3v4"},
+                                        CredentialScope: credentialScope{
+                                                Region: "us-east-1",
+                                        },
+                                },
+                                "sa-east-1": endpoint{
+                                        Hostname:          "s3-sa-east-1.amazonaws.com",
+                                        SignatureVersions: []string{"s3", "s3v4"},
+                                },
+                                "us-east-1": endpoint{
+                                        Hostname:          "s3.amazonaws.com",
+                                        SignatureVersions: []string{"s3", "s3v4"},
+                                },
+                                "us-east-2": endpoint{},
+                                "us-west-1": endpoint{
+                                        Hostname:          "s3-us-west-1.amazonaws.com",
+                                        SignatureVersions: []string{"s3", "s3v4"},
+                                },
+                                "us-west-2": endpoint{
+                                        Hostname:          "s3-us-west-2.amazonaws.com",
+                                        SignatureVersions: []string{"s3", "s3v4"},
+                                },
+                        },
+                },
+                "sdb": service{
+                        Defaults: endpoint{
+                                Protocols:         []string{"http", "https"},
+                                SignatureVersions: []string{"v2"},
+                        },
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1": endpoint{
+                                        Hostname: "sdb.amazonaws.com",
+                                },
+                                "us-west-1": endpoint{},
+                                "us-west-2": endpoint{},
+                        },
+                },
+                "servicecatalog": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "shield": service{
+                        IsRegionalized: boxedFalse,
+                        Defaults: endpoint{
+                                SSLCommonName: "Shield.us-east-1.amazonaws.com",
+                                Protocols:     []string{"https"},
+                        },
+                        Endpoints: endpoints{
+                                "us-east-1": endpoint{},
+                        },
+                },
+                "sms": service{
+
+                        Endpoints: endpoints{
+                                "ap-southeast-2": endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                        },
+                },
+                "snowball": service{
+
+                        Endpoints: endpoints{
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "sns": service{
+                        Defaults: endpoint{
+                                Protocols: []string{"http", "https"},
+                        },
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "sqs": service{
+                        Defaults: endpoint{
+                                SSLCommonName: "{region}.queue.{dnsSuffix}",
+                                Protocols:     []string{"http", "https"},
+                        },
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1": endpoint{
+                                        SSLCommonName: "queue.{dnsSuffix}",
+                                },
+                                "us-east-2": endpoint{},
+                                "us-west-1": endpoint{},
+                                "us-west-2": endpoint{},
+                        },
+                },
+                "ssm": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "states": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "storagegateway": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "streams.dynamodb": service{
+                        Defaults: endpoint{
+                                Protocols: []string{"http", "http", "https", "https"},
+                                CredentialScope: credentialScope{
+                                        Service: "dynamodb",
+                                },
+                        },
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "local": endpoint{
+                                        Hostname:  "localhost:8000",
+                                        Protocols: []string{"http"},
+                                        CredentialScope: credentialScope{
+                                                Region: "us-east-1",
+                                        },
+                                },
+                                "sa-east-1": endpoint{},
+                                "us-east-1": endpoint{},
+                                "us-east-2": endpoint{},
+                                "us-west-1": endpoint{},
+                                "us-west-2": endpoint{},
+                        },
+                },
+                "sts": service{
+                        PartitionEndpoint: "aws-global",
+                        Defaults: endpoint{
+                                Hostname: "sts.amazonaws.com",
+                                CredentialScope: credentialScope{
+                                        Region: "us-east-1",
+                                },
+                        },
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{
+                                        Hostname: "sts.ap-northeast-2.amazonaws.com",
+                                        CredentialScope: credentialScope{
+                                                Region: "ap-northeast-2",
+                                        },
+                                },
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "aws-global":     endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "support": service{
+
+                        Endpoints: endpoints{
+                                "us-east-1": endpoint{},
+                        },
+                },
+                "swf": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "tagging": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "ca-central-1":   endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "eu-west-2":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "waf": service{
+                        PartitionEndpoint: "aws-global",
+                        IsRegionalized:    boxedFalse,
+
+                        Endpoints: endpoints{
+                                "aws-global": endpoint{
+                                        Hostname: "waf.amazonaws.com",
+                                        CredentialScope: credentialScope{
+                                                Region: "us-east-1",
+                                        },
+                                },
+                        },
+                },
+                "waf-regional": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "workdocs": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "workspaces": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+                "xray": service{
+
+                        Endpoints: endpoints{
+                                "ap-northeast-1": endpoint{},
+                                "ap-northeast-2": endpoint{},
+                                "ap-south-1":     endpoint{},
+                                "ap-southeast-1": endpoint{},
+                                "ap-southeast-2": endpoint{},
+                                "eu-central-1":   endpoint{},
+                                "eu-west-1":      endpoint{},
+                                "sa-east-1":      endpoint{},
+                                "us-east-1":      endpoint{},
+                                "us-east-2":      endpoint{},
+                                "us-west-1":      endpoint{},
+                                "us-west-2":      endpoint{},
+                        },
+                },
+        },
+}
+
+// AwsCnPartition returns the Resolver for AWS China.
+func AwsCnPartition() Partition {
+        return awscnPartition.Partition()
+}
+
+var awscnPartition = partition{
+        ID:        "aws-cn",
+        Name:      "AWS China",
+        DNSSuffix: "amazonaws.com.cn",
+        RegionRegex: regionRegex{
+                Regexp: func() *regexp.Regexp {
+                        reg, _ := regexp.Compile("^cn\\-\\w+\\-\\d+$")
+                        return reg
+                }(),
+        },
+        Defaults: endpoint{
+                Hostname:          "{service}.{region}.{dnsSuffix}",
+                Protocols:         []string{"https"},
+                SignatureVersions: []string{"v4"},
+        },
+        Regions: regions{
+                "cn-north-1": region{
+                        Description: "China (Beijing)",
+                },
+        },
+        Services: services{
+                "autoscaling": service{
+                        Defaults: endpoint{
+                                Protocols: []string{"http", "https"},
+                        },
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "cloudformation": service{
+
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "cloudtrail": service{
+
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "codedeploy": service{
+
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "config": service{
+
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "directconnect": service{
+
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "dynamodb": service{
+                        Defaults: endpoint{
+                                Protocols: []string{"http", "https"},
+                        },
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "ec2": service{
+                        Defaults: endpoint{
+                                Protocols: []string{"http", "https"},
+                        },
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "ec2metadata": service{
+                        PartitionEndpoint: "aws-global",
+                        IsRegionalized:    boxedFalse,
+
+                        Endpoints: endpoints{
+                                "aws-global": endpoint{
+                                        Hostname:  "169.254.169.254/latest",
+                                        Protocols: []string{"http"},
+                                },
+                        },
+                },
+                "elasticache": service{
+
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "elasticbeanstalk": service{
+
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "elasticloadbalancing": service{
+                        Defaults: endpoint{
+                                Protocols: []string{"http", "https"},
+                        },
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "elasticmapreduce": service{
+                        Defaults: endpoint{
+                                Protocols: []string{"http", "https"},
+                        },
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "events": service{
+
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "glacier": service{
+                        Defaults: endpoint{
+                                Protocols: []string{"http", "https"},
+                        },
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "iam": service{
+                        PartitionEndpoint: "aws-cn-global",
+                        IsRegionalized:    boxedFalse,
+
+                        Endpoints: endpoints{
+                                "aws-cn-global": endpoint{
+                                        Hostname: "iam.cn-north-1.amazonaws.com.cn",
+                                        CredentialScope: credentialScope{
+                                                Region: "cn-north-1",
+                                        },
+                                },
+                        },
+                },
+                "kinesis": service{
+
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "logs": service{
+
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "monitoring": service{
+                        Defaults: endpoint{
+                                Protocols: []string{"http", "https"},
+                        },
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "rds": service{
+
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "redshift": service{
+
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "s3": service{
+                        Defaults: endpoint{
+                                Protocols:         []string{"http", "https"},
+                                SignatureVersions: []string{"s3v4"},
+                        },
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "sns": service{
+                        Defaults: endpoint{
+                                Protocols: []string{"http", "https"},
+                        },
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "sqs": service{
+                        Defaults: endpoint{
+                                SSLCommonName: "{region}.queue.{dnsSuffix}",
+                                Protocols:     []string{"http", "https"},
+                        },
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "storagegateway": service{
+
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "streams.dynamodb": service{
+                        Defaults: endpoint{
+                                Protocols: []string{"http", "http", "https", "https"},
+                                CredentialScope: credentialScope{
+                                        Service: "dynamodb",
+                                },
+                        },
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "sts": service{
+
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "swf": service{
+
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+                "tagging": service{
+
+                        Endpoints: endpoints{
+                                "cn-north-1": endpoint{},
+                        },
+                },
+        },
+}
+
+// AwsUsGovPartition returns the Resolver for AWS GovCloud (US).
+func AwsUsGovPartition() Partition {
+        return awsusgovPartition.Partition()
+}
+
+var awsusgovPartition = partition{
+        ID:        "aws-us-gov",
+        Name:      "AWS GovCloud (US)",
+        DNSSuffix: "amazonaws.com",
+        RegionRegex: regionRegex{
+                Regexp: func() *regexp.Regexp {
+                        reg, _ := regexp.Compile("^us\\-gov\\-\\w+\\-\\d+$")
+                        return reg
+                }(),
+        },
+        Defaults: endpoint{
+                Hostname:          "{service}.{region}.{dnsSuffix}",
+                Protocols:         []string{"https"},
+                SignatureVersions: []string{"v4"},
+        },
+        Regions: regions{
+                "us-gov-west-1": region{
+                        Description: "AWS GovCloud (US)",
+                },
+        },
+        Services: services{
+                "autoscaling": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{
+                                        Protocols: []string{"http", "https"},
+                                },
+                        },
+                },
+                "cloudformation": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{},
+                        },
+                },
+                "cloudhsm": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{},
+                        },
+                },
+                "cloudtrail": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{},
+                        },
+                },
+                "config": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{},
+                        },
+                },
+                "directconnect": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{},
+                        },
+                },
+                "dynamodb": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{},
+                        },
+                },
+                "ec2": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{},
+                        },
+                },
+                "ec2metadata": service{
+                        PartitionEndpoint: "aws-global",
+                        IsRegionalized:    boxedFalse,
+
+                        Endpoints: endpoints{
+                                "aws-global": endpoint{
+                                        Hostname:  "169.254.169.254/latest",
+                                        Protocols: []string{"http"},
+                                },
+                        },
+                },
+                "elasticache": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{},
+                        },
+                },
+                "elasticloadbalancing": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{
+                                        Protocols: []string{"http", "https"},
+                                },
+                        },
+                },
+                "elasticmapreduce": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{
+                                        Protocols: []string{"http", "https"},
+                                },
+                        },
+                },
+                "glacier": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{
+                                        Protocols: []string{"http", "https"},
+                                },
+                        },
+                },
+                "iam": service{
+                        PartitionEndpoint: "aws-us-gov-global",
+                        IsRegionalized:    boxedFalse,
+
+                        Endpoints: endpoints{
+                                "aws-us-gov-global": endpoint{
+                                        Hostname: "iam.us-gov.amazonaws.com",
+                                        CredentialScope: credentialScope{
+                                                Region: "us-gov-west-1",
+                                        },
+                                },
+                        },
+                },
+                "kinesis": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{},
+                        },
+                },
+                "kms": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{},
+                        },
+                },
+                "logs": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{},
+                        },
+                },
+                "monitoring": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{},
+                        },
+                },
+                "rds": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{},
+                        },
+                },
+                "redshift": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{},
+                        },
+                },
+                "s3": service{
+                        Defaults: endpoint{
+                                SignatureVersions: []string{"s3", "s3v4"},
+                        },
+                        Endpoints: endpoints{
+                                "fips-us-gov-west-1": endpoint{
+                                        Hostname: "s3-fips-us-gov-west-1.amazonaws.com",
+                                        CredentialScope: credentialScope{
+                                                Region: "us-gov-west-1",
+                                        },
+                                },
+                                "us-gov-west-1": endpoint{
+                                        Hostname:  "s3-us-gov-west-1.amazonaws.com",
+                                        Protocols: []string{"http", "https"},
+                                },
+                        },
+                },
+                "snowball": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{},
+                        },
+                },
+                "sns": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{
+                                        Protocols: []string{"http", "https"},
+                                },
+                        },
+                },
+                "sqs": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{
+                                        SSLCommonName: "{region}.queue.{dnsSuffix}",
+                                        Protocols:     []string{"http", "https"},
+                                },
+                        },
+                },
+                "streams.dynamodb": service{
+                        Defaults: endpoint{
+                                CredentialScope: credentialScope{
+                                        Service: "dynamodb",
+                                },
+                        },
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{},
+                        },
+                },
+                "sts": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{},
+                        },
+                },
+                "swf": service{
+
+                        Endpoints: endpoints{
+                                "us-gov-west-1": endpoint{},
+                        },
+                },
+        },
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/endpoints/doc.go b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/doc.go
new file mode 100644
index 0000000..a0e9bc4
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/doc.go
@@ -0,0 +1,66 @@
+// Package endpoints provides the types and functionality for defining regions
+// and endpoints, as well as querying those definitions.
+//
+// The SDK's Regions and Endpoints metadata is code generated into the endpoints
+// package, and is accessible via the DefaultResolver function. This function
+// returns a endpoint Resolver will search the metadata and build an associated
+// endpoint if one is found. The default resolver will search all partitions
+// known by the SDK. e.g AWS Standard (aws), AWS China (aws-cn), and
+// AWS GovCloud (US) (aws-us-gov).
+// .
+//
+// Enumerating Regions and Endpoint Metadata
+//
+// Casting the Resolver returned by DefaultResolver to a EnumPartitions interface
+// will allow you to get access to the list of underlying Partitions with the
+// Partitions method. This is helpful if you want to limit the SDK's endpoint
+// resolving to a single partition, or enumerate regions, services, and endpoints
+// in the partition.
+//
+//     resolver := endpoints.DefaultResolver()
+//     partitions := resolver.(endpoints.EnumPartitions).Partitions()
+//
+//     for _, p := range partitions {
+//         fmt.Println("Regions for", p.Name)
+//         for id, _ := range p.Regions() {
+//             fmt.Println("*", id)
+//         }
+//
+//         fmt.Println("Services for", p.Name)
+//         for id, _ := range p.Services() {
+//             fmt.Println("*", id)
+//         }
+//     }
+//
+// Using Custom Endpoints
+//
+// The endpoints package also gives you the ability to use your own logic how
+// endpoints are resolved. This is a great way to define a custom endpoint
+// for select services, without passing that logic down through your code.
+//
+// If a type implements the Resolver interface it can be used to resolve
+// endpoints. To use this with the SDK's Session and Config set the value
+// of the type to the EndpointsResolver field of aws.Config when initializing
+// the session, or service client.
+//
+// In addition the ResolverFunc is a wrapper for a func matching the signature
+// of Resolver.EndpointFor, converting it to a type that satisfies the
+// Resolver interface.
+//
+//
+//     myCustomResolver := func(service, region string, optFns ...func(*endpoints.Options)) (endpoints.ResolvedEndpoint, error) {
+//         if service == endpoints.S3ServiceID {
+//             return endpoints.ResolvedEndpoint{
+//                 URL:           "s3.custom.endpoint.com",
+//                 SigningRegion: "custom-signing-region",
+//             }, nil
+//         }
+//
+//         return endpoints.DefaultResolver().EndpointFor(service, region, optFns...)
+//     }
+//
+//     sess := session.Must(session.NewSession(&aws.Config{
+//         Region:           aws.String("us-west-2"),
+//         EndpointResolver: endpoints.ResolverFunc(myCustomResolver),
+//     }))
+package endpoints
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/endpoints/endpoints.go b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/endpoints.go
new file mode 100644
index 0000000..9c3eedb
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/endpoints.go
@@ -0,0 +1,439 @@
+package endpoints
+
+import (
+        "fmt"
+        "regexp"
+
+        "github.com/aws/aws-sdk-go/aws/awserr"
+)
+
+// Options provide the configuration needed to direct how the
+// endpoints will be resolved.
+type Options struct {
+        // DisableSSL forces the endpoint to be resolved as HTTP.
+        // instead of HTTPS if the service supports it.
+        DisableSSL bool
+
+        // Sets the resolver to resolve the endpoint as a dualstack endpoint
+        // for the service. If dualstack support for a service is not known and
+        // StrictMatching is not enabled a dualstack endpoint for the service will
+        // be returned. This endpoint may not be valid. If StrictMatching is
+        // enabled only services that are known to support dualstack will return
+        // dualstack endpoints.
+        UseDualStack bool
+
+        // Enables strict matching of services and regions resolved endpoints.
+        // If the partition doesn't enumerate the exact service and region an
+        // error will be returned. This option will prevent returning endpoints
+        // that look valid, but may not resolve to any real endpoint.
+        StrictMatching bool
+
+        // Enables resolving a service endpoint based on the region provided if the
+        // service does not exist. The service endpoint ID will be used as the service
+        // domain name prefix. By default the endpoint resolver requires the service
+        // to be known when resolving endpoints.
+        //
+        // If resolving an endpoint on the partition list the provided region will
+        // be used to determine which partition's domain name pattern to the service
+        // endpoint ID with. If both the service and region are unkonwn and resolving
+        // the endpoint on partition list an UnknownEndpointError error will be returned.
+        //
+        // If resolving and endpoint on a partition specific resolver that partition's
+        // domain name pattern will be used with the service endpoint ID. If both
+        // region and service do not exist when resolving an endpoint on a specific
+        // partition the partition's domain pattern will be used to combine the
+        // endpoint and region together.
+        //
+        // This option is ignored if StrictMatching is enabled.
+        ResolveUnknownService bool
+}
+
+// Set combines all of the option functions together.
+func (o *Options) Set(optFns ...func(*Options)) {
+        for _, fn := range optFns {
+                fn(o)
+        }
+}
+
+// DisableSSLOption sets the DisableSSL options. Can be used as a functional
+// option when resolving endpoints.
+func DisableSSLOption(o *Options) {
+        o.DisableSSL = true
+}
+
+// UseDualStackOption sets the UseDualStack option. Can be used as a functional
+// option when resolving endpoints.
+func UseDualStackOption(o *Options) {
+        o.UseDualStack = true
+}
+
+// StrictMatchingOption sets the StrictMatching option. Can be used as a functional
+// option when resolving endpoints.
+func StrictMatchingOption(o *Options) {
+        o.StrictMatching = true
+}
+
+// ResolveUnknownServiceOption sets the ResolveUnknownService option. Can be used
+// as a functional option when resolving endpoints.
+func ResolveUnknownServiceOption(o *Options) {
+        o.ResolveUnknownService = true
+}
+
+// A Resolver provides the interface for functionality to resolve endpoints.
+// The build in Partition and DefaultResolver return value satisfy this interface.
+type Resolver interface {
+        EndpointFor(service, region string, opts ...func(*Options)) (ResolvedEndpoint, error)
+}
+
+// ResolverFunc is a helper utility that wraps a function so it satisfies the
+// Resolver interface. This is useful when you want to add additional endpoint
+// resolving logic, or stub out specific endpoints with custom values.
+type ResolverFunc func(service, region string, opts ...func(*Options)) (ResolvedEndpoint, error)
+
+// EndpointFor wraps the ResolverFunc function to satisfy the Resolver interface.
+func (fn ResolverFunc) EndpointFor(service, region string, opts ...func(*Options)) (ResolvedEndpoint, error) {
+        return fn(service, region, opts...)
+}
+
+var schemeRE = regexp.MustCompile("^([^:]+)://")
+
+// AddScheme adds the HTTP or HTTPS schemes to a endpoint URL if there is no
+// scheme. If disableSSL is true HTTP will set HTTP instead of the default HTTPS.
+//
+// If disableSSL is set, it will only set the URL's scheme if the URL does not
+// contain a scheme.
+func AddScheme(endpoint string, disableSSL bool) string {
+        if !schemeRE.MatchString(endpoint) {
+                scheme := "https"
+                if disableSSL {
+                        scheme = "http"
+                }
+                endpoint = fmt.Sprintf("%s://%s", scheme, endpoint)
+        }
+
+        return endpoint
+}
+
+// EnumPartitions a provides a way to retrieve the underlying partitions that
+// make up the SDK's default Resolver, or any resolver decoded from a model
+// file.
+//
+// Use this interface with DefaultResolver and DecodeModels to get the list of
+// Partitions.
+type EnumPartitions interface {
+        Partitions() []Partition
+}
+
+// RegionsForService returns a map of regions for the partition and service.
+// If either the partition or service does not exist false will be returned
+// as the second parameter.
+//
+// This example shows how  to get the regions for DynamoDB in the AWS partition.
+//    rs, exists := endpoints.RegionsForService(endpoints.DefaultPartitions(), endpoints.AwsPartitionID, endpoints.DynamodbServiceID)
+//
+// This is equivalent to using the partition directly.
+//    rs := endpoints.AwsPartition().Services()[endpoints.DynamodbServiceID].Regions()
+func RegionsForService(ps []Partition, partitionID, serviceID string) (map[string]Region, bool) {
+        for _, p := range ps {
+                if p.ID() != partitionID {
+                        continue
+                }
+                if _, ok := p.p.Services[serviceID]; !ok {
+                        break
+                }
+
+                s := Service{
+                        id: serviceID,
+                        p:  p.p,
+                }
+                return s.Regions(), true
+        }
+
+        return map[string]Region{}, false
+}
+
+// PartitionForRegion returns the first partition which includes the region
+// passed in. This includes both known regions and regions which match
+// a pattern supported by the partition which may include regions that are
+// not explicitly known by the partition. Use the Regions method of the
+// returned Partition if explicit support is needed.
+func PartitionForRegion(ps []Partition, regionID string) (Partition, bool) {
+        for _, p := range ps {
+                if _, ok := p.p.Regions[regionID]; ok || p.p.RegionRegex.MatchString(regionID) {
+                        return p, true
+                }
+        }
+
+        return Partition{}, false
+}
+
+// A Partition provides the ability to enumerate the partition's regions
+// and services.
+type Partition struct {
+        id string
+        p  *partition
+}
+
+// ID returns the identifier of the partition.
+func (p Partition) ID() string { return p.id }
+
+// EndpointFor attempts to resolve the endpoint based on service and region.
+// See Options for information on configuring how the endpoint is resolved.
+//
+// If the service cannot be found in the metadata the UnknownServiceError
+// error will be returned. This validation will occur regardless if
+// StrictMatching is enabled. To enable resolving unknown services set the
+// "ResolveUnknownService" option to true. When StrictMatching is disabled
+// this option allows the partition resolver to resolve a endpoint based on
+// the service endpoint ID provided.
+//
+// When resolving endpoints you can choose to enable StrictMatching. This will
+// require the provided service and region to be known by the partition.
+// If the endpoint cannot be strictly resolved an error will be returned. This
+// mode is useful to ensure the endpoint resolved is valid. Without
+// StrictMatching enabled the endpoint returned my look valid but may not work.
+// StrictMatching requires the SDK to be updated if you want to take advantage
+// of new regions and services expansions.
+//
+// Errors that can be returned.
+//   * UnknownServiceError
+//   * UnknownEndpointError
+func (p Partition) EndpointFor(service, region string, opts ...func(*Options)) (ResolvedEndpoint, error) {
+        return p.p.EndpointFor(service, region, opts...)
+}
+
+// Regions returns a map of Regions indexed by their ID. This is useful for
+// enumerating over the regions in a partition.
+func (p Partition) Regions() map[string]Region {
+        rs := map[string]Region{}
+        for id := range p.p.Regions {
+                rs[id] = Region{
+                        id: id,
+                        p:  p.p,
+                }
+        }
+
+        return rs
+}
+
+// Services returns a map of Service indexed by their ID. This is useful for
+// enumerating over the services in a partition.
+func (p Partition) Services() map[string]Service {
+        ss := map[string]Service{}
+        for id := range p.p.Services {
+                ss[id] = Service{
+                        id: id,
+                        p:  p.p,
+                }
+        }
+
+        return ss
+}
+
+// A Region provides information about a region, and ability to resolve an
+// endpoint from the context of a region, given a service.
+type Region struct {
+        id, desc string
+        p        *partition
+}
+
+// ID returns the region's identifier.
+func (r Region) ID() string { return r.id }
+
+// ResolveEndpoint resolves an endpoint from the context of the region given
+// a service. See Partition.EndpointFor for usage and errors that can be returned.
+func (r Region) ResolveEndpoint(service string, opts ...func(*Options)) (ResolvedEndpoint, error) {
+        return r.p.EndpointFor(service, r.id, opts...)
+}
+
+// Services returns a list of all services that are known to be in this region.
+func (r Region) Services() map[string]Service {
+        ss := map[string]Service{}
+        for id, s := range r.p.Services {
+                if _, ok := s.Endpoints[r.id]; ok {
+                        ss[id] = Service{
+                                id: id,
+                                p:  r.p,
+                        }
+                }
+        }
+
+        return ss
+}
+
+// A Service provides information about a service, and ability to resolve an
+// endpoint from the context of a service, given a region.
+type Service struct {
+        id string
+        p  *partition
+}
+
+// ID returns the identifier for the service.
+func (s Service) ID() string { return s.id }
+
+// ResolveEndpoint resolves an endpoint from the context of a service given
+// a region. See Partition.EndpointFor for usage and errors that can be returned.
+func (s Service) ResolveEndpoint(region string, opts ...func(*Options)) (ResolvedEndpoint, error) {
+        return s.p.EndpointFor(s.id, region, opts...)
+}
+
+// Regions returns a map of Regions that the service is present in.
+//
+// A region is the AWS region the service exists in. Whereas a Endpoint is
+// an URL that can be resolved to a instance of a service.
+func (s Service) Regions() map[string]Region {
+        rs := map[string]Region{}
+        for id := range s.p.Services[s.id].Endpoints {
+                if _, ok := s.p.Regions[id]; ok {
+                        rs[id] = Region{
+                                id: id,
+                                p:  s.p,
+                        }
+                }
+        }
+
+        return rs
+}
+
+// Endpoints returns a map of Endpoints indexed by their ID for all known
+// endpoints for a service.
+//
+// A region is the AWS region the service exists in. Whereas a Endpoint is
+// an URL that can be resolved to a instance of a service.
+func (s Service) Endpoints() map[string]Endpoint {
+        es := map[string]Endpoint{}
+        for id := range s.p.Services[s.id].Endpoints {
+                es[id] = Endpoint{
+                        id:        id,
+                        serviceID: s.id,
+                        p:         s.p,
+                }
+        }
+
+        return es
+}
+
+// A Endpoint provides information about endpoints, and provides the ability
+// to resolve that endpoint for the service, and the region the endpoint
+// represents.
+type Endpoint struct {
+        id        string
+        serviceID string
+        p         *partition
+}
+
+// ID returns the identifier for an endpoint.
+func (e Endpoint) ID() string { return e.id }
+
+// ServiceID returns the identifier the endpoint belongs to.
+func (e Endpoint) ServiceID() string { return e.serviceID }
+
+// ResolveEndpoint resolves an endpoint from the context of a service and
+// region the endpoint represents. See Partition.EndpointFor for usage and
+// errors that can be returned.
+func (e Endpoint) ResolveEndpoint(opts ...func(*Options)) (ResolvedEndpoint, error) {
+        return e.p.EndpointFor(e.serviceID, e.id, opts...)
+}
+
+// A ResolvedEndpoint is an endpoint that has been resolved based on a partition
+// service, and region.
+type ResolvedEndpoint struct {
+        // The endpoint URL
+        URL string
+
+        // The region that should be used for signing requests.
+        SigningRegion string
+
+        // The service name that should be used for signing requests.
+        SigningName string
+
+        // The signing method that should be used for signing requests.
+        SigningMethod string
+}
+
+// So that the Error interface type can be included as an anonymous field
+// in the requestError struct and not conflict with the error.Error() method.
+type awsError awserr.Error
+
+// A EndpointNotFoundError is returned when in StrictMatching mode, and the
+// endpoint for the service and region cannot be found in any of the partitions.
+type EndpointNotFoundError struct {
+        awsError
+        Partition string
+        Service   string
+        Region    string
+}
+
+// A UnknownServiceError is returned when the service does not resolve to an
+// endpoint. Includes a list of all known services for the partition. Returned
+// when a partition does not support the service.
+type UnknownServiceError struct {
+        awsError
+        Partition string
+        Service   string
+        Known     []string
+}
+
+// NewUnknownServiceError builds and returns UnknownServiceError.
+func NewUnknownServiceError(p, s string, known []string) UnknownServiceError {
+        return UnknownServiceError{
+                awsError: awserr.New("UnknownServiceError",
+                        "could not resolve endpoint for unknown service", nil),
+                Partition: p,
+                Service:   s,
+                Known:     known,
+        }
+}
+
+// String returns the string representation of the error.
+func (e UnknownServiceError) Error() string {
+        extra := fmt.Sprintf("partition: %q, service: %q",
+                e.Partition, e.Service)
+        if len(e.Known) > 0 {
+                extra += fmt.Sprintf(", known: %v", e.Known)
+        }
+        return awserr.SprintError(e.Code(), e.Message(), extra, e.OrigErr())
+}
+
+// String returns the string representation of the error.
+func (e UnknownServiceError) String() string {
+        return e.Error()
+}
+
+// A UnknownEndpointError is returned when in StrictMatching mode and the
+// service is valid, but the region does not resolve to an endpoint. Includes
+// a list of all known endpoints for the service.
+type UnknownEndpointError struct {
+        awsError
+        Partition string
+        Service   string
+        Region    string
+        Known     []string
+}
+
+// NewUnknownEndpointError builds and returns UnknownEndpointError.
+func NewUnknownEndpointError(p, s, r string, known []string) UnknownEndpointError {
+        return UnknownEndpointError{
+                awsError: awserr.New("UnknownEndpointError",
+                        "could not resolve endpoint", nil),
+                Partition: p,
+                Service:   s,
+                Region:    r,
+                Known:     known,
+        }
+}
+
+// String returns the string representation of the error.
+func (e UnknownEndpointError) Error() string {
+        extra := fmt.Sprintf("partition: %q, service: %q, region: %q",
+                e.Partition, e.Service, e.Region)
+        if len(e.Known) > 0 {
+                extra += fmt.Sprintf(", known: %v", e.Known)
+        }
+        return awserr.SprintError(e.Code(), e.Message(), extra, e.OrigErr())
+}
+
+// String returns the string representation of the error.
+func (e UnknownEndpointError) String() string {
+        return e.Error()
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/endpoints/v3model.go b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/v3model.go
new file mode 100644
index 0000000..13d968a
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/v3model.go
@@ -0,0 +1,303 @@
+package endpoints
+
+import (
+        "fmt"
+        "regexp"
+        "strconv"
+        "strings"
+)
+
+type partitions []partition
+
+func (ps partitions) EndpointFor(service, region string, opts ...func(*Options)) (ResolvedEndpoint, error) {
+        var opt Options
+        opt.Set(opts...)
+
+        for i := 0; i < len(ps); i++ {
+                if !ps[i].canResolveEndpoint(service, region, opt.StrictMatching) {
+                        continue
+                }
+
+                return ps[i].EndpointFor(service, region, opts...)
+        }
+
+        // If loose matching fallback to first partition format to use
+        // when resolving the endpoint.
+        if !opt.StrictMatching && len(ps) > 0 {
+                return ps[0].EndpointFor(service, region, opts...)
+        }
+
+        return ResolvedEndpoint{}, NewUnknownEndpointError("all partitions", service, region, []string{})
+}
+
+// Partitions satisfies the EnumPartitions interface and returns a list
+// of Partitions representing each partition represented in the SDK's
+// endpoints model.
+func (ps partitions) Partitions() []Partition {
+        parts := make([]Partition, 0, len(ps))
+        for i := 0; i < len(ps); i++ {
+                parts = append(parts, ps[i].Partition())
+        }
+
+        return parts
+}
+
+type partition struct {
+        ID          string      `json:"partition"`
+        Name        string      `json:"partitionName"`
+        DNSSuffix   string      `json:"dnsSuffix"`
+        RegionRegex regionRegex `json:"regionRegex"`
+        Defaults    endpoint    `json:"defaults"`
+        Regions     regions     `json:"regions"`
+        Services    services    `json:"services"`
+}
+
+func (p partition) Partition() Partition {
+        return Partition{
+                id: p.ID,
+                p:  &p,
+        }
+}
+
+func (p partition) canResolveEndpoint(service, region string, strictMatch bool) bool {
+        s, hasService := p.Services[service]
+        _, hasEndpoint := s.Endpoints[region]
+
+        if hasEndpoint && hasService {
+                return true
+        }
+
+        if strictMatch {
+                return false
+        }
+
+        return p.RegionRegex.MatchString(region)
+}
+
+func (p partition) EndpointFor(service, region string, opts ...func(*Options)) (resolved ResolvedEndpoint, err error) {
+        var opt Options
+        opt.Set(opts...)
+
+        s, hasService := p.Services[service]
+        if !(hasService || opt.ResolveUnknownService) {
+                // Only return error if the resolver will not fallback to creating
+                // endpoint based on service endpoint ID passed in.
+                return resolved, NewUnknownServiceError(p.ID, service, serviceList(p.Services))
+        }
+
+        e, hasEndpoint := s.endpointForRegion(region)
+        if !hasEndpoint && opt.StrictMatching {
+                return resolved, NewUnknownEndpointError(p.ID, service, region, endpointList(s.Endpoints))
+        }
+
+        defs := []endpoint{p.Defaults, s.Defaults}
+        return e.resolve(service, region, p.DNSSuffix, defs, opt), nil
+}
+
+func serviceList(ss services) []string {
+        list := make([]string, 0, len(ss))
+        for k := range ss {
+                list = append(list, k)
+        }
+        return list
+}
+func endpointList(es endpoints) []string {
+        list := make([]string, 0, len(es))
+        for k := range es {
+                list = append(list, k)
+        }
+        return list
+}
+
+type regionRegex struct {
+        *regexp.Regexp
+}
+
+func (rr *regionRegex) UnmarshalJSON(b []byte) (err error) {
+        // Strip leading and trailing quotes
+        regex, err := strconv.Unquote(string(b))
+        if err != nil {
+                return fmt.Errorf("unable to strip quotes from regex, %v", err)
+        }
+
+        rr.Regexp, err = regexp.Compile(regex)
+        if err != nil {
+                return fmt.Errorf("unable to unmarshal region regex, %v", err)
+        }
+        return nil
+}
+
+type regions map[string]region
+
+type region struct {
+        Description string `json:"description"`
+}
+
+type services map[string]service
+
+type service struct {
+        PartitionEndpoint string    `json:"partitionEndpoint"`
+        IsRegionalized    boxedBool `json:"isRegionalized,omitempty"`
+        Defaults          endpoint  `json:"defaults"`
+        Endpoints         endpoints `json:"endpoints"`
+}
+
+func (s *service) endpointForRegion(region string) (endpoint, bool) {
+        if s.IsRegionalized == boxedFalse {
+                return s.Endpoints[s.PartitionEndpoint], region == s.PartitionEndpoint
+        }
+
+        if e, ok := s.Endpoints[region]; ok {
+                return e, true
+        }
+
+        // Unable to find any matching endpoint, return
+        // blank that will be used for generic endpoint creation.
+        return endpoint{}, false
+}
+
+type endpoints map[string]endpoint
+
+type endpoint struct {
+        Hostname        string          `json:"hostname"`
+        Protocols       []string        `json:"protocols"`
+        CredentialScope credentialScope `json:"credentialScope"`
+
+        // Custom fields not modeled
+        HasDualStack      boxedBool `json:"-"`
+        DualStackHostname string    `json:"-"`
+
+        // Signature Version not used
+        SignatureVersions []string `json:"signatureVersions"`
+
+        // SSLCommonName not used.
+        SSLCommonName string `json:"sslCommonName"`
+}
+
+const (
+        defaultProtocol = "https"
+        defaultSigner   = "v4"
+)
+
+var (
+        protocolPriority = []string{"https", "http"}
+        signerPriority   = []string{"v4", "v2"}
+)
+
+func getByPriority(s []string, p []string, def string) string {
+        if len(s) == 0 {
+                return def
+        }
+
+        for i := 0; i < len(p); i++ {
+                for j := 0; j < len(s); j++ {
+                        if s[j] == p[i] {
+                                return s[j]
+                        }
+                }
+        }
+
+        return s[0]
+}
+
+func (e endpoint) resolve(service, region, dnsSuffix string, defs []endpoint, opts Options) ResolvedEndpoint {
+        var merged endpoint
+        for _, def := range defs {
+                merged.mergeIn(def)
+        }
+        merged.mergeIn(e)
+        e = merged
+
+        hostname := e.Hostname
+
+        // Offset the hostname for dualstack if enabled
+        if opts.UseDualStack && e.HasDualStack == boxedTrue {
+                hostname = e.DualStackHostname
+        }
+
+        u := strings.Replace(hostname, "{service}", service, 1)
+        u = strings.Replace(u, "{region}", region, 1)
+        u = strings.Replace(u, "{dnsSuffix}", dnsSuffix, 1)
+
+        scheme := getEndpointScheme(e.Protocols, opts.DisableSSL)
+        u = fmt.Sprintf("%s://%s", scheme, u)
+
+        signingRegion := e.CredentialScope.Region
+        if len(signingRegion) == 0 {
+                signingRegion = region
+        }
+        signingName := e.CredentialScope.Service
+        if len(signingName) == 0 {
+                signingName = service
+        }
+
+        return ResolvedEndpoint{
+                URL:           u,
+                SigningRegion: signingRegion,
+                SigningName:   signingName,
+                SigningMethod: getByPriority(e.SignatureVersions, signerPriority, defaultSigner),
+        }
+}
+
+func getEndpointScheme(protocols []string, disableSSL bool) string {
+        if disableSSL {
+                return "http"
+        }
+
+        return getByPriority(protocols, protocolPriority, defaultProtocol)
+}
+
+func (e *endpoint) mergeIn(other endpoint) {
+        if len(other.Hostname) > 0 {
+                e.Hostname = other.Hostname
+        }
+        if len(other.Protocols) > 0 {
+                e.Protocols = other.Protocols
+        }
+        if len(other.SignatureVersions) > 0 {
+                e.SignatureVersions = other.SignatureVersions
+        }
+        if len(other.CredentialScope.Region) > 0 {
+                e.CredentialScope.Region = other.CredentialScope.Region
+        }
+        if len(other.CredentialScope.Service) > 0 {
+                e.CredentialScope.Service = other.CredentialScope.Service
+        }
+        if len(other.SSLCommonName) > 0 {
+                e.SSLCommonName = other.SSLCommonName
+        }
+        if other.HasDualStack != boxedBoolUnset {
+                e.HasDualStack = other.HasDualStack
+        }
+        if len(other.DualStackHostname) > 0 {
+                e.DualStackHostname = other.DualStackHostname
+        }
+}
+
+type credentialScope struct {
+        Region  string `json:"region"`
+        Service string `json:"service"`
+}
+
+type boxedBool int
+
+func (b *boxedBool) UnmarshalJSON(buf []byte) error {
+        v, err := strconv.ParseBool(string(buf))
+        if err != nil {
+                return err
+        }
+
+        if v {
+                *b = boxedTrue
+        } else {
+                *b = boxedFalse
+        }
+
+        return nil
+}
+
+const (
+        boxedBoolUnset boxedBool = iota
+        boxedFalse
+        boxedTrue
+)
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/endpoints/v3model_codegen.go b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/v3model_codegen.go
new file mode 100644
index 0000000..05e92df
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/v3model_codegen.go
@@ -0,0 +1,337 @@
+// +build codegen
+
+package endpoints
+
+import (
+        "fmt"
+        "io"
+        "reflect"
+        "strings"
+        "text/template"
+        "unicode"
+)
+
+// A CodeGenOptions are the options for code generating the endpoints into
+// Go code from the endpoints model definition.
+type CodeGenOptions struct {
+        // Options for how the model will be decoded.
+        DecodeModelOptions DecodeModelOptions
+}
+
+// Set combines all of the option functions together
+func (d *CodeGenOptions) Set(optFns ...func(*CodeGenOptions)) {
+        for _, fn := range optFns {
+                fn(d)
+        }
+}
+
+// CodeGenModel given a endpoints model file will decode it and attempt to
+// generate Go code from the model definition. Error will be returned if
+// the code is unable to be generated, or decoded.
+func CodeGenModel(modelFile io.Reader, outFile io.Writer, optFns ...func(*CodeGenOptions)) error {
+        var opts CodeGenOptions
+        opts.Set(optFns...)
+
+        resolver, err := DecodeModel(modelFile, func(d *DecodeModelOptions) {
+                *d = opts.DecodeModelOptions
+        })
+        if err != nil {
+                return err
+        }
+
+        tmpl := template.Must(template.New("tmpl").Funcs(funcMap).Parse(v3Tmpl))
+        if err := tmpl.ExecuteTemplate(outFile, "defaults", resolver); err != nil {
+                return fmt.Errorf("failed to execute template, %v", err)
+        }
+
+        return nil
+}
+
+func toSymbol(v string) string {
+        out := []rune{}
+        for _, c := range strings.Title(v) {
+                if !(unicode.IsNumber(c) || unicode.IsLetter(c)) {
+                        continue
+                }
+
+                out = append(out, c)
+        }
+
+        return string(out)
+}
+
+func quoteString(v string) string {
+        return fmt.Sprintf("%q", v)
+}
+
+func regionConstName(p, r string) string {
+        return toSymbol(p) + toSymbol(r)
+}
+
+func partitionGetter(id string) string {
+        return fmt.Sprintf("%sPartition", toSymbol(id))
+}
+
+func partitionVarName(id string) string {
+        return fmt.Sprintf("%sPartition", strings.ToLower(toSymbol(id)))
+}
+
+func listPartitionNames(ps partitions) string {
+        names := []string{}
+        switch len(ps) {
+        case 1:
+                return ps[0].Name
+        case 2:
+                return fmt.Sprintf("%s and %s", ps[0].Name, ps[1].Name)
+        default:
+                for i, p := range ps {
+                        if i == len(ps)-1 {
+                                names = append(names, "and "+p.Name)
+                        } else {
+                                names = append(names, p.Name)
+                        }
+                }
+                return strings.Join(names, ", ")
+        }
+}
+
+func boxedBoolIfSet(msg string, v boxedBool) string {
+        switch v {
+        case boxedTrue:
+                return fmt.Sprintf(msg, "boxedTrue")
+        case boxedFalse:
+                return fmt.Sprintf(msg, "boxedFalse")
+        default:
+                return ""
+        }
+}
+
+func stringIfSet(msg, v string) string {
+        if len(v) == 0 {
+                return ""
+        }
+
+        return fmt.Sprintf(msg, v)
+}
+
+func stringSliceIfSet(msg string, vs []string) string {
+        if len(vs) == 0 {
+                return ""
+        }
+
+        names := []string{}
+        for _, v := range vs {
+                names = append(names, `"`+v+`"`)
+        }
+
+        return fmt.Sprintf(msg, strings.Join(names, ","))
+}
+
+func endpointIsSet(v endpoint) bool {
+        return !reflect.DeepEqual(v, endpoint{})
+}
+
+func serviceSet(ps partitions) map[string]struct{} {
+        set := map[string]struct{}{}
+        for _, p := range ps {
+                for id := range p.Services {
+                        set[id] = struct{}{}
+                }
+        }
+
+        return set
+}
+
+var funcMap = template.FuncMap{
+        "ToSymbol":           toSymbol,
+        "QuoteString":        quoteString,
+        "RegionConst":        regionConstName,
+        "PartitionGetter":    partitionGetter,
+        "PartitionVarName":   partitionVarName,
+        "ListPartitionNames": listPartitionNames,
+        "BoxedBoolIfSet":     boxedBoolIfSet,
+        "StringIfSet":        stringIfSet,
+        "StringSliceIfSet":   stringSliceIfSet,
+        "EndpointIsSet":      endpointIsSet,
+        "ServicesSet":        serviceSet,
+}
+
+const v3Tmpl = `
+{{ define "defaults" -}}
+// Code generated by aws/endpoints/v3model_codegen.go. DO NOT EDIT.
+
+package endpoints
+
+import (
+        "regexp"
+)
+
+        {{ template "partition consts" . }}
+
+        {{ range $_, $partition := . }}
+                {{ template "partition region consts" $partition }}
+        {{ end }}
+
+        {{ template "service consts" . }}
+        
+        {{ template "endpoint resolvers" . }}
+{{- end }}
+
+{{ define "partition consts" }}
+        // Partition identifiers
+        const (
+                {{ range $_, $p := . -}}
+                        {{ ToSymbol $p.ID }}PartitionID = {{ QuoteString $p.ID }} // {{ $p.Name }} partition.
+                {{ end -}}
+        )
+{{- end }}
+
+{{ define "partition region consts" }}
+        // {{ .Name }} partition's regions.
+        const (
+                {{ range $id, $region := .Regions -}}
+                        {{ ToSymbol $id }}RegionID = {{ QuoteString $id }} // {{ $region.Description }}.
+                {{ end -}}
+        )
+{{- end }}
+
+{{ define "service consts" }}
+        // Service identifiers
+        const (
+                {{ $serviceSet := ServicesSet . -}}
+                {{ range $id, $_ := $serviceSet -}}
+                        {{ ToSymbol $id }}ServiceID = {{ QuoteString $id }} // {{ ToSymbol $id }}.
+                {{ end -}}
+        )
+{{- end }}
+
+{{ define "endpoint resolvers" }}
+        // DefaultResolver returns an Endpoint resolver that will be able
+        // to resolve endpoints for: {{ ListPartitionNames . }}.
+        //
+        // Use DefaultPartitions() to get the list of the default partitions.
+        func DefaultResolver() Resolver {
+                return defaultPartitions
+        }
+
+        // DefaultPartitions returns a list of the partitions the SDK is bundled
+        // with. The available partitions are: {{ ListPartitionNames . }}.
+        //
+        //    partitions := endpoints.DefaultPartitions
+        //    for _, p := range partitions {
+        //        // ... inspect partitions
+        //    }
+        func DefaultPartitions() []Partition {
+                return defaultPartitions.Partitions()
+        }
+
+        var defaultPartitions = partitions{
+                {{ range $_, $partition := . -}}
+                        {{ PartitionVarName $partition.ID }},
+                {{ end }}
+        }
+        
+        {{ range $_, $partition := . -}}
+                {{ $name := PartitionGetter $partition.ID -}}
+                // {{ $name }} returns the Resolver for {{ $partition.Name }}.
+                func {{ $name }}() Partition {
+                        return  {{ PartitionVarName $partition.ID }}.Partition()
+                }
+                var {{ PartitionVarName $partition.ID }} = {{ template "gocode Partition" $partition }}
+        {{ end }}
+{{ end }}
+
+{{ define "default partitions" }}
+        func DefaultPartitions() []Partition {
+                return []partition{
+                        {{ range $_, $partition := . -}}
+                        // {{ ToSymbol $partition.ID}}Partition(),
+                        {{ end }}
+                }
+        }
+{{ end }}
+
+{{ define "gocode Partition" -}}
+partition{
+        {{ StringIfSet "ID: %q,\n" .ID -}}
+        {{ StringIfSet "Name: %q,\n" .Name -}}
+        {{ StringIfSet "DNSSuffix: %q,\n" .DNSSuffix -}}
+        RegionRegex: {{ template "gocode RegionRegex" .RegionRegex }},
+        {{ if EndpointIsSet .Defaults -}}
+                Defaults: {{ template "gocode Endpoint" .Defaults }},
+        {{- end }}
+        Regions:  {{ template "gocode Regions" .Regions }},
+        Services: {{ template "gocode Services" .Services }},
+}
+{{- end }}
+
+{{ define "gocode RegionRegex" -}}
+regionRegex{
+        Regexp: func() *regexp.Regexp{
+                reg, _ := regexp.Compile({{ QuoteString .Regexp.String }})
+                return reg
+        }(),
+}
+{{- end }}
+
+{{ define "gocode Regions" -}}
+regions{
+        {{ range $id, $region := . -}}
+                "{{ $id }}": {{ template "gocode Region" $region }},
+        {{ end -}}
+}
+{{- end }}
+
+{{ define "gocode Region" -}}
+region{
+        {{ StringIfSet "Description: %q,\n" .Description -}}
+}
+{{- end }}
+
+{{ define "gocode Services" -}}
+services{
+        {{ range $id, $service := . -}}
+        "{{ $id }}": {{ template "gocode Service" $service }},
+        {{ end }}
+}
+{{- end }}
+
+{{ define "gocode Service" -}}
+service{
+        {{ StringIfSet "PartitionEndpoint: %q,\n" .PartitionEndpoint -}}
+        {{ BoxedBoolIfSet "IsRegionalized: %s,\n" .IsRegionalized -}}
+        {{ if EndpointIsSet .Defaults -}}
+                Defaults: {{ template "gocode Endpoint" .Defaults -}},
+        {{- end }}
+        {{ if .Endpoints -}}
+                Endpoints: {{ template "gocode Endpoints" .Endpoints }},
+        {{- end }}
+}
+{{- end }}
+
+{{ define "gocode Endpoints" -}}
+endpoints{
+        {{ range $id, $endpoint := . -}}
+        "{{ $id }}": {{ template "gocode Endpoint" $endpoint }},
+        {{ end }}
+}
+{{- end }}
+
+{{ define "gocode Endpoint" -}}
+endpoint{
+        {{ StringIfSet "Hostname: %q,\n" .Hostname -}}
+        {{ StringIfSet "SSLCommonName: %q,\n" .SSLCommonName -}}
+        {{ StringSliceIfSet "Protocols: []string{%s},\n" .Protocols -}}
+        {{ StringSliceIfSet "SignatureVersions: []string{%s},\n" .SignatureVersions -}}
+        {{ if or .CredentialScope.Region .CredentialScope.Service -}}
+        CredentialScope: credentialScope{
+                {{ StringIfSet "Region: %q,\n" .CredentialScope.Region -}}
+                {{ StringIfSet "Service: %q,\n" .CredentialScope.Service -}}
+        },
+        {{- end }}
+        {{ BoxedBoolIfSet "HasDualStack: %s,\n" .HasDualStack -}}
+        {{ StringIfSet "DualStackHostname: %q,\n" .DualStackHostname -}}
+
+}
+{{- end }}
+`
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/errors.go b/vendor/github.com/aws/aws-sdk-go/aws/errors.go
new file mode 100644
index 0000000..5766361
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/errors.go
@@ -0,0 +1,17 @@
+package aws
+
+import "github.com/aws/aws-sdk-go/aws/awserr"
+
+var (
+        // ErrMissingRegion is an error that is returned if region configuration is
+        // not found.
+        //
+        // @readonly
+        ErrMissingRegion = awserr.New("MissingRegion", "could not find region configuration", nil)
+
+        // ErrMissingEndpoint is an error that is returned if an endpoint cannot be
+        // resolved for a service.
+        //
+        // @readonly
+        ErrMissingEndpoint = awserr.New("MissingEndpoint", "'Endpoint' configuration is required for this service", nil)
+)
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/jsonvalue.go b/vendor/github.com/aws/aws-sdk-go/aws/jsonvalue.go
new file mode 100644
index 0000000..91a6f27
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/jsonvalue.go
@@ -0,0 +1,12 @@
+package aws
+
+// JSONValue is a representation of a grab bag type that will be marshaled
+// into a json string. This type can be used just like any other map.
+//
+//      Example:
+//
+//      values := aws.JSONValue{
+//              "Foo": "Bar",
+//      }
+//      values["Baz"] = "Qux"
+type JSONValue map[string]interface{}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/logger.go b/vendor/github.com/aws/aws-sdk-go/aws/logger.go
new file mode 100644
index 0000000..db87188
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/logger.go
@@ -0,0 +1,112 @@
+package aws
+
+import (
+        "log"
+        "os"
+)
+
+// A LogLevelType defines the level logging should be performed at. Used to instruct
+// the SDK which statements should be logged.
+type LogLevelType uint
+
+// LogLevel returns the pointer to a LogLevel. Should be used to workaround
+// not being able to take the address of a non-composite literal.
+func LogLevel(l LogLevelType) *LogLevelType {
+        return &l
+}
+
+// Value returns the LogLevel value or the default value LogOff if the LogLevel
+// is nil. Safe to use on nil value LogLevelTypes.
+func (l *LogLevelType) Value() LogLevelType {
+        if l != nil {
+                return *l
+        }
+        return LogOff
+}
+
+// Matches returns true if the v LogLevel is enabled by this LogLevel. Should be
+// used with logging sub levels. Is safe to use on nil value LogLevelTypes. If
+// LogLevel is nill, will default to LogOff comparison.
+func (l *LogLevelType) Matches(v LogLevelType) bool {
+        c := l.Value()
+        return c&v == v
+}
+
+// AtLeast returns true if this LogLevel is at least high enough to satisfies v.
+// Is safe to use on nil value LogLevelTypes. If LogLevel is nill, will default
+// to LogOff comparison.
+func (l *LogLevelType) AtLeast(v LogLevelType) bool {
+        c := l.Value()
+        return c >= v
+}
+
+const (
+        // LogOff states that no logging should be performed by the SDK. This is the
+        // default state of the SDK, and should be use to disable all logging.
+        LogOff LogLevelType = iota * 0x1000
+
+        // LogDebug state that debug output should be logged by the SDK. This should
+        // be used to inspect request made and responses received.
+        LogDebug
+)
+
+// Debug Logging Sub Levels
+const (
+        // LogDebugWithSigning states that the SDK should log request signing and
+        // presigning events. This should be used to log the signing details of
+        // requests for debugging. Will also enable LogDebug.
+        LogDebugWithSigning LogLevelType = LogDebug | (1 << iota)
+
+        // LogDebugWithHTTPBody states the SDK should log HTTP request and response
+        // HTTP bodys in addition to the headers and path. This should be used to
+        // see the body content of requests and responses made while using the SDK
+        // Will also enable LogDebug.
+        LogDebugWithHTTPBody
+
+        // LogDebugWithRequestRetries states the SDK should log when service requests will
+        // be retried. This should be used to log when you want to log when service
+        // requests are being retried. Will also enable LogDebug.
+        LogDebugWithRequestRetries
+
+        // LogDebugWithRequestErrors states the SDK should log when service requests fail
+        // to build, send, validate, or unmarshal.
+        LogDebugWithRequestErrors
+)
+
+// A Logger is a minimalistic interface for the SDK to log messages to. Should
+// be used to provide custom logging writers for the SDK to use.
+type Logger interface {
+        Log(...interface{})
+}
+
+// A LoggerFunc is a convenience type to convert a function taking a variadic
+// list of arguments and wrap it so the Logger interface can be used.
+//
+// Example:
+//     s3.New(sess, &aws.Config{Logger: aws.LoggerFunc(func(args ...interface{}) {
+//         fmt.Fprintln(os.Stdout, args...)
+//     })})
+type LoggerFunc func(...interface{})
+
+// Log calls the wrapped function with the arguments provided
+func (f LoggerFunc) Log(args ...interface{}) {
+        f(args...)
+}
+
+// NewDefaultLogger returns a Logger which will write log messages to stdout, and
+// use same formatting runes as the stdlib log.Logger
+func NewDefaultLogger() Logger {
+        return &defaultLogger{
+                logger: log.New(os.Stdout, "", log.LstdFlags),
+        }
+}
+
+// A defaultLogger provides a minimalistic logger satisfying the Logger interface.
+type defaultLogger struct {
+        logger *log.Logger
+}
+
+// Log logs the parameters to the stdlib logger. See log.Println.
+func (l defaultLogger) Log(args ...interface{}) {
+        l.logger.Println(args...)
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/connection_reset_error.go b/vendor/github.com/aws/aws-sdk-go/aws/request/connection_reset_error.go
new file mode 100644
index 0000000..10fc8cb
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/connection_reset_error.go
@@ -0,0 +1,19 @@
+// +build !appengine
+
+package request
+
+import (
+        "net"
+        "os"
+        "syscall"
+)
+
+func isErrConnectionReset(err error) bool {
+        if opErr, ok := err.(*net.OpError); ok {
+                if sysErr, ok := opErr.Err.(*os.SyscallError); ok {
+                        return sysErr.Err == syscall.ECONNRESET
+                }
+        }
+
+        return false
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/connection_reset_error_appengine.go b/vendor/github.com/aws/aws-sdk-go/aws/request/connection_reset_error_appengine.go
new file mode 100644
index 0000000..996196e
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/connection_reset_error_appengine.go
@@ -0,0 +1,11 @@
+// +build appengine
+
+package request
+
+import (
+        "strings"
+)
+
+func isErrConnectionReset(err error) bool {
+        return strings.Contains(err.Error(), "connection reset")
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/handlers.go b/vendor/github.com/aws/aws-sdk-go/aws/request/handlers.go
new file mode 100644
index 0000000..6c14336
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/handlers.go
@@ -0,0 +1,225 @@
+package request
+
+import (
+        "fmt"
+        "strings"
+)
+
+// A Handlers provides a collection of request handlers for various
+// stages of handling requests.
+type Handlers struct {
+        Validate         HandlerList
+        Build            HandlerList
+        Sign             HandlerList
+        Send             HandlerList
+        ValidateResponse HandlerList
+        Unmarshal        HandlerList
+        UnmarshalMeta    HandlerList
+        UnmarshalError   HandlerList
+        Retry            HandlerList
+        AfterRetry       HandlerList
+        Complete         HandlerList
+}
+
+// Copy returns of this handler's lists.
+func (h *Handlers) Copy() Handlers {
+        return Handlers{
+                Validate:         h.Validate.copy(),
+                Build:            h.Build.copy(),
+                Sign:             h.Sign.copy(),
+                Send:             h.Send.copy(),
+                ValidateResponse: h.ValidateResponse.copy(),
+                Unmarshal:        h.Unmarshal.copy(),
+                UnmarshalError:   h.UnmarshalError.copy(),
+                UnmarshalMeta:    h.UnmarshalMeta.copy(),
+                Retry:            h.Retry.copy(),
+                AfterRetry:       h.AfterRetry.copy(),
+                Complete:         h.Complete.copy(),
+        }
+}
+
+// Clear removes callback functions for all handlers
+func (h *Handlers) Clear() {
+        h.Validate.Clear()
+        h.Build.Clear()
+        h.Send.Clear()
+        h.Sign.Clear()
+        h.Unmarshal.Clear()
+        h.UnmarshalMeta.Clear()
+        h.UnmarshalError.Clear()
+        h.ValidateResponse.Clear()
+        h.Retry.Clear()
+        h.AfterRetry.Clear()
+        h.Complete.Clear()
+}
+
+// A HandlerListRunItem represents an entry in the HandlerList which
+// is being run.
+type HandlerListRunItem struct {
+        Index   int
+        Handler NamedHandler
+        Request *Request
+}
+
+// A HandlerList manages zero or more handlers in a list.
+type HandlerList struct {
+        list []NamedHandler
+
+        // Called after each request handler in the list is called. If set
+        // and the func returns true the HandlerList will continue to iterate
+        // over the request handlers. If false is returned the HandlerList
+        // will stop iterating.
+        //
+        // Should be used if extra logic to be performed between each handler
+        // in the list. This can be used to terminate a list's iteration
+        // based on a condition such as error like, HandlerListStopOnError.
+        // Or for logging like HandlerListLogItem.
+        AfterEachFn func(item HandlerListRunItem) bool
+}
+
+// A NamedHandler is a struct that contains a name and function callback.
+type NamedHandler struct {
+        Name string
+        Fn   func(*Request)
+}
+
+// copy creates a copy of the handler list.
+func (l *HandlerList) copy() HandlerList {
+        n := HandlerList{
+                AfterEachFn: l.AfterEachFn,
+        }
+        if len(l.list) == 0 {
+                return n
+        }
+
+        n.list = append(make([]NamedHandler, 0, len(l.list)), l.list...)
+        return n
+}
+
+// Clear clears the handler list.
+func (l *HandlerList) Clear() {
+        l.list = l.list[0:0]
+}
+
+// Len returns the number of handlers in the list.
+func (l *HandlerList) Len() int {
+        return len(l.list)
+}
+
+// PushBack pushes handler f to the back of the handler list.
+func (l *HandlerList) PushBack(f func(*Request)) {
+        l.PushBackNamed(NamedHandler{"__anonymous", f})
+}
+
+// PushBackNamed pushes named handler f to the back of the handler list.
+func (l *HandlerList) PushBackNamed(n NamedHandler) {
+        if cap(l.list) == 0 {
+                l.list = make([]NamedHandler, 0, 5)
+        }
+        l.list = append(l.list, n)
+}
+
+// PushFront pushes handler f to the front of the handler list.
+func (l *HandlerList) PushFront(f func(*Request)) {
+        l.PushFrontNamed(NamedHandler{"__anonymous", f})
+}
+
+// PushFrontNamed pushes named handler f to the front of the handler list.
+func (l *HandlerList) PushFrontNamed(n NamedHandler) {
+        if cap(l.list) == len(l.list) {
+                // Allocating new list required
+                l.list = append([]NamedHandler{n}, l.list...)
+        } else {
+                // Enough room to prepend into list.
+                l.list = append(l.list, NamedHandler{})
+                copy(l.list[1:], l.list)
+                l.list[0] = n
+        }
+}
+
+// Remove removes a NamedHandler n
+func (l *HandlerList) Remove(n NamedHandler) {
+        l.RemoveByName(n.Name)
+}
+
+// RemoveByName removes a NamedHandler by name.
+func (l *HandlerList) RemoveByName(name string) {
+        for i := 0; i < len(l.list); i++ {
+                m := l.list[i]
+                if m.Name == name {
+                        // Shift array preventing creating new arrays
+                        copy(l.list[i:], l.list[i+1:])
+                        l.list[len(l.list)-1] = NamedHandler{}
+                        l.list = l.list[:len(l.list)-1]
+
+                        // decrement list so next check to length is correct
+                        i--
+                }
+        }
+}
+
+// Run executes all handlers in the list with a given request object.
+func (l *HandlerList) Run(r *Request) {
+        for i, h := range l.list {
+                h.Fn(r)
+                item := HandlerListRunItem{
+                        Index: i, Handler: h, Request: r,
+                }
+                if l.AfterEachFn != nil && !l.AfterEachFn(item) {
+                        return
+                }
+        }
+}
+
+// HandlerListLogItem logs the request handler and the state of the
+// request's Error value. Always returns true to continue iterating
+// request handlers in a HandlerList.
+func HandlerListLogItem(item HandlerListRunItem) bool {
+        if item.Request.Config.Logger == nil {
+                return true
+        }
+        item.Request.Config.Logger.Log("DEBUG: RequestHandler",
+                item.Index, item.Handler.Name, item.Request.Error)
+
+        return true
+}
+
+// HandlerListStopOnError returns false to stop the HandlerList iterating
+// over request handlers if Request.Error is not nil. True otherwise
+// to continue iterating.
+func HandlerListStopOnError(item HandlerListRunItem) bool {
+        return item.Request.Error == nil
+}
+
+// WithAppendUserAgent will add a string to the user agent prefixed with a
+// single white space.
+func WithAppendUserAgent(s string) Option {
+        return func(r *Request) {
+                r.Handlers.Build.PushBack(func(r2 *Request) {
+                        AddToUserAgent(r, s)
+                })
+        }
+}
+
+// MakeAddToUserAgentHandler will add the name/version pair to the User-Agent request
+// header. If the extra parameters are provided they will be added as metadata to the
+// name/version pair resulting in the following format.
+// "name/version (extra0; extra1; ...)"
+// The user agent part will be concatenated with this current request's user agent string.
+func MakeAddToUserAgentHandler(name, version string, extra ...string) func(*Request) {
+        ua := fmt.Sprintf("%s/%s", name, version)
+        if len(extra) > 0 {
+                ua += fmt.Sprintf(" (%s)", strings.Join(extra, "; "))
+        }
+        return func(r *Request) {
+                AddToUserAgent(r, ua)
+        }
+}
+
+// MakeAddToUserAgentFreeFormHandler adds the input to the User-Agent request header.
+// The input string will be concatenated with the current request's user agent string.
+func MakeAddToUserAgentFreeFormHandler(s string) func(*Request) {
+        return func(r *Request) {
+                AddToUserAgent(r, s)
+        }
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/http_request.go b/vendor/github.com/aws/aws-sdk-go/aws/request/http_request.go
new file mode 100644
index 0000000..79f7960
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/http_request.go
@@ -0,0 +1,24 @@
+package request
+
+import (
+        "io"
+        "net/http"
+        "net/url"
+)
+
+func copyHTTPRequest(r *http.Request, body io.ReadCloser) *http.Request {
+        req := new(http.Request)
+        *req = *r
+        req.URL = &url.URL{}
+        *req.URL = *r.URL
+        req.Body = body
+
+        req.Header = http.Header{}
+        for k, v := range r.Header {
+                for _, vv := range v {
+                        req.Header.Add(k, vv)
+                }
+        }
+
+        return req
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/offset_reader.go b/vendor/github.com/aws/aws-sdk-go/aws/request/offset_reader.go
new file mode 100644
index 0000000..02f07f4
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/offset_reader.go
@@ -0,0 +1,58 @@
+package request
+
+import (
+        "io"
+        "sync"
+)
+
+// offsetReader is a thread-safe io.ReadCloser to prevent racing
+// with retrying requests
+type offsetReader struct {
+        buf    io.ReadSeeker
+        lock   sync.Mutex
+        closed bool
+}
+
+func newOffsetReader(buf io.ReadSeeker, offset int64) *offsetReader {
+        reader := &offsetReader{}
+        buf.Seek(offset, 0)
+
+        reader.buf = buf
+        return reader
+}
+
+// Close will close the instance of the offset reader's access to
+// the underlying io.ReadSeeker.
+func (o *offsetReader) Close() error {
+        o.lock.Lock()
+        defer o.lock.Unlock()
+        o.closed = true
+        return nil
+}
+
+// Read is a thread-safe read of the underlying io.ReadSeeker
+func (o *offsetReader) Read(p []byte) (int, error) {
+        o.lock.Lock()
+        defer o.lock.Unlock()
+
+        if o.closed {
+                return 0, io.EOF
+        }
+
+        return o.buf.Read(p)
+}
+
+// Seek is a thread-safe seeking operation.
+func (o *offsetReader) Seek(offset int64, whence int) (int64, error) {
+        o.lock.Lock()
+        defer o.lock.Unlock()
+
+        return o.buf.Seek(offset, whence)
+}
+
+// CloseAndCopy will return a new offsetReader with a copy of the old buffer
+// and close the old buffer.
+func (o *offsetReader) CloseAndCopy(offset int64) *offsetReader {
+        o.Close()
+        return newOffsetReader(o.buf, offset)
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/request.go b/vendor/github.com/aws/aws-sdk-go/aws/request/request.go
new file mode 100644
index 0000000..4f4f112
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/request.go
@@ -0,0 +1,575 @@
+package request
+
+import (
+        "bytes"
+        "fmt"
+        "io"
+        "net"
+        "net/http"
+        "net/url"
+        "reflect"
+        "strings"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/client/metadata"
+)
+
+const (
+        // ErrCodeSerialization is the serialization error code that is received
+        // during protocol unmarshaling.
+        ErrCodeSerialization = "SerializationError"
+
+        // ErrCodeRead is an error that is returned during HTTP reads.
+        ErrCodeRead = "ReadError"
+
+        // ErrCodeResponseTimeout is the connection timeout error that is recieved
+        // during body reads.
+        ErrCodeResponseTimeout = "ResponseTimeout"
+
+        // CanceledErrorCode is the error code that will be returned by an
+        // API request that was canceled. Requests given a aws.Context may
+        // return this error when canceled.
+        CanceledErrorCode = "RequestCanceled"
+)
+
+// A Request is the service request to be made.
+type Request struct {
+        Config     aws.Config
+        ClientInfo metadata.ClientInfo
+        Handlers   Handlers
+
+        Retryer
+        Time                   time.Time
+        ExpireTime             time.Duration
+        Operation              *Operation
+        HTTPRequest            *http.Request
+        HTTPResponse           *http.Response
+        Body                   io.ReadSeeker
+        BodyStart              int64 // offset from beginning of Body that the request body starts
+        Params                 interface{}
+        Error                  error
+        Data                   interface{}
+        RequestID              string
+        RetryCount             int
+        Retryable              *bool
+        RetryDelay             time.Duration
+        NotHoist               bool
+        SignedHeaderVals       http.Header
+        LastSignedAt           time.Time
+        DisableFollowRedirects bool
+
+        context aws.Context
+
+        built bool
+
+        // Need to persist an intermediate body between the input Body and HTTP
+        // request body because the HTTP Client's transport can maintain a reference
+        // to the HTTP request's body after the client has returned. This value is
+        // safe to use concurrently and wrap the input Body for each HTTP request.
+        safeBody *offsetReader
+}
+
+// An Operation is the service API operation to be made.
+type Operation struct {
+        Name       string
+        HTTPMethod string
+        HTTPPath   string
+        *Paginator
+
+        BeforePresignFn func(r *Request) error
+}
+
+// New returns a new Request pointer for the service API
+// operation and parameters.
+//
+// Params is any value of input parameters to be the request payload.
+// Data is pointer value to an object which the request's response
+// payload will be deserialized to.
+func New(cfg aws.Config, clientInfo metadata.ClientInfo, handlers Handlers,
+        retryer Retryer, operation *Operation, params interface{}, data interface{}) *Request {
+
+        method := operation.HTTPMethod
+        if method == "" {
+                method = "POST"
+        }
+
+        httpReq, _ := http.NewRequest(method, "", nil)
+
+        var err error
+        httpReq.URL, err = url.Parse(clientInfo.Endpoint + operation.HTTPPath)
+        if err != nil {
+                httpReq.URL = &url.URL{}
+                err = awserr.New("InvalidEndpointURL", "invalid endpoint uri", err)
+        }
+
+        r := &Request{
+                Config:     cfg,
+                ClientInfo: clientInfo,
+                Handlers:   handlers.Copy(),
+
+                Retryer:     retryer,
+                Time:        time.Now(),
+                ExpireTime:  0,
+                Operation:   operation,
+                HTTPRequest: httpReq,
+                Body:        nil,
+                Params:      params,
+                Error:       err,
+                Data:        data,
+        }
+        r.SetBufferBody([]byte{})
+
+        return r
+}
+
+// A Option is a functional option that can augment or modify a request when
+// using a WithContext API operation method.
+type Option func(*Request)
+
+// WithGetResponseHeader builds a request Option which will retrieve a single
+// header value from the HTTP Response. If there are multiple values for the
+// header key use WithGetResponseHeaders instead to access the http.Header
+// map directly. The passed in val pointer must be non-nil.
+//
+// This Option can be used multiple times with a single API operation.
+//
+//    var id2, versionID string
+//    svc.PutObjectWithContext(ctx, params,
+//        request.WithGetResponseHeader("x-amz-id-2", &id2),
+//        request.WithGetResponseHeader("x-amz-version-id", &versionID),
+//    )
+func WithGetResponseHeader(key string, val *string) Option {
+        return func(r *Request) {
+                r.Handlers.Complete.PushBack(func(req *Request) {
+                        *val = req.HTTPResponse.Header.Get(key)
+                })
+        }
+}
+
+// WithGetResponseHeaders builds a request Option which will retrieve the
+// headers from the HTTP response and assign them to the passed in headers
+// variable. The passed in headers pointer must be non-nil.
+//
+//    var headers http.Header
+//    svc.PutObjectWithContext(ctx, params, request.WithGetResponseHeaders(&headers))
+func WithGetResponseHeaders(headers *http.Header) Option {
+        return func(r *Request) {
+                r.Handlers.Complete.PushBack(func(req *Request) {
+                        *headers = req.HTTPResponse.Header
+                })
+        }
+}
+
+// WithLogLevel is a request option that will set the request to use a specific
+// log level when the request is made.
+//
+//     svc.PutObjectWithContext(ctx, params, request.WithLogLevel(aws.LogDebugWithHTTPBody)
+func WithLogLevel(l aws.LogLevelType) Option {
+        return func(r *Request) {
+                r.Config.LogLevel = aws.LogLevel(l)
+        }
+}
+
+// ApplyOptions will apply each option to the request calling them in the order
+// the were provided.
+func (r *Request) ApplyOptions(opts ...Option) {
+        for _, opt := range opts {
+                opt(r)
+        }
+}
+
+// Context will always returns a non-nil context. If Request does not have a
+// context aws.BackgroundContext will be returned.
+func (r *Request) Context() aws.Context {
+        if r.context != nil {
+                return r.context
+        }
+        return aws.BackgroundContext()
+}
+
+// SetContext adds a Context to the current request that can be used to cancel
+// a in-flight request. The Context value must not be nil, or this method will
+// panic.
+//
+// Unlike http.Request.WithContext, SetContext does not return a copy of the
+// Request. It is not safe to use use a single Request value for multiple
+// requests. A new Request should be created for each API operation request.
+//
+// Go 1.6 and below:
+// The http.Request's Cancel field will be set to the Done() value of
+// the context. This will overwrite the Cancel field's value.
+//
+// Go 1.7 and above:
+// The http.Request.WithContext will be used to set the context on the underlying
+// http.Request. This will create a shallow copy of the http.Request. The SDK
+// may create sub contexts in the future for nested requests such as retries.
+func (r *Request) SetContext(ctx aws.Context) {
+        if ctx == nil {
+                panic("context cannot be nil")
+        }
+        setRequestContext(r, ctx)
+}
+
+// WillRetry returns if the request's can be retried.
+func (r *Request) WillRetry() bool {
+        return r.Error != nil && aws.BoolValue(r.Retryable) && r.RetryCount < r.MaxRetries()
+}
+
+// ParamsFilled returns if the request's parameters have been populated
+// and the parameters are valid. False is returned if no parameters are
+// provided or invalid.
+func (r *Request) ParamsFilled() bool {
+        return r.Params != nil && reflect.ValueOf(r.Params).Elem().IsValid()
+}
+
+// DataFilled returns true if the request's data for response deserialization
+// target has been set and is a valid. False is returned if data is not
+// set, or is invalid.
+func (r *Request) DataFilled() bool {
+        return r.Data != nil && reflect.ValueOf(r.Data).Elem().IsValid()
+}
+
+// SetBufferBody will set the request's body bytes that will be sent to
+// the service API.
+func (r *Request) SetBufferBody(buf []byte) {
+        r.SetReaderBody(bytes.NewReader(buf))
+}
+
+// SetStringBody sets the body of the request to be backed by a string.
+func (r *Request) SetStringBody(s string) {
+        r.SetReaderBody(strings.NewReader(s))
+}
+
+// SetReaderBody will set the request's body reader.
+func (r *Request) SetReaderBody(reader io.ReadSeeker) {
+        r.Body = reader
+        r.ResetBody()
+}
+
+// Presign returns the request's signed URL. Error will be returned
+// if the signing fails.
+func (r *Request) Presign(expireTime time.Duration) (string, error) {
+        r.ExpireTime = expireTime
+        r.NotHoist = false
+
+        if r.Operation.BeforePresignFn != nil {
+                r = r.copy()
+                err := r.Operation.BeforePresignFn(r)
+                if err != nil {
+                        return "", err
+                }
+        }
+
+        r.Sign()
+        if r.Error != nil {
+                return "", r.Error
+        }
+        return r.HTTPRequest.URL.String(), nil
+}
+
+// PresignRequest behaves just like presign, but hoists all headers and signs them.
+// Also returns the signed hash back to the user
+func (r *Request) PresignRequest(expireTime time.Duration) (string, http.Header, error) {
+        r.ExpireTime = expireTime
+        r.NotHoist = true
+        r.Sign()
+        if r.Error != nil {
+                return "", nil, r.Error
+        }
+        return r.HTTPRequest.URL.String(), r.SignedHeaderVals, nil
+}
+
+func debugLogReqError(r *Request, stage string, retrying bool, err error) {
+        if !r.Config.LogLevel.Matches(aws.LogDebugWithRequestErrors) {
+                return
+        }
+
+        retryStr := "not retrying"
+        if retrying {
+                retryStr = "will retry"
+        }
+
+        r.Config.Logger.Log(fmt.Sprintf("DEBUG: %s %s/%s failed, %s, error %v",
+                stage, r.ClientInfo.ServiceName, r.Operation.Name, retryStr, err))
+}
+
+// Build will build the request's object so it can be signed and sent
+// to the service. Build will also validate all the request's parameters.
+// Anny additional build Handlers set on this request will be run
+// in the order they were set.
+//
+// The request will only be built once. Multiple calls to build will have
+// no effect.
+//
+// If any Validate or Build errors occur the build will stop and the error
+// which occurred will be returned.
+func (r *Request) Build() error {
+        if !r.built {
+                r.Handlers.Validate.Run(r)
+                if r.Error != nil {
+                        debugLogReqError(r, "Validate Request", false, r.Error)
+                        return r.Error
+                }
+                r.Handlers.Build.Run(r)
+                if r.Error != nil {
+                        debugLogReqError(r, "Build Request", false, r.Error)
+                        return r.Error
+                }
+                r.built = true
+        }
+
+        return r.Error
+}
+
+// Sign will sign the request returning error if errors are encountered.
+//
+// Send will build the request prior to signing. All Sign Handlers will
+// be executed in the order they were set.
+func (r *Request) Sign() error {
+        r.Build()
+        if r.Error != nil {
+                debugLogReqError(r, "Build Request", false, r.Error)
+                return r.Error
+        }
+
+        r.Handlers.Sign.Run(r)
+        return r.Error
+}
+
+// ResetBody rewinds the request body backto its starting position, and
+// set's the HTTP Request body reference. When the body is read prior
+// to being sent in the HTTP request it will need to be rewound.
+func (r *Request) ResetBody() {
+        if r.safeBody != nil {
+                r.safeBody.Close()
+        }
+
+        r.safeBody = newOffsetReader(r.Body, r.BodyStart)
+
+        // Go 1.8 tightened and clarified the rules code needs to use when building
+        // requests with the http package. Go 1.8 removed the automatic detection
+        // of if the Request.Body was empty, or actually had bytes in it. The SDK
+        // always sets the Request.Body even if it is empty and should not actually
+        // be sent. This is incorrect.
+        //
+        // Go 1.8 did add a http.NoBody value that the SDK can use to tell the http
+        // client that the request really should be sent without a body. The
+        // Request.Body cannot be set to nil, which is preferable, because the
+        // field is exported and could introduce nil pointer dereferences for users
+        // of the SDK if they used that field.
+        //
+        // Related golang/go#18257
+        l, err := computeBodyLength(r.Body)
+        if err != nil {
+                r.Error = awserr.New(ErrCodeSerialization, "failed to compute request body size", err)
+                return
+        }
+
+        if l == 0 {
+                r.HTTPRequest.Body = noBodyReader
+        } else if l > 0 {
+                r.HTTPRequest.Body = r.safeBody
+        } else {
+                // Hack to prevent sending bodies for methods where the body
+                // should be ignored by the server. Sending bodies on these
+                // methods without an associated ContentLength will cause the
+                // request to socket timeout because the server does not handle
+                // Transfer-Encoding: chunked bodies for these methods.
+                //
+                // This would only happen if a aws.ReaderSeekerCloser was used with
+                // a io.Reader that was not also an io.Seeker.
+                switch r.Operation.HTTPMethod {
+                case "GET", "HEAD", "DELETE":
+                        r.HTTPRequest.Body = noBodyReader
+                default:
+                        r.HTTPRequest.Body = r.safeBody
+                }
+        }
+}
+
+// Attempts to compute the length of the body of the reader using the
+// io.Seeker interface. If the value is not seekable because of being
+// a ReaderSeekerCloser without an unerlying Seeker -1 will be returned.
+// If no error occurs the length of the body will be returned.
+func computeBodyLength(r io.ReadSeeker) (int64, error) {
+        seekable := true
+        // Determine if the seeker is actually seekable. ReaderSeekerCloser
+        // hides the fact that a io.Readers might not actually be seekable.
+        switch v := r.(type) {
+        case aws.ReaderSeekerCloser:
+                seekable = v.IsSeeker()
+        case *aws.ReaderSeekerCloser:
+                seekable = v.IsSeeker()
+        }
+        if !seekable {
+                return -1, nil
+        }
+
+        curOffset, err := r.Seek(0, 1)
+        if err != nil {
+                return 0, err
+        }
+
+        endOffset, err := r.Seek(0, 2)
+        if err != nil {
+                return 0, err
+        }
+
+        _, err = r.Seek(curOffset, 0)
+        if err != nil {
+                return 0, err
+        }
+
+        return endOffset - curOffset, nil
+}
+
+// GetBody will return an io.ReadSeeker of the Request's underlying
+// input body with a concurrency safe wrapper.
+func (r *Request) GetBody() io.ReadSeeker {
+        return r.safeBody
+}
+
+// Send will send the request returning error if errors are encountered.
+//
+// Send will sign the request prior to sending. All Send Handlers will
+// be executed in the order they were set.
+//
+// Canceling a request is non-deterministic. If a request has been canceled,
+// then the transport will choose, randomly, one of the state channels during
+// reads or getting the connection.
+//
+// readLoop() and getConn(req *Request, cm connectMethod)
+// https://github.com/golang/go/blob/master/src/net/http/transport.go
+//
+// Send will not close the request.Request's body.
+func (r *Request) Send() error {
+        defer func() {
+                // Regardless of success or failure of the request trigger the Complete
+                // request handlers.
+                r.Handlers.Complete.Run(r)
+        }()
+
+        for {
+                if aws.BoolValue(r.Retryable) {
+                        if r.Config.LogLevel.Matches(aws.LogDebugWithRequestRetries) {
+                                r.Config.Logger.Log(fmt.Sprintf("DEBUG: Retrying Request %s/%s, attempt %d",
+                                        r.ClientInfo.ServiceName, r.Operation.Name, r.RetryCount))
+                        }
+
+                        // The previous http.Request will have a reference to the r.Body
+                        // and the HTTP Client's Transport may still be reading from
+                        // the request's body even though the Client's Do returned.
+                        r.HTTPRequest = copyHTTPRequest(r.HTTPRequest, nil)
+                        r.ResetBody()
+
+                        // Closing response body to ensure that no response body is leaked
+                        // between retry attempts.
+                        if r.HTTPResponse != nil && r.HTTPResponse.Body != nil {
+                                r.HTTPResponse.Body.Close()
+                        }
+                }
+
+                r.Sign()
+                if r.Error != nil {
+                        return r.Error
+                }
+
+                r.Retryable = nil
+
+                r.Handlers.Send.Run(r)
+                if r.Error != nil {
+                        if !shouldRetryCancel(r) {
+                                return r.Error
+                        }
+
+                        err := r.Error
+                        r.Handlers.Retry.Run(r)
+                        r.Handlers.AfterRetry.Run(r)
+                        if r.Error != nil {
+                                debugLogReqError(r, "Send Request", false, r.Error)
+                                return r.Error
+                        }
+                        debugLogReqError(r, "Send Request", true, err)
+                        continue
+                }
+                r.Handlers.UnmarshalMeta.Run(r)
+                r.Handlers.ValidateResponse.Run(r)
+                if r.Error != nil {
+                        err := r.Error
+                        r.Handlers.UnmarshalError.Run(r)
+                        r.Handlers.Retry.Run(r)
+                        r.Handlers.AfterRetry.Run(r)
+                        if r.Error != nil {
+                                debugLogReqError(r, "Validate Response", false, r.Error)
+                                return r.Error
+                        }
+                        debugLogReqError(r, "Validate Response", true, err)
+                        continue
+                }
+
+                r.Handlers.Unmarshal.Run(r)
+                if r.Error != nil {
+                        err := r.Error
+                        r.Handlers.Retry.Run(r)
+                        r.Handlers.AfterRetry.Run(r)
+                        if r.Error != nil {
+                                debugLogReqError(r, "Unmarshal Response", false, r.Error)
+                                return r.Error
+                        }
+                        debugLogReqError(r, "Unmarshal Response", true, err)
+                        continue
+                }
+
+                break
+        }
+
+        return nil
+}
+
+// copy will copy a request which will allow for local manipulation of the
+// request.
+func (r *Request) copy() *Request {
+        req := &Request{}
+        *req = *r
+        req.Handlers = r.Handlers.Copy()
+        op := *r.Operation
+        req.Operation = &op
+        return req
+}
+
+// AddToUserAgent adds the string to the end of the request's current user agent.
+func AddToUserAgent(r *Request, s string) {
+        curUA := r.HTTPRequest.Header.Get("User-Agent")
+        if len(curUA) > 0 {
+                s = curUA + " " + s
+        }
+        r.HTTPRequest.Header.Set("User-Agent", s)
+}
+
+func shouldRetryCancel(r *Request) bool {
+        awsErr, ok := r.Error.(awserr.Error)
+        timeoutErr := false
+        errStr := r.Error.Error()
+        if ok {
+                if awsErr.Code() == CanceledErrorCode {
+                        return false
+                }
+                err := awsErr.OrigErr()
+                netErr, netOK := err.(net.Error)
+                timeoutErr = netOK && netErr.Temporary()
+                if urlErr, ok := err.(*url.Error); !timeoutErr && ok {
+                        errStr = urlErr.Err.Error()
+                }
+        }
+
+        // There can be two types of canceled errors here.
+        // The first being a net.Error and the other being an error.
+        // If the request was timed out, we want to continue the retry
+        // process. Otherwise, return the canceled error.
+        return timeoutErr ||
+                (errStr != "net/http: request canceled" &&
+                        errStr != "net/http: request canceled while waiting for connection")
+
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/request_1_7.go b/vendor/github.com/aws/aws-sdk-go/aws/request/request_1_7.go
new file mode 100644
index 0000000..1323af9
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/request_1_7.go
@@ -0,0 +1,21 @@
+// +build !go1.8
+
+package request
+
+import "io"
+
+// NoBody is an io.ReadCloser with no bytes. Read always returns EOF
+// and Close always returns nil. It can be used in an outgoing client
+// request to explicitly signal that a request has zero bytes.
+// An alternative, however, is to simply set Request.Body to nil.
+//
+// Copy of Go 1.8 NoBody type from net/http/http.go
+type noBody struct{}
+
+func (noBody) Read([]byte) (int, error)         { return 0, io.EOF }
+func (noBody) Close() error                     { return nil }
+func (noBody) WriteTo(io.Writer) (int64, error) { return 0, nil }
+
+// Is an empty reader that will trigger the Go HTTP client to not include
+// and body in the HTTP request.
+var noBodyReader = noBody{}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/request_1_8.go b/vendor/github.com/aws/aws-sdk-go/aws/request/request_1_8.go
new file mode 100644
index 0000000..8b963f4
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/request_1_8.go
@@ -0,0 +1,9 @@
+// +build go1.8
+
+package request
+
+import "net/http"
+
+// Is a http.NoBody reader instructing Go HTTP client to not include
+// and body in the HTTP request.
+var noBodyReader = http.NoBody
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/request_context.go b/vendor/github.com/aws/aws-sdk-go/aws/request/request_context.go
new file mode 100644
index 0000000..a7365cd
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/request_context.go
@@ -0,0 +1,14 @@
+// +build go1.7
+
+package request
+
+import "github.com/aws/aws-sdk-go/aws"
+
+// setContext updates the Request to use the passed in context for cancellation.
+// Context will also be used for request retry delay.
+//
+// Creates shallow copy of the http.Request with the WithContext method.
+func setRequestContext(r *Request, ctx aws.Context) {
+        r.context = ctx
+        r.HTTPRequest = r.HTTPRequest.WithContext(ctx)
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/request_context_1_6.go b/vendor/github.com/aws/aws-sdk-go/aws/request/request_context_1_6.go
new file mode 100644
index 0000000..307fa07
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/request_context_1_6.go
@@ -0,0 +1,14 @@
+// +build !go1.7
+
+package request
+
+import "github.com/aws/aws-sdk-go/aws"
+
+// setContext updates the Request to use the passed in context for cancellation.
+// Context will also be used for request retry delay.
+//
+// Creates shallow copy of the http.Request with the WithContext method.
+func setRequestContext(r *Request, ctx aws.Context) {
+        r.context = ctx
+        r.HTTPRequest.Cancel = ctx.Done()
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/request_pagination.go b/vendor/github.com/aws/aws-sdk-go/aws/request/request_pagination.go
new file mode 100644
index 0000000..59de673
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/request_pagination.go
@@ -0,0 +1,236 @@
+package request
+
+import (
+        "reflect"
+        "sync/atomic"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awsutil"
+)
+
+// A Pagination provides paginating of SDK API operations which are paginatable.
+// Generally you should not use this type directly, but use the "Pages" API
+// operations method to automatically perform pagination for you. Such as,
+// "S3.ListObjectsPages", and "S3.ListObjectsPagesWithContext" methods.
+//
+// Pagination differs from a Paginator type in that pagination is the type that
+// does the pagination between API operations, and Paginator defines the
+// configuration that will be used per page request.
+//
+//     cont := true
+//     for p.Next() && cont {
+//         data := p.Page().(*s3.ListObjectsOutput)
+//         // process the page's data
+//     }
+//     return p.Err()
+//
+// See service client API operation Pages methods for examples how the SDK will
+// use the Pagination type.
+type Pagination struct {
+        // Function to return a Request value for each pagination request.
+        // Any configuration or handlers that need to be applied to the request
+        // prior to getting the next page should be done here before the request
+        // returned.
+        //
+        // NewRequest should always be built from the same API operations. It is
+        // undefined if different API operations are returned on subsequent calls.
+        NewRequest func() (*Request, error)
+
+        started    bool
+        nextTokens []interface{}
+
+        err     error
+        curPage interface{}
+}
+
+// HasNextPage will return true if Pagination is able to determine that the API
+// operation has additional pages. False will be returned if there are no more
+// pages remaining.
+//
+// Will always return true if Next has not been called yet.
+func (p *Pagination) HasNextPage() bool {
+        return !(p.started && len(p.nextTokens) == 0)
+}
+
+// Err returns the error Pagination encountered when retrieving the next page.
+func (p *Pagination) Err() error {
+        return p.err
+}
+
+// Page returns the current page. Page should only be called after a successful
+// call to Next. It is undefined what Page will return if Page is called after
+// Next returns false.
+func (p *Pagination) Page() interface{} {
+        return p.curPage
+}
+
+// Next will attempt to retrieve the next page for the API operation. When a page
+// is retrieved true will be returned. If the page cannot be retrieved, or there
+// are no more pages false will be returned.
+//
+// Use the Page method to retrieve the current page data. The data will need
+// to be cast to the API operation's output type.
+//
+// Use the Err method to determine if an error occurred if Page returns false.
+func (p *Pagination) Next() bool {
+        if !p.HasNextPage() {
+                return false
+        }
+
+        req, err := p.NewRequest()
+        if err != nil {
+                p.err = err
+                return false
+        }
+
+        if p.started {
+                for i, intok := range req.Operation.InputTokens {
+                        awsutil.SetValueAtPath(req.Params, intok, p.nextTokens[i])
+                }
+        }
+        p.started = true
+
+        err = req.Send()
+        if err != nil {
+                p.err = err
+                return false
+        }
+
+        p.nextTokens = req.nextPageTokens()
+        p.curPage = req.Data
+
+        return true
+}
+
+// A Paginator is the configuration data that defines how an API operation
+// should be paginated. This type is used by the API service models to define
+// the generated pagination config for service APIs.
+//
+// The Pagination type is what provides iterating between pages of an API. It
+// is only used to store the token metadata the SDK should use for performing
+// pagination.
+type Paginator struct {
+        InputTokens     []string
+        OutputTokens    []string
+        LimitToken      string
+        TruncationToken string
+}
+
+// nextPageTokens returns the tokens to use when asking for the next page of data.
+func (r *Request) nextPageTokens() []interface{} {
+        if r.Operation.Paginator == nil {
+                return nil
+        }
+        if r.Operation.TruncationToken != "" {
+                tr, _ := awsutil.ValuesAtPath(r.Data, r.Operation.TruncationToken)
+                if len(tr) == 0 {
+                        return nil
+                }
+
+                switch v := tr[0].(type) {
+                case *bool:
+                        if !aws.BoolValue(v) {
+                                return nil
+                        }
+                case bool:
+                        if v == false {
+                                return nil
+                        }
+                }
+        }
+
+        tokens := []interface{}{}
+        tokenAdded := false
+        for _, outToken := range r.Operation.OutputTokens {
+                v, _ := awsutil.ValuesAtPath(r.Data, outToken)
+                if len(v) > 0 {
+                        tokens = append(tokens, v[0])
+                        tokenAdded = true
+                } else {
+                        tokens = append(tokens, nil)
+                }
+        }
+        if !tokenAdded {
+                return nil
+        }
+
+        return tokens
+}
+
+// Ensure a deprecated item is only logged once instead of each time its used.
+func logDeprecatedf(logger aws.Logger, flag *int32, msg string) {
+        if logger == nil {
+                return
+        }
+        if atomic.CompareAndSwapInt32(flag, 0, 1) {
+                logger.Log(msg)
+        }
+}
+
+var (
+        logDeprecatedHasNextPage int32
+        logDeprecatedNextPage    int32
+        logDeprecatedEachPage    int32
+)
+
+// HasNextPage returns true if this request has more pages of data available.
+//
+// Deprecated Use Pagination type for configurable pagination of API operations
+func (r *Request) HasNextPage() bool {
+        logDeprecatedf(r.Config.Logger, &logDeprecatedHasNextPage,
+                "Request.HasNextPage deprecated. Use Pagination type for configurable pagination of API operations")
+
+        return len(r.nextPageTokens()) > 0
+}
+
+// NextPage returns a new Request that can be executed to return the next
+// page of result data. Call .Send() on this request to execute it.
+//
+// Deprecated Use Pagination type for configurable pagination of API operations
+func (r *Request) NextPage() *Request {
+        logDeprecatedf(r.Config.Logger, &logDeprecatedNextPage,
+                "Request.NextPage deprecated. Use Pagination type for configurable pagination of API operations")
+
+        tokens := r.nextPageTokens()
+        if len(tokens) == 0 {
+                return nil
+        }
+
+        data := reflect.New(reflect.TypeOf(r.Data).Elem()).Interface()
+        nr := New(r.Config, r.ClientInfo, r.Handlers, r.Retryer, r.Operation, awsutil.CopyOf(r.Params), data)
+        for i, intok := range nr.Operation.InputTokens {
+                awsutil.SetValueAtPath(nr.Params, intok, tokens[i])
+        }
+        return nr
+}
+
+// EachPage iterates over each page of a paginated request object. The fn
+// parameter should be a function with the following sample signature:
+//
+//   func(page *T, lastPage bool) bool {
+//       return true // return false to stop iterating
+//   }
+//
+// Where "T" is the structure type matching the output structure of the given
+// operation. For example, a request object generated by
+// DynamoDB.ListTablesRequest() would expect to see dynamodb.ListTablesOutput
+// as the structure "T". The lastPage value represents whether the page is
+// the last page of data or not. The return value of this function should
+// return true to keep iterating or false to stop.
+//
+// Deprecated Use Pagination type for configurable pagination of API operations
+func (r *Request) EachPage(fn func(data interface{}, isLastPage bool) (shouldContinue bool)) error {
+        logDeprecatedf(r.Config.Logger, &logDeprecatedEachPage,
+                "Request.EachPage deprecated. Use Pagination type for configurable pagination of API operations")
+
+        for page := r; page != nil; page = page.NextPage() {
+                if err := page.Send(); err != nil {
+                        return err
+                }
+                if getNextPage := fn(page.Data, !page.HasNextPage()); !getNextPage {
+                        return page.Error
+                }
+        }
+
+        return nil
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/retryer.go b/vendor/github.com/aws/aws-sdk-go/aws/request/retryer.go
new file mode 100644
index 0000000..7af81de
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/retryer.go
@@ -0,0 +1,154 @@
+package request
+
+import (
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awserr"
+)
+
+// Retryer is an interface to control retry logic for a given service.
+// The default implementation used by most services is the service.DefaultRetryer
+// structure, which contains basic retry logic using exponential backoff.
+type Retryer interface {
+        RetryRules(*Request) time.Duration
+        ShouldRetry(*Request) bool
+        MaxRetries() int
+}
+
+// WithRetryer sets a config Retryer value to the given Config returning it
+// for chaining.
+func WithRetryer(cfg *aws.Config, retryer Retryer) *aws.Config {
+        cfg.Retryer = retryer
+        return cfg
+}
+
+// retryableCodes is a collection of service response codes which are retry-able
+// without any further action.
+var retryableCodes = map[string]struct{}{
+        "RequestError":            {},
+        "RequestTimeout":          {},
+        ErrCodeResponseTimeout:    {},
+        "RequestTimeoutException": {}, // Glacier's flavor of RequestTimeout
+}
+
+var throttleCodes = map[string]struct{}{
+        "ProvisionedThroughputExceededException": {},
+        "Throttling":                             {},
+        "ThrottlingException":                    {},
+        "RequestLimitExceeded":                   {},
+        "RequestThrottled":                       {},
+        "LimitExceededException":                 {}, // Deleting 10+ DynamoDb tables at once
+        "TooManyRequestsException":               {}, // Lambda functions
+        "PriorRequestNotComplete":                {}, // Route53
+}
+
+// credsExpiredCodes is a collection of error codes which signify the credentials
+// need to be refreshed. Expired tokens require refreshing of credentials, and
+// resigning before the request can be retried.
+var credsExpiredCodes = map[string]struct{}{
+        "ExpiredToken":          {},
+        "ExpiredTokenException": {},
+        "RequestExpired":        {}, // EC2 Only
+}
+
+func isCodeThrottle(code string) bool {
+        _, ok := throttleCodes[code]
+        return ok
+}
+
+func isCodeRetryable(code string) bool {
+        if _, ok := retryableCodes[code]; ok {
+                return true
+        }
+
+        return isCodeExpiredCreds(code)
+}
+
+func isCodeExpiredCreds(code string) bool {
+        _, ok := credsExpiredCodes[code]
+        return ok
+}
+
+var validParentCodes = map[string]struct{}{
+        ErrCodeSerialization: struct{}{},
+        ErrCodeRead:          struct{}{},
+}
+
+func isNestedErrorRetryable(parentErr awserr.Error) bool {
+        if parentErr == nil {
+                return false
+        }
+
+        if _, ok := validParentCodes[parentErr.Code()]; !ok {
+                return false
+        }
+
+        err := parentErr.OrigErr()
+        if err == nil {
+                return false
+        }
+
+        if aerr, ok := err.(awserr.Error); ok {
+                return isCodeRetryable(aerr.Code())
+        }
+
+        return isErrConnectionReset(err)
+}
+
+// IsErrorRetryable returns whether the error is retryable, based on its Code.
+// Returns false if error is nil.
+func IsErrorRetryable(err error) bool {
+        if err != nil {
+                if aerr, ok := err.(awserr.Error); ok {
+                        return isCodeRetryable(aerr.Code()) || isNestedErrorRetryable(aerr)
+                }
+        }
+        return false
+}
+
+// IsErrorThrottle returns whether the error is to be throttled based on its code.
+// Returns false if error is nil.
+func IsErrorThrottle(err error) bool {
+        if err != nil {
+                if aerr, ok := err.(awserr.Error); ok {
+                        return isCodeThrottle(aerr.Code())
+                }
+        }
+        return false
+}
+
+// IsErrorExpiredCreds returns whether the error code is a credential expiry error.
+// Returns false if error is nil.
+func IsErrorExpiredCreds(err error) bool {
+        if err != nil {
+                if aerr, ok := err.(awserr.Error); ok {
+                        return isCodeExpiredCreds(aerr.Code())
+                }
+        }
+        return false
+}
+
+// IsErrorRetryable returns whether the error is retryable, based on its Code.
+// Returns false if the request has no Error set.
+//
+// Alias for the utility function IsErrorRetryable
+func (r *Request) IsErrorRetryable() bool {
+        return IsErrorRetryable(r.Error)
+}
+
+// IsErrorThrottle returns whether the error is to be throttled based on its code.
+// Returns false if the request has no Error set
+//
+// Alias for the utility function IsErrorThrottle
+func (r *Request) IsErrorThrottle() bool {
+        return IsErrorThrottle(r.Error)
+}
+
+// IsErrorExpired returns whether the error code is a credential expiry error.
+// Returns false if the request has no Error set.
+//
+// Alias for the utility function IsErrorExpiredCreds
+func (r *Request) IsErrorExpired() bool {
+        return IsErrorExpiredCreds(r.Error)
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/timeout_read_closer.go b/vendor/github.com/aws/aws-sdk-go/aws/request/timeout_read_closer.go
new file mode 100644
index 0000000..09a44eb
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/timeout_read_closer.go
@@ -0,0 +1,94 @@
+package request
+
+import (
+        "io"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws/awserr"
+)
+
+var timeoutErr = awserr.New(
+        ErrCodeResponseTimeout,
+        "read on body has reached the timeout limit",
+        nil,
+)
+
+type readResult struct {
+        n   int
+        err error
+}
+
+// timeoutReadCloser will handle body reads that take too long.
+// We will return a ErrReadTimeout error if a timeout occurs.
+type timeoutReadCloser struct {
+        reader   io.ReadCloser
+        duration time.Duration
+}
+
+// Read will spin off a goroutine to call the reader's Read method. We will
+// select on the timer's channel or the read's channel. Whoever completes first
+// will be returned.
+func (r *timeoutReadCloser) Read(b []byte) (int, error) {
+        timer := time.NewTimer(r.duration)
+        c := make(chan readResult, 1)
+
+        go func() {
+                n, err := r.reader.Read(b)
+                timer.Stop()
+                c <- readResult{n: n, err: err}
+        }()
+
+        select {
+        case data := <-c:
+                return data.n, data.err
+        case <-timer.C:
+                return 0, timeoutErr
+        }
+}
+
+func (r *timeoutReadCloser) Close() error {
+        return r.reader.Close()
+}
+
+const (
+        // HandlerResponseTimeout is what we use to signify the name of the
+        // response timeout handler.
+        HandlerResponseTimeout = "ResponseTimeoutHandler"
+)
+
+// adaptToResponseTimeoutError is a handler that will replace any top level error
+// to a ErrCodeResponseTimeout, if its child is that.
+func adaptToResponseTimeoutError(req *Request) {
+        if err, ok := req.Error.(awserr.Error); ok {
+                aerr, ok := err.OrigErr().(awserr.Error)
+                if ok && aerr.Code() == ErrCodeResponseTimeout {
+                        req.Error = aerr
+                }
+        }
+}
+
+// WithResponseReadTimeout is a request option that will wrap the body in a timeout read closer.
+// This will allow for per read timeouts. If a timeout occurred, we will return the
+// ErrCodeResponseTimeout.
+//
+//     svc.PutObjectWithContext(ctx, params, request.WithTimeoutReadCloser(30 * time.Second)
+func WithResponseReadTimeout(duration time.Duration) Option {
+        return func(r *Request) {
+
+                var timeoutHandler = NamedHandler{
+                        HandlerResponseTimeout,
+                        func(req *Request) {
+                                req.HTTPResponse.Body = &timeoutReadCloser{
+                                        reader:   req.HTTPResponse.Body,
+                                        duration: duration,
+                                }
+                        }}
+
+                // remove the handler so we are not stomping over any new durations.
+                r.Handlers.Send.RemoveByName(HandlerResponseTimeout)
+                r.Handlers.Send.PushBackNamed(timeoutHandler)
+
+                r.Handlers.Unmarshal.PushBack(adaptToResponseTimeoutError)
+                r.Handlers.UnmarshalError.PushBack(adaptToResponseTimeoutError)
+        }
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/validation.go b/vendor/github.com/aws/aws-sdk-go/aws/request/validation.go
new file mode 100644
index 0000000..2520286
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/validation.go
@@ -0,0 +1,234 @@
+package request
+
+import (
+        "bytes"
+        "fmt"
+
+        "github.com/aws/aws-sdk-go/aws/awserr"
+)
+
+const (
+        // InvalidParameterErrCode is the error code for invalid parameters errors
+        InvalidParameterErrCode = "InvalidParameter"
+        // ParamRequiredErrCode is the error code for required parameter errors
+        ParamRequiredErrCode = "ParamRequiredError"
+        // ParamMinValueErrCode is the error code for fields with too low of a
+        // number value.
+        ParamMinValueErrCode = "ParamMinValueError"
+        // ParamMinLenErrCode is the error code for fields without enough elements.
+        ParamMinLenErrCode = "ParamMinLenError"
+)
+
+// Validator provides a way for types to perform validation logic on their
+// input values that external code can use to determine if a type's values
+// are valid.
+type Validator interface {
+        Validate() error
+}
+
+// An ErrInvalidParams provides wrapping of invalid parameter errors found when
+// validating API operation input parameters.
+type ErrInvalidParams struct {
+        // Context is the base context of the invalid parameter group.
+        Context string
+        errs    []ErrInvalidParam
+}
+
+// Add adds a new invalid parameter error to the collection of invalid
+// parameters. The context of the invalid parameter will be updated to reflect
+// this collection.
+func (e *ErrInvalidParams) Add(err ErrInvalidParam) {
+        err.SetContext(e.Context)
+        e.errs = append(e.errs, err)
+}
+
+// AddNested adds the invalid parameter errors from another ErrInvalidParams
+// value into this collection. The nested errors will have their nested context
+// updated and base context to reflect the merging.
+//
+// Use for nested validations errors.
+func (e *ErrInvalidParams) AddNested(nestedCtx string, nested ErrInvalidParams) {
+        for _, err := range nested.errs {
+                err.SetContext(e.Context)
+                err.AddNestedContext(nestedCtx)
+                e.errs = append(e.errs, err)
+        }
+}
+
+// Len returns the number of invalid parameter errors
+func (e ErrInvalidParams) Len() int {
+        return len(e.errs)
+}
+
+// Code returns the code of the error
+func (e ErrInvalidParams) Code() string {
+        return InvalidParameterErrCode
+}
+
+// Message returns the message of the error
+func (e ErrInvalidParams) Message() string {
+        return fmt.Sprintf("%d validation error(s) found.", len(e.errs))
+}
+
+// Error returns the string formatted form of the invalid parameters.
+func (e ErrInvalidParams) Error() string {
+        w := &bytes.Buffer{}
+        fmt.Fprintf(w, "%s: %s\n", e.Code(), e.Message())
+
+        for _, err := range e.errs {
+                fmt.Fprintf(w, "- %s\n", err.Message())
+        }
+
+        return w.String()
+}
+
+// OrigErr returns the invalid parameters as a awserr.BatchedErrors value
+func (e ErrInvalidParams) OrigErr() error {
+        return awserr.NewBatchError(
+                InvalidParameterErrCode, e.Message(), e.OrigErrs())
+}
+
+// OrigErrs returns a slice of the invalid parameters
+func (e ErrInvalidParams) OrigErrs() []error {
+        errs := make([]error, len(e.errs))
+        for i := 0; i < len(errs); i++ {
+                errs[i] = e.errs[i]
+        }
+
+        return errs
+}
+
+// An ErrInvalidParam represents an invalid parameter error type.
+type ErrInvalidParam interface {
+        awserr.Error
+
+        // Field name the error occurred on.
+        Field() string
+
+        // SetContext updates the context of the error.
+        SetContext(string)
+
+        // AddNestedContext updates the error's context to include a nested level.
+        AddNestedContext(string)
+}
+
+type errInvalidParam struct {
+        context       string
+        nestedContext string
+        field         string
+        code          string
+        msg           string
+}
+
+// Code returns the error code for the type of invalid parameter.
+func (e *errInvalidParam) Code() string {
+        return e.code
+}
+
+// Message returns the reason the parameter was invalid, and its context.
+func (e *errInvalidParam) Message() string {
+        return fmt.Sprintf("%s, %s.", e.msg, e.Field())
+}
+
+// Error returns the string version of the invalid parameter error.
+func (e *errInvalidParam) Error() string {
+        return fmt.Sprintf("%s: %s", e.code, e.Message())
+}
+
+// OrigErr returns nil, Implemented for awserr.Error interface.
+func (e *errInvalidParam) OrigErr() error {
+        return nil
+}
+
+// Field Returns the field and context the error occurred.
+func (e *errInvalidParam) Field() string {
+        field := e.context
+        if len(field) > 0 {
+                field += "."
+        }
+        if len(e.nestedContext) > 0 {
+                field += fmt.Sprintf("%s.", e.nestedContext)
+        }
+        field += e.field
+
+        return field
+}
+
+// SetContext updates the base context of the error.
+func (e *errInvalidParam) SetContext(ctx string) {
+        e.context = ctx
+}
+
+// AddNestedContext prepends a context to the field's path.
+func (e *errInvalidParam) AddNestedContext(ctx string) {
+        if len(e.nestedContext) == 0 {
+                e.nestedContext = ctx
+        } else {
+                e.nestedContext = fmt.Sprintf("%s.%s", ctx, e.nestedContext)
+        }
+
+}
+
+// An ErrParamRequired represents an required parameter error.
+type ErrParamRequired struct {
+        errInvalidParam
+}
+
+// NewErrParamRequired creates a new required parameter error.
+func NewErrParamRequired(field string) *ErrParamRequired {
+        return &ErrParamRequired{
+                errInvalidParam{
+                        code:  ParamRequiredErrCode,
+                        field: field,
+                        msg:   fmt.Sprintf("missing required field"),
+                },
+        }
+}
+
+// An ErrParamMinValue represents a minimum value parameter error.
+type ErrParamMinValue struct {
+        errInvalidParam
+        min float64
+}
+
+// NewErrParamMinValue creates a new minimum value parameter error.
+func NewErrParamMinValue(field string, min float64) *ErrParamMinValue {
+        return &ErrParamMinValue{
+                errInvalidParam: errInvalidParam{
+                        code:  ParamMinValueErrCode,
+                        field: field,
+                        msg:   fmt.Sprintf("minimum field value of %v", min),
+                },
+                min: min,
+        }
+}
+
+// MinValue returns the field's require minimum value.
+//
+// float64 is returned for both int and float min values.
+func (e *ErrParamMinValue) MinValue() float64 {
+        return e.min
+}
+
+// An ErrParamMinLen represents a minimum length parameter error.
+type ErrParamMinLen struct {
+        errInvalidParam
+        min int
+}
+
+// NewErrParamMinLen creates a new minimum length parameter error.
+func NewErrParamMinLen(field string, min int) *ErrParamMinLen {
+        return &ErrParamMinLen{
+                errInvalidParam: errInvalidParam{
+                        code:  ParamMinValueErrCode,
+                        field: field,
+                        msg:   fmt.Sprintf("minimum field size of %v", min),
+                },
+                min: min,
+        }
+}
+
+// MinLen returns the field's required minimum length.
+func (e *ErrParamMinLen) MinLen() int {
+        return e.min
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/waiter.go b/vendor/github.com/aws/aws-sdk-go/aws/request/waiter.go
new file mode 100644
index 0000000..22d2f80
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/waiter.go
@@ -0,0 +1,287 @@
+package request
+
+import (
+        "fmt"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/awsutil"
+)
+
+// WaiterResourceNotReadyErrorCode is the error code returned by a waiter when
+// the waiter's max attempts have been exhausted.
+const WaiterResourceNotReadyErrorCode = "ResourceNotReady"
+
+// A WaiterOption is a function that will update the Waiter value's fields to
+// configure the waiter.
+type WaiterOption func(*Waiter)
+
+// WithWaiterMaxAttempts returns the maximum number of times the waiter should
+// attempt to check the resource for the target state.
+func WithWaiterMaxAttempts(max int) WaiterOption {
+        return func(w *Waiter) {
+                w.MaxAttempts = max
+        }
+}
+
+// WaiterDelay will return a delay the waiter should pause between attempts to
+// check the resource state. The passed in attempt is the number of times the
+// Waiter has checked the resource state.
+//
+// Attempt is the number of attempts the Waiter has made checking the resource
+// state.
+type WaiterDelay func(attempt int) time.Duration
+
+// ConstantWaiterDelay returns a WaiterDelay that will always return a constant
+// delay the waiter should use between attempts. It ignores the number of
+// attempts made.
+func ConstantWaiterDelay(delay time.Duration) WaiterDelay {
+        return func(attempt int) time.Duration {
+                return delay
+        }
+}
+
+// WithWaiterDelay will set the Waiter to use the WaiterDelay passed in.
+func WithWaiterDelay(delayer WaiterDelay) WaiterOption {
+        return func(w *Waiter) {
+                w.Delay = delayer
+        }
+}
+
+// WithWaiterLogger returns a waiter option to set the logger a waiter
+// should use to log warnings and errors to.
+func WithWaiterLogger(logger aws.Logger) WaiterOption {
+        return func(w *Waiter) {
+                w.Logger = logger
+        }
+}
+
+// WithWaiterRequestOptions returns a waiter option setting the request
+// options for each request the waiter makes. Appends to waiter's request
+// options already set.
+func WithWaiterRequestOptions(opts ...Option) WaiterOption {
+        return func(w *Waiter) {
+                w.RequestOptions = append(w.RequestOptions, opts...)
+        }
+}
+
+// A Waiter provides the functionality to perform a blocking call which will
+// wait for a resource state to be satisfied by a service.
+//
+// This type should not be used directly. The API operations provided in the
+// service packages prefixed with "WaitUntil" should be used instead.
+type Waiter struct {
+        Name      string
+        Acceptors []WaiterAcceptor
+        Logger    aws.Logger
+
+        MaxAttempts int
+        Delay       WaiterDelay
+
+        RequestOptions []Option
+        NewRequest     func([]Option) (*Request, error)
+}
+
+// ApplyOptions updates the waiter with the list of waiter options provided.
+func (w *Waiter) ApplyOptions(opts ...WaiterOption) {
+        for _, fn := range opts {
+                fn(w)
+        }
+}
+
+// WaiterState are states the waiter uses based on WaiterAcceptor definitions
+// to identify if the resource state the waiter is waiting on has occurred.
+type WaiterState int
+
+// String returns the string representation of the waiter state.
+func (s WaiterState) String() string {
+        switch s {
+        case SuccessWaiterState:
+                return "success"
+        case FailureWaiterState:
+                return "failure"
+        case RetryWaiterState:
+                return "retry"
+        default:
+                return "unknown waiter state"
+        }
+}
+
+// States the waiter acceptors will use to identify target resource states.
+const (
+        SuccessWaiterState WaiterState = iota // waiter successful
+        FailureWaiterState                    // waiter failed
+        RetryWaiterState                      // waiter needs to be retried
+)
+
+// WaiterMatchMode is the mode that the waiter will use to match the WaiterAcceptor
+// definition's Expected attribute.
+type WaiterMatchMode int
+
+// Modes the waiter will use when inspecting API response to identify target
+// resource states.
+const (
+        PathAllWaiterMatch  WaiterMatchMode = iota // match on all paths
+        PathWaiterMatch                            // match on specific path
+        PathAnyWaiterMatch                         // match on any path
+        PathListWaiterMatch                        // match on list of paths
+        StatusWaiterMatch                          // match on status code
+        ErrorWaiterMatch                           // match on error
+)
+
+// String returns the string representation of the waiter match mode.
+func (m WaiterMatchMode) String() string {
+        switch m {
+        case PathAllWaiterMatch:
+                return "pathAll"
+        case PathWaiterMatch:
+                return "path"
+        case PathAnyWaiterMatch:
+                return "pathAny"
+        case PathListWaiterMatch:
+                return "pathList"
+        case StatusWaiterMatch:
+                return "status"
+        case ErrorWaiterMatch:
+                return "error"
+        default:
+                return "unknown waiter match mode"
+        }
+}
+
+// WaitWithContext will make requests for the API operation using NewRequest to
+// build API requests. The request's response will be compared against the
+// Waiter's Acceptors to determine the successful state of the resource the
+// waiter is inspecting.
+//
+// The passed in context must not be nil. If it is nil a panic will occur. The
+// Context will be used to cancel the waiter's pending requests and retry delays.
+// Use aws.BackgroundContext if no context is available.
+//
+// The waiter will continue until the target state defined by the Acceptors,
+// or the max attempts expires.
+//
+// Will return the WaiterResourceNotReadyErrorCode error code if the waiter's
+// retryer ShouldRetry returns false. This normally will happen when the max
+// wait attempts expires.
+func (w Waiter) WaitWithContext(ctx aws.Context) error {
+
+        for attempt := 1; ; attempt++ {
+                req, err := w.NewRequest(w.RequestOptions)
+                if err != nil {
+                        waiterLogf(w.Logger, "unable to create request %v", err)
+                        return err
+                }
+                req.Handlers.Build.PushBack(MakeAddToUserAgentFreeFormHandler("Waiter"))
+                err = req.Send()
+
+                // See if any of the acceptors match the request's response, or error
+                for _, a := range w.Acceptors {
+                        if matched, matchErr := a.match(w.Name, w.Logger, req, err); matched {
+                                return matchErr
+                        }
+                }
+
+                // The Waiter should only check the resource state MaxAttempts times
+                // This is here instead of in the for loop above to prevent delaying
+                // unnecessary when the waiter will not retry.
+                if attempt == w.MaxAttempts {
+                        break
+                }
+
+                // Delay to wait before inspecting the resource again
+                delay := w.Delay(attempt)
+                if sleepFn := req.Config.SleepDelay; sleepFn != nil {
+                        // Support SleepDelay for backwards compatibility and testing
+                        sleepFn(delay)
+                } else if err := aws.SleepWithContext(ctx, delay); err != nil {
+                        return awserr.New(CanceledErrorCode, "waiter context canceled", err)
+                }
+        }
+
+        return awserr.New(WaiterResourceNotReadyErrorCode, "exceeded wait attempts", nil)
+}
+
+// A WaiterAcceptor provides the information needed to wait for an API operation
+// to complete.
+type WaiterAcceptor struct {
+        State    WaiterState
+        Matcher  WaiterMatchMode
+        Argument string
+        Expected interface{}
+}
+
+// match returns if the acceptor found a match with the passed in request
+// or error. True is returned if the acceptor made a match, error is returned
+// if there was an error attempting to perform the match.
+func (a *WaiterAcceptor) match(name string, l aws.Logger, req *Request, err error) (bool, error) {
+        result := false
+        var vals []interface{}
+
+        switch a.Matcher {
+        case PathAllWaiterMatch, PathWaiterMatch:
+                // Require all matches to be equal for result to match
+                vals, _ = awsutil.ValuesAtPath(req.Data, a.Argument)
+                if len(vals) == 0 {
+                        break
+                }
+                result = true
+                for _, val := range vals {
+                        if !awsutil.DeepEqual(val, a.Expected) {
+                                result = false
+                                break
+                        }
+                }
+        case PathAnyWaiterMatch:
+                // Only a single match needs to equal for the result to match
+                vals, _ = awsutil.ValuesAtPath(req.Data, a.Argument)
+                for _, val := range vals {
+                        if awsutil.DeepEqual(val, a.Expected) {
+                                result = true
+                                break
+                        }
+                }
+        case PathListWaiterMatch:
+                // ignored matcher
+        case StatusWaiterMatch:
+                s := a.Expected.(int)
+                result = s == req.HTTPResponse.StatusCode
+        case ErrorWaiterMatch:
+                if aerr, ok := err.(awserr.Error); ok {
+                        result = aerr.Code() == a.Expected.(string)
+                }
+        default:
+                waiterLogf(l, "WARNING: Waiter %s encountered unexpected matcher: %s",
+                        name, a.Matcher)
+        }
+
+        if !result {
+                // If there was no matching result found there is nothing more to do
+                // for this response, retry the request.
+                return false, nil
+        }
+
+        switch a.State {
+        case SuccessWaiterState:
+                // waiter completed
+                return true, nil
+        case FailureWaiterState:
+                // Waiter failure state triggered
+                return true, awserr.New(WaiterResourceNotReadyErrorCode,
+                        "failed waiting for successful resource state", err)
+        case RetryWaiterState:
+                // clear the error and retry the operation
+                return false, nil
+        default:
+                waiterLogf(l, "WARNING: Waiter %s encountered unexpected state: %s",
+                        name, a.State)
+                return false, nil
+        }
+}
+
+func waiterLogf(logger aws.Logger, msg string, args ...interface{}) {
+        if logger != nil {
+                logger.Log(fmt.Sprintf(msg, args...))
+        }
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/session/doc.go b/vendor/github.com/aws/aws-sdk-go/aws/session/doc.go
new file mode 100644
index 0000000..ea7b886
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/session/doc.go
@@ -0,0 +1,273 @@
+/*
+Package session provides configuration for the SDK's service clients.
+
+Sessions can be shared across all service clients that share the same base
+configuration.  The Session is built from the SDK's default configuration and
+request handlers.
+
+Sessions should be cached when possible, because creating a new Session will
+load all configuration values from the environment, and config files each time
+the Session is created. Sharing the Session value across all of your service
+clients will ensure the configuration is loaded the fewest number of times possible.
+
+Concurrency
+
+Sessions are safe to use concurrently as long as the Session is not being
+modified. The SDK will not modify the Session once the Session has been created.
+Creating service clients concurrently from a shared Session is safe.
+
+Sessions from Shared Config
+
+Sessions can be created using the method above that will only load the
+additional config if the AWS_SDK_LOAD_CONFIG environment variable is set.
+Alternatively you can explicitly create a Session with shared config enabled.
+To do this you can use NewSessionWithOptions to configure how the Session will
+be created. Using the NewSessionWithOptions with SharedConfigState set to
+SharedConfigEnable will create the session as if the AWS_SDK_LOAD_CONFIG
+environment variable was set.
+
+Creating Sessions
+
+When creating Sessions optional aws.Config values can be passed in that will
+override the default, or loaded config values the Session is being created
+with. This allows you to provide additional, or case based, configuration
+as needed.
+
+By default NewSession will only load credentials from the shared credentials
+file (~/.aws/credentials). If the AWS_SDK_LOAD_CONFIG environment variable is
+set to a truthy value the Session will be created from the configuration
+values from the shared config (~/.aws/config) and shared credentials
+(~/.aws/credentials) files. See the section Sessions from Shared Config for
+more information.
+
+Create a Session with the default config and request handlers. With credentials
+region, and profile loaded from the environment and shared config automatically.
+Requires the AWS_PROFILE to be set, or "default" is used.
+
+        // Create Session
+        sess := session.Must(session.NewSession())
+
+        // Create a Session with a custom region
+        sess := session.Must(session.NewSession(&aws.Config{
+                Region: aws.String("us-east-1"),
+        }))
+
+        // Create a S3 client instance from a session
+        sess := session.Must(session.NewSession())
+
+        svc := s3.New(sess)
+
+Create Session With Option Overrides
+
+In addition to NewSession, Sessions can be created using NewSessionWithOptions.
+This func allows you to control and override how the Session will be created
+through code instead of being driven by environment variables only.
+
+Use NewSessionWithOptions when you want to provide the config profile, or
+override the shared config state (AWS_SDK_LOAD_CONFIG).
+
+        // Equivalent to session.NewSession()
+        sess := session.Must(session.NewSessionWithOptions(session.Options{
+                // Options
+        }))
+
+        // Specify profile to load for the session's config
+        sess := session.Must(session.NewSessionWithOptions(session.Options{
+                 Profile: "profile_name",
+        }))
+
+        // Specify profile for config and region for requests
+        sess := session.Must(session.NewSessionWithOptions(session.Options{
+                 Config: aws.Config{Region: aws.String("us-east-1")},
+                 Profile: "profile_name",
+        }))
+
+        // Force enable Shared Config support
+        sess := session.Must(session.NewSessionWithOptions(session.Options{
+                SharedConfigState: session.SharedConfigEnable,
+        }))
+
+Adding Handlers
+
+You can add handlers to a session for processing HTTP requests. All service
+clients that use the session inherit the handlers. For example, the following
+handler logs every request and its payload made by a service client:
+
+        // Create a session, and add additional handlers for all service
+        // clients created with the Session to inherit. Adds logging handler.
+        sess := session.Must(session.NewSession())
+
+        sess.Handlers.Send.PushFront(func(r *request.Request) {
+                // Log every request made and its payload
+                logger.Println("Request: %s/%s, Payload: %s",
+                        r.ClientInfo.ServiceName, r.Operation, r.Params)
+        })
+
+Deprecated "New" function
+
+The New session function has been deprecated because it does not provide good
+way to return errors that occur when loading the configuration files and values.
+Because of this, NewSession was created so errors can be retrieved when
+creating a session fails.
+
+Shared Config Fields
+
+By default the SDK will only load the shared credentials file's (~/.aws/credentials)
+credentials values, and all other config is provided by the environment variables,
+SDK defaults, and user provided aws.Config values.
+
+If the AWS_SDK_LOAD_CONFIG environment variable is set, or SharedConfigEnable
+option is used to create the Session the full shared config values will be
+loaded. This includes credentials, region, and support for assume role. In
+addition the Session will load its configuration from both the shared config
+file (~/.aws/config) and shared credentials file (~/.aws/credentials). Both
+files have the same format.
+
+If both config files are present the configuration from both files will be
+read. The Session will be created from configuration values from the shared
+credentials file (~/.aws/credentials) over those in the shared config file (~/.aws/config).
+
+Credentials are the values the SDK should use for authenticating requests with
+AWS Services. They arfrom a configuration file will need to include both
+aws_access_key_id and aws_secret_access_key must be provided together in the
+same file to be considered valid. The values will be ignored if not a complete
+group. aws_session_token is an optional field that can be provided if both of
+the other two fields are also provided.
+
+        aws_access_key_id = AKID
+        aws_secret_access_key = SECRET
+        aws_session_token = TOKEN
+
+Assume Role values allow you to configure the SDK to assume an IAM role using
+a set of credentials provided in a config file via the source_profile field.
+Both "role_arn" and "source_profile" are required. The SDK supports assuming
+a role with MFA token if the session option AssumeRoleTokenProvider
+is set.
+
+        role_arn = arn:aws:iam::<account_number>:role/<role_name>
+        source_profile = profile_with_creds
+        external_id = 1234
+        mfa_serial = <serial or mfa arn>
+        role_session_name = session_name
+
+Region is the region the SDK should use for looking up AWS service endpoints
+and signing requests.
+
+        region = us-east-1
+
+Assume Role with MFA token
+
+To create a session with support for assuming an IAM role with MFA set the
+session option AssumeRoleTokenProvider to a function that will prompt for the
+MFA token code when the SDK assumes the role and refreshes the role's credentials.
+This allows you to configure the SDK via the shared config to assumea role
+with MFA tokens.
+
+In order for the SDK to assume a role with MFA the SharedConfigState
+session option must be set to SharedConfigEnable, or AWS_SDK_LOAD_CONFIG
+environment variable set.
+
+The shared configuration instructs the SDK to assume an IAM role with MFA
+when the mfa_serial configuration field is set in the shared config
+(~/.aws/config) or shared credentials (~/.aws/credentials) file.
+
+If mfa_serial is set in the configuration, the SDK will assume the role, and
+the AssumeRoleTokenProvider session option is not set an an error will
+be returned when creating the session.
+
+    sess := session.Must(session.NewSessionWithOptions(session.Options{
+        AssumeRoleTokenProvider: stscreds.StdinTokenProvider,
+    }))
+
+    // Create service client value configured for credentials
+    // from assumed role.
+    svc := s3.New(sess)
+
+To setup assume role outside of a session see the stscrds.AssumeRoleProvider
+documentation.
+
+Environment Variables
+
+When a Session is created several environment variables can be set to adjust
+how the SDK functions, and what configuration data it loads when creating
+Sessions. All environment values are optional, but some values like credentials
+require multiple of the values to set or the partial values will be ignored.
+All environment variable values are strings unless otherwise noted.
+
+Environment configuration values. If set both Access Key ID and Secret Access
+Key must be provided. Session Token and optionally also be provided, but is
+not required.
+
+        # Access Key ID
+        AWS_ACCESS_KEY_ID=AKID
+        AWS_ACCESS_KEY=AKID # only read if AWS_ACCESS_KEY_ID is not set.
+
+        # Secret Access Key
+        AWS_SECRET_ACCESS_KEY=SECRET
+        AWS_SECRET_KEY=SECRET=SECRET # only read if AWS_SECRET_ACCESS_KEY is not set.
+
+        # Session Token
+        AWS_SESSION_TOKEN=TOKEN
+
+Region value will instruct the SDK where to make service API requests to. If is
+not provided in the environment the region must be provided before a service
+client request is made.
+
+        AWS_REGION=us-east-1
+
+        # AWS_DEFAULT_REGION is only read if AWS_SDK_LOAD_CONFIG is also set,
+        # and AWS_REGION is not also set.
+        AWS_DEFAULT_REGION=us-east-1
+
+Profile name the SDK should load use when loading shared config from the
+configuration files. If not provided "default" will be used as the profile name.
+
+        AWS_PROFILE=my_profile
+
+        # AWS_DEFAULT_PROFILE is only read if AWS_SDK_LOAD_CONFIG is also set,
+        # and AWS_PROFILE is not also set.
+        AWS_DEFAULT_PROFILE=my_profile
+
+SDK load config instructs the SDK to load the shared config in addition to
+shared credentials. This also expands the configuration loaded so the shared
+credentials will have parity with the shared config file. This also enables
+Region and Profile support for the AWS_DEFAULT_REGION and AWS_DEFAULT_PROFILE
+env values as well.
+
+        AWS_SDK_LOAD_CONFIG=1
+
+Shared credentials file path can be set to instruct the SDK to use an alternative
+file for the shared credentials. If not set the file will be loaded from
+$HOME/.aws/credentials on Linux/Unix based systems, and
+%USERPROFILE%\.aws\credentials on Windows.
+
+        AWS_SHARED_CREDENTIALS_FILE=$HOME/my_shared_credentials
+
+Shared config file path can be set to instruct the SDK to use an alternative
+file for the shared config. If not set the file will be loaded from
+$HOME/.aws/config on Linux/Unix based systems, and
+%USERPROFILE%\.aws\config on Windows.
+
+        AWS_CONFIG_FILE=$HOME/my_shared_config
+
+Path to a custom Credentials Authority (CA) bundle PEM file that the SDK
+will use instead of the default system's root CA bundle. Use this only
+if you want to replace the CA bundle the SDK uses for TLS requests.
+
+        AWS_CA_BUNDLE=$HOME/my_custom_ca_bundle
+
+Enabling this option will attempt to merge the Transport into the SDK's HTTP
+client. If the client's Transport is not a http.Transport an error will be
+returned. If the Transport's TLS config is set this option will cause the SDK
+to overwrite the Transport's TLS config's  RootCAs value. If the CA bundle file
+contains multiple certificates all of them will be loaded.
+
+The Session option CustomCABundle is also available when creating sessions
+to also enable this feature. CustomCABundle session option field has priority
+over the AWS_CA_BUNDLE environment variable, and will be used if both are set.
+
+Setting a custom HTTPClient in the aws.Config options will override this setting.
+To use this option and custom HTTP client, the HTTP client needs to be provided
+when creating the session. Not the service client.
+*/
+package session
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/session/env_config.go b/vendor/github.com/aws/aws-sdk-go/aws/session/env_config.go
new file mode 100644
index 0000000..e6278a7
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/session/env_config.go
@@ -0,0 +1,208 @@
+package session
+
+import (
+        "os"
+        "path/filepath"
+        "strconv"
+
+        "github.com/aws/aws-sdk-go/aws/credentials"
+)
+
+// envConfig is a collection of environment values the SDK will read
+// setup config from. All environment values are optional. But some values
+// such as credentials require multiple values to be complete or the values
+// will be ignored.
+type envConfig struct {
+        // Environment configuration values. If set both Access Key ID and Secret Access
+        // Key must be provided. Session Token and optionally also be provided, but is
+        // not required.
+        //
+        //      # Access Key ID
+        //      AWS_ACCESS_KEY_ID=AKID
+        //      AWS_ACCESS_KEY=AKID # only read if AWS_ACCESS_KEY_ID is not set.
+        //
+        //      # Secret Access Key
+        //      AWS_SECRET_ACCESS_KEY=SECRET
+        //      AWS_SECRET_KEY=SECRET=SECRET # only read if AWS_SECRET_ACCESS_KEY is not set.
+        //
+        //      # Session Token
+        //      AWS_SESSION_TOKEN=TOKEN
+        Creds credentials.Value
+
+        // Region value will instruct the SDK where to make service API requests to. If is
+        // not provided in the environment the region must be provided before a service
+        // client request is made.
+        //
+        //      AWS_REGION=us-east-1
+        //
+        //      # AWS_DEFAULT_REGION is only read if AWS_SDK_LOAD_CONFIG is also set,
+        //      # and AWS_REGION is not also set.
+        //      AWS_DEFAULT_REGION=us-east-1
+        Region string
+
+        // Profile name the SDK should load use when loading shared configuration from the
+        // shared configuration files. If not provided "default" will be used as the
+        // profile name.
+        //
+        //      AWS_PROFILE=my_profile
+        //
+        //      # AWS_DEFAULT_PROFILE is only read if AWS_SDK_LOAD_CONFIG is also set,
+        //      # and AWS_PROFILE is not also set.
+        //      AWS_DEFAULT_PROFILE=my_profile
+        Profile string
+
+        // SDK load config instructs the SDK to load the shared config in addition to
+        // shared credentials. This also expands the configuration loaded from the shared
+        // credentials to have parity with the shared config file. This also enables
+        // Region and Profile support for the AWS_DEFAULT_REGION and AWS_DEFAULT_PROFILE
+        // env values as well.
+        //
+        //      AWS_SDK_LOAD_CONFIG=1
+        EnableSharedConfig bool
+
+        // Shared credentials file path can be set to instruct the SDK to use an alternate
+        // file for the shared credentials. If not set the file will be loaded from
+        // $HOME/.aws/credentials on Linux/Unix based systems, and
+        // %USERPROFILE%\.aws\credentials on Windows.
+        //
+        //      AWS_SHARED_CREDENTIALS_FILE=$HOME/my_shared_credentials
+        SharedCredentialsFile string
+
+        // Shared config file path can be set to instruct the SDK to use an alternate
+        // file for the shared config. If not set the file will be loaded from
+        // $HOME/.aws/config on Linux/Unix based systems, and
+        // %USERPROFILE%\.aws\config on Windows.
+        //
+        //      AWS_CONFIG_FILE=$HOME/my_shared_config
+        SharedConfigFile string
+
+        // Sets the path to a custom Credentials Authroity (CA) Bundle PEM file
+        // that the SDK will use instead of the the system's root CA bundle.
+        // Only use this if you want to configure the SDK to use a custom set
+        // of CAs.
+        //
+        // Enabling this option will attempt to merge the Transport
+        // into the SDK's HTTP client. If the client's Transport is
+        // not a http.Transport an error will be returned. If the
+        // Transport's TLS config is set this option will cause the
+        // SDK to overwrite the Transport's TLS config's  RootCAs value.
+        //
+        // Setting a custom HTTPClient in the aws.Config options will override this setting.
+        // To use this option and custom HTTP client, the HTTP client needs to be provided
+        // when creating the session. Not the service client.
+        //
+        //  AWS_CA_BUNDLE=$HOME/my_custom_ca_bundle
+        CustomCABundle string
+}
+
+var (
+        credAccessEnvKey = []string{
+                "AWS_ACCESS_KEY_ID",
+                "AWS_ACCESS_KEY",
+        }
+        credSecretEnvKey = []string{
+                "AWS_SECRET_ACCESS_KEY",
+                "AWS_SECRET_KEY",
+        }
+        credSessionEnvKey = []string{
+                "AWS_SESSION_TOKEN",
+        }
+
+        regionEnvKeys = []string{
+                "AWS_REGION",
+                "AWS_DEFAULT_REGION", // Only read if AWS_SDK_LOAD_CONFIG is also set
+        }
+        profileEnvKeys = []string{
+                "AWS_PROFILE",
+                "AWS_DEFAULT_PROFILE", // Only read if AWS_SDK_LOAD_CONFIG is also set
+        }
+)
+
+// loadEnvConfig retrieves the SDK's environment configuration.
+// See `envConfig` for the values that will be retrieved.
+//
+// If the environment variable `AWS_SDK_LOAD_CONFIG` is set to a truthy value
+// the shared SDK config will be loaded in addition to the SDK's specific
+// configuration values.
+func loadEnvConfig() envConfig {
+        enableSharedConfig, _ := strconv.ParseBool(os.Getenv("AWS_SDK_LOAD_CONFIG"))
+        return envConfigLoad(enableSharedConfig)
+}
+
+// loadEnvSharedConfig retrieves the SDK's environment configuration, and the
+// SDK shared config. See `envConfig` for the values that will be retrieved.
+//
+// Loads the shared configuration in addition to the SDK's specific configuration.
+// This will load the same values as `loadEnvConfig` if the `AWS_SDK_LOAD_CONFIG`
+// environment variable is set.
+func loadSharedEnvConfig() envConfig {
+        return envConfigLoad(true)
+}
+
+func envConfigLoad(enableSharedConfig bool) envConfig {
+        cfg := envConfig{}
+
+        cfg.EnableSharedConfig = enableSharedConfig
+
+        setFromEnvVal(&cfg.Creds.AccessKeyID, credAccessEnvKey)
+        setFromEnvVal(&cfg.Creds.SecretAccessKey, credSecretEnvKey)
+        setFromEnvVal(&cfg.Creds.SessionToken, credSessionEnvKey)
+
+        // Require logical grouping of credentials
+        if len(cfg.Creds.AccessKeyID) == 0 || len(cfg.Creds.SecretAccessKey) == 0 {
+                cfg.Creds = credentials.Value{}
+        } else {
+                cfg.Creds.ProviderName = "EnvConfigCredentials"
+        }
+
+        regionKeys := regionEnvKeys
+        profileKeys := profileEnvKeys
+        if !cfg.EnableSharedConfig {
+                regionKeys = regionKeys[:1]
+                profileKeys = profileKeys[:1]
+        }
+
+        setFromEnvVal(&cfg.Region, regionKeys)
+        setFromEnvVal(&cfg.Profile, profileKeys)
+
+        cfg.SharedCredentialsFile = sharedCredentialsFilename()
+        cfg.SharedConfigFile = sharedConfigFilename()
+
+        cfg.CustomCABundle = os.Getenv("AWS_CA_BUNDLE")
+
+        return cfg
+}
+
+func setFromEnvVal(dst *string, keys []string) {
+        for _, k := range keys {
+                if v := os.Getenv(k); len(v) > 0 {
+                        *dst = v
+                        break
+                }
+        }
+}
+
+func sharedCredentialsFilename() string {
+        if name := os.Getenv("AWS_SHARED_CREDENTIALS_FILE"); len(name) > 0 {
+                return name
+        }
+
+        return filepath.Join(userHomeDir(), ".aws", "credentials")
+}
+
+func sharedConfigFilename() string {
+        if name := os.Getenv("AWS_CONFIG_FILE"); len(name) > 0 {
+                return name
+        }
+
+        return filepath.Join(userHomeDir(), ".aws", "config")
+}
+
+func userHomeDir() string {
+        homeDir := os.Getenv("HOME") // *nix
+        if len(homeDir) == 0 {       // windows
+                homeDir = os.Getenv("USERPROFILE")
+        }
+
+        return homeDir
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/session/session.go b/vendor/github.com/aws/aws-sdk-go/aws/session/session.go
new file mode 100644
index 0000000..4792d3a
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/session/session.go
@@ -0,0 +1,590 @@
+package session
+
+import (
+        "crypto/tls"
+        "crypto/x509"
+        "fmt"
+        "io"
+        "io/ioutil"
+        "net/http"
+        "os"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/client"
+        "github.com/aws/aws-sdk-go/aws/corehandlers"
+        "github.com/aws/aws-sdk-go/aws/credentials"
+        "github.com/aws/aws-sdk-go/aws/credentials/stscreds"
+        "github.com/aws/aws-sdk-go/aws/defaults"
+        "github.com/aws/aws-sdk-go/aws/endpoints"
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+// A Session provides a central location to create service clients from and
+// store configurations and request handlers for those services.
+//
+// Sessions are safe to create service clients concurrently, but it is not safe
+// to mutate the Session concurrently.
+//
+// The Session satisfies the service client's client.ClientConfigProvider.
+type Session struct {
+        Config   *aws.Config
+        Handlers request.Handlers
+}
+
+// New creates a new instance of the handlers merging in the provided configs
+// on top of the SDK's default configurations. Once the Session is created it
+// can be mutated to modify the Config or Handlers. The Session is safe to be
+// read concurrently, but it should not be written to concurrently.
+//
+// If the AWS_SDK_LOAD_CONFIG environment is set to a truthy value, the New
+// method could now encounter an error when loading the configuration. When
+// The environment variable is set, and an error occurs, New will return a
+// session that will fail all requests reporting the error that occurred while
+// loading the session. Use NewSession to get the error when creating the
+// session.
+//
+// If the AWS_SDK_LOAD_CONFIG environment variable is set to a truthy value
+// the shared config file (~/.aws/config) will also be loaded, in addition to
+// the shared credentials file (~/.aws/credentials). Values set in both the
+// shared config, and shared credentials will be taken from the shared
+// credentials file.
+//
+// Deprecated: Use NewSession functions to create sessions instead. NewSession
+// has the same functionality as New except an error can be returned when the
+// func is called instead of waiting to receive an error until a request is made.
+func New(cfgs ...*aws.Config) *Session {
+        // load initial config from environment
+        envCfg := loadEnvConfig()
+
+        if envCfg.EnableSharedConfig {
+                s, err := newSession(Options{}, envCfg, cfgs...)
+                if err != nil {
+                        // Old session.New expected all errors to be discovered when
+                        // a request is made, and would report the errors then. This
+                        // needs to be replicated if an error occurs while creating
+                        // the session.
+                        msg := "failed to create session with AWS_SDK_LOAD_CONFIG enabled. " +
+                                "Use session.NewSession to handle errors occurring during session creation."
+
+                        // Session creation failed, need to report the error and prevent
+                        // any requests from succeeding.
+                        s = &Session{Config: defaults.Config()}
+                        s.Config.MergeIn(cfgs...)
+                        s.Config.Logger.Log("ERROR:", msg, "Error:", err)
+                        s.Handlers.Validate.PushBack(func(r *request.Request) {
+                                r.Error = err
+                        })
+                }
+                return s
+        }
+
+        return deprecatedNewSession(cfgs...)
+}
+
+// NewSession returns a new Session created from SDK defaults, config files,
+// environment, and user provided config files. Once the Session is created
+// it can be mutated to modify the Config or Handlers. The Session is safe to
+// be read concurrently, but it should not be written to concurrently.
+//
+// If the AWS_SDK_LOAD_CONFIG environment variable is set to a truthy value
+// the shared config file (~/.aws/config) will also be loaded in addition to
+// the shared credentials file (~/.aws/credentials). Values set in both the
+// shared config, and shared credentials will be taken from the shared
+// credentials file. Enabling the Shared Config will also allow the Session
+// to be built with retrieving credentials with AssumeRole set in the config.
+//
+// See the NewSessionWithOptions func for information on how to override or
+// control through code how the Session will be created. Such as specifying the
+// config profile, and controlling if shared config is enabled or not.
+func NewSession(cfgs ...*aws.Config) (*Session, error) {
+        opts := Options{}
+        opts.Config.MergeIn(cfgs...)
+
+        return NewSessionWithOptions(opts)
+}
+
+// SharedConfigState provides the ability to optionally override the state
+// of the session's creation based on the shared config being enabled or
+// disabled.
+type SharedConfigState int
+
+const (
+        // SharedConfigStateFromEnv does not override any state of the
+        // AWS_SDK_LOAD_CONFIG env var. It is the default value of the
+        // SharedConfigState type.
+        SharedConfigStateFromEnv SharedConfigState = iota
+
+        // SharedConfigDisable overrides the AWS_SDK_LOAD_CONFIG env var value
+        // and disables the shared config functionality.
+        SharedConfigDisable
+
+        // SharedConfigEnable overrides the AWS_SDK_LOAD_CONFIG env var value
+        // and enables the shared config functionality.
+        SharedConfigEnable
+)
+
+// Options provides the means to control how a Session is created and what
+// configuration values will be loaded.
+//
+type Options struct {
+        // Provides config values for the SDK to use when creating service clients
+        // and making API requests to services. Any value set in with this field
+        // will override the associated value provided by the SDK defaults,
+        // environment or config files where relevant.
+        //
+        // If not set, configuration values from from SDK defaults, environment,
+        // config will be used.
+        Config aws.Config
+
+        // Overrides the config profile the Session should be created from. If not
+        // set the value of the environment variable will be loaded (AWS_PROFILE,
+        // or AWS_DEFAULT_PROFILE if the Shared Config is enabled).
+        //
+        // If not set and environment variables are not set the "default"
+        // (DefaultSharedConfigProfile) will be used as the profile to load the
+        // session config from.
+        Profile string
+
+        // Instructs how the Session will be created based on the AWS_SDK_LOAD_CONFIG
+        // environment variable. By default a Session will be created using the
+        // value provided by the AWS_SDK_LOAD_CONFIG environment variable.
+        //
+        // Setting this value to SharedConfigEnable or SharedConfigDisable
+        // will allow you to override the AWS_SDK_LOAD_CONFIG environment variable
+        // and enable or disable the shared config functionality.
+        SharedConfigState SharedConfigState
+
+        // When the SDK's shared config is configured to assume a role with MFA
+        // this option is required in order to provide the mechanism that will
+        // retrieve the MFA token. There is no default value for this field. If
+        // it is not set an error will be returned when creating the session.
+        //
+        // This token provider will be called when ever the assumed role's
+        // credentials need to be refreshed. Within the context of service clients
+        // all sharing the same session the SDK will ensure calls to the token
+        // provider are atomic. When sharing a token provider across multiple
+        // sessions additional synchronization logic is needed to ensure the
+        // token providers do not introduce race conditions. It is recommend to
+        // share the session where possible.
+        //
+        // stscreds.StdinTokenProvider is a basic implementation that will prompt
+        // from stdin for the MFA token code.
+        //
+        // This field is only used if the shared configuration is enabled, and
+        // the config enables assume role wit MFA via the mfa_serial field.
+        AssumeRoleTokenProvider func() (string, error)
+
+        // Reader for a custom Credentials Authority (CA) bundle in PEM format that
+        // the SDK will use instead of the default system's root CA bundle. Use this
+        // only if you want to replace the CA bundle the SDK uses for TLS requests.
+        //
+        // Enabling this option will attempt to merge the Transport into the SDK's HTTP
+        // client. If the client's Transport is not a http.Transport an error will be
+        // returned. If the Transport's TLS config is set this option will cause the SDK
+        // to overwrite the Transport's TLS config's  RootCAs value. If the CA
+        // bundle reader contains multiple certificates all of them will be loaded.
+        //
+        // The Session option CustomCABundle is also available when creating sessions
+        // to also enable this feature. CustomCABundle session option field has priority
+        // over the AWS_CA_BUNDLE environment variable, and will be used if both are set.
+        CustomCABundle io.Reader
+}
+
+// NewSessionWithOptions returns a new Session created from SDK defaults, config files,
+// environment, and user provided config files. This func uses the Options
+// values to configure how the Session is created.
+//
+// If the AWS_SDK_LOAD_CONFIG environment variable is set to a truthy value
+// the shared config file (~/.aws/config) will also be loaded in addition to
+// the shared credentials file (~/.aws/credentials). Values set in both the
+// shared config, and shared credentials will be taken from the shared
+// credentials file. Enabling the Shared Config will also allow the Session
+// to be built with retrieving credentials with AssumeRole set in the config.
+//
+//     // Equivalent to session.New
+//     sess := session.Must(session.NewSessionWithOptions(session.Options{}))
+//
+//     // Specify profile to load for the session's config
+//     sess := session.Must(session.NewSessionWithOptions(session.Options{
+//          Profile: "profile_name",
+//     }))
+//
+//     // Specify profile for config and region for requests
+//     sess := session.Must(session.NewSessionWithOptions(session.Options{
+//          Config: aws.Config{Region: aws.String("us-east-1")},
+//          Profile: "profile_name",
+//     }))
+//
+//     // Force enable Shared Config support
+//     sess := session.Must(session.NewSessionWithOptions(session.Options{
+//         SharedConfigState: session.SharedConfigEnable,
+//     }))
+func NewSessionWithOptions(opts Options) (*Session, error) {
+        var envCfg envConfig
+        if opts.SharedConfigState == SharedConfigEnable {
+                envCfg = loadSharedEnvConfig()
+        } else {
+                envCfg = loadEnvConfig()
+        }
+
+        if len(opts.Profile) > 0 {
+                envCfg.Profile = opts.Profile
+        }
+
+        switch opts.SharedConfigState {
+        case SharedConfigDisable:
+                envCfg.EnableSharedConfig = false
+        case SharedConfigEnable:
+                envCfg.EnableSharedConfig = true
+        }
+
+        // Only use AWS_CA_BUNDLE if session option is not provided.
+        if len(envCfg.CustomCABundle) != 0 && opts.CustomCABundle == nil {
+                f, err := os.Open(envCfg.CustomCABundle)
+                if err != nil {
+                        return nil, awserr.New("LoadCustomCABundleError",
+                                "failed to open custom CA bundle PEM file", err)
+                }
+                defer f.Close()
+                opts.CustomCABundle = f
+        }
+
+        return newSession(opts, envCfg, &opts.Config)
+}
+
+// Must is a helper function to ensure the Session is valid and there was no
+// error when calling a NewSession function.
+//
+// This helper is intended to be used in variable initialization to load the
+// Session and configuration at startup. Such as:
+//
+//     var sess = session.Must(session.NewSession())
+func Must(sess *Session, err error) *Session {
+        if err != nil {
+                panic(err)
+        }
+
+        return sess
+}
+
+func deprecatedNewSession(cfgs ...*aws.Config) *Session {
+        cfg := defaults.Config()
+        handlers := defaults.Handlers()
+
+        // Apply the passed in configs so the configuration can be applied to the
+        // default credential chain
+        cfg.MergeIn(cfgs...)
+        if cfg.EndpointResolver == nil {
+                // An endpoint resolver is required for a session to be able to provide
+                // endpoints for service client configurations.
+                cfg.EndpointResolver = endpoints.DefaultResolver()
+        }
+        cfg.Credentials = defaults.CredChain(cfg, handlers)
+
+        // Reapply any passed in configs to override credentials if set
+        cfg.MergeIn(cfgs...)
+
+        s := &Session{
+                Config:   cfg,
+                Handlers: handlers,
+        }
+
+        initHandlers(s)
+
+        return s
+}
+
+func newSession(opts Options, envCfg envConfig, cfgs ...*aws.Config) (*Session, error) {
+        cfg := defaults.Config()
+        handlers := defaults.Handlers()
+
+        // Get a merged version of the user provided config to determine if
+        // credentials were.
+        userCfg := &aws.Config{}
+        userCfg.MergeIn(cfgs...)
+
+        // Order config files will be loaded in with later files overwriting
+        // previous config file values.
+        cfgFiles := []string{envCfg.SharedConfigFile, envCfg.SharedCredentialsFile}
+        if !envCfg.EnableSharedConfig {
+                // The shared config file (~/.aws/config) is only loaded if instructed
+                // to load via the envConfig.EnableSharedConfig (AWS_SDK_LOAD_CONFIG).
+                cfgFiles = cfgFiles[1:]
+        }
+
+        // Load additional config from file(s)
+        sharedCfg, err := loadSharedConfig(envCfg.Profile, cfgFiles)
+        if err != nil {
+                return nil, err
+        }
+
+        if err := mergeConfigSrcs(cfg, userCfg, envCfg, sharedCfg, handlers, opts); err != nil {
+                return nil, err
+        }
+
+        s := &Session{
+                Config:   cfg,
+                Handlers: handlers,
+        }
+
+        initHandlers(s)
+
+        // Setup HTTP client with custom cert bundle if enabled
+        if opts.CustomCABundle != nil {
+                if err := loadCustomCABundle(s, opts.CustomCABundle); err != nil {
+                        return nil, err
+                }
+        }
+
+        return s, nil
+}
+
+func loadCustomCABundle(s *Session, bundle io.Reader) error {
+        var t *http.Transport
+        switch v := s.Config.HTTPClient.Transport.(type) {
+        case *http.Transport:
+                t = v
+        default:
+                if s.Config.HTTPClient.Transport != nil {
+                        return awserr.New("LoadCustomCABundleError",
+                                "unable to load custom CA bundle, HTTPClient's transport unsupported type", nil)
+                }
+        }
+        if t == nil {
+                t = &http.Transport{}
+        }
+
+        p, err := loadCertPool(bundle)
+        if err != nil {
+                return err
+        }
+        if t.TLSClientConfig == nil {
+                t.TLSClientConfig = &tls.Config{}
+        }
+        t.TLSClientConfig.RootCAs = p
+
+        s.Config.HTTPClient.Transport = t
+
+        return nil
+}
+
+func loadCertPool(r io.Reader) (*x509.CertPool, error) {
+        b, err := ioutil.ReadAll(r)
+        if err != nil {
+                return nil, awserr.New("LoadCustomCABundleError",
+                        "failed to read custom CA bundle PEM file", err)
+        }
+
+        p := x509.NewCertPool()
+        if !p.AppendCertsFromPEM(b) {
+                return nil, awserr.New("LoadCustomCABundleError",
+                        "failed to load custom CA bundle PEM file", err)
+        }
+
+        return p, nil
+}
+
+func mergeConfigSrcs(cfg, userCfg *aws.Config, envCfg envConfig, sharedCfg sharedConfig, handlers request.Handlers, sessOpts Options) error {
+        // Merge in user provided configuration
+        cfg.MergeIn(userCfg)
+
+        // Region if not already set by user
+        if len(aws.StringValue(cfg.Region)) == 0 {
+                if len(envCfg.Region) > 0 {
+                        cfg.WithRegion(envCfg.Region)
+                } else if envCfg.EnableSharedConfig && len(sharedCfg.Region) > 0 {
+                        cfg.WithRegion(sharedCfg.Region)
+                }
+        }
+
+        // Configure credentials if not already set
+        if cfg.Credentials == credentials.AnonymousCredentials && userCfg.Credentials == nil {
+                if len(envCfg.Creds.AccessKeyID) > 0 {
+                        cfg.Credentials = credentials.NewStaticCredentialsFromCreds(
+                                envCfg.Creds,
+                        )
+                } else if envCfg.EnableSharedConfig && len(sharedCfg.AssumeRole.RoleARN) > 0 && sharedCfg.AssumeRoleSource != nil {
+                        cfgCp := *cfg
+                        cfgCp.Credentials = credentials.NewStaticCredentialsFromCreds(
+                                sharedCfg.AssumeRoleSource.Creds,
+                        )
+                        if len(sharedCfg.AssumeRole.MFASerial) > 0 && sessOpts.AssumeRoleTokenProvider == nil {
+                                // AssumeRole Token provider is required if doing Assume Role
+                                // with MFA.
+                                return AssumeRoleTokenProviderNotSetError{}
+                        }
+                        cfg.Credentials = stscreds.NewCredentials(
+                                &Session{
+                                        Config:   &cfgCp,
+                                        Handlers: handlers.Copy(),
+                                },
+                                sharedCfg.AssumeRole.RoleARN,
+                                func(opt *stscreds.AssumeRoleProvider) {
+                                        opt.RoleSessionName = sharedCfg.AssumeRole.RoleSessionName
+
+                                        // Assume role with external ID
+                                        if len(sharedCfg.AssumeRole.ExternalID) > 0 {
+                                                opt.ExternalID = aws.String(sharedCfg.AssumeRole.ExternalID)
+                                        }
+
+                                        // Assume role with MFA
+                                        if len(sharedCfg.AssumeRole.MFASerial) > 0 {
+                                                opt.SerialNumber = aws.String(sharedCfg.AssumeRole.MFASerial)
+                                                opt.TokenProvider = sessOpts.AssumeRoleTokenProvider
+                                        }
+                                },
+                        )
+                } else if len(sharedCfg.Creds.AccessKeyID) > 0 {
+                        cfg.Credentials = credentials.NewStaticCredentialsFromCreds(
+                                sharedCfg.Creds,
+                        )
+                } else {
+                        // Fallback to default credentials provider, include mock errors
+                        // for the credential chain so user can identify why credentials
+                        // failed to be retrieved.
+                        cfg.Credentials = credentials.NewCredentials(&credentials.ChainProvider{
+                                VerboseErrors: aws.BoolValue(cfg.CredentialsChainVerboseErrors),
+                                Providers: []credentials.Provider{
+                                        &credProviderError{Err: awserr.New("EnvAccessKeyNotFound", "failed to find credentials in the environment.", nil)},
+                                        &credProviderError{Err: awserr.New("SharedCredsLoad", fmt.Sprintf("failed to load profile, %s.", envCfg.Profile), nil)},
+                                        defaults.RemoteCredProvider(*cfg, handlers),
+                                },
+                        })
+                }
+        }
+
+        return nil
+}
+
+// AssumeRoleTokenProviderNotSetError is an error returned when creating a session when the
+// MFAToken option is not set when shared config is configured load assume a
+// role with an MFA token.
+type AssumeRoleTokenProviderNotSetError struct{}
+
+// Code is the short id of the error.
+func (e AssumeRoleTokenProviderNotSetError) Code() string {
+        return "AssumeRoleTokenProviderNotSetError"
+}
+
+// Message is the description of the error
+func (e AssumeRoleTokenProviderNotSetError) Message() string {
+        return fmt.Sprintf("assume role with MFA enabled, but AssumeRoleTokenProvider session option not set.")
+}
+
+// OrigErr is the underlying error that caused the failure.
+func (e AssumeRoleTokenProviderNotSetError) OrigErr() error {
+        return nil
+}
+
+// Error satisfies the error interface.
+func (e AssumeRoleTokenProviderNotSetError) Error() string {
+        return awserr.SprintError(e.Code(), e.Message(), "", nil)
+}
+
+type credProviderError struct {
+        Err error
+}
+
+var emptyCreds = credentials.Value{}
+
+func (c credProviderError) Retrieve() (credentials.Value, error) {
+        return credentials.Value{}, c.Err
+}
+func (c credProviderError) IsExpired() bool {
+        return true
+}
+
+func initHandlers(s *Session) {
+        // Add the Validate parameter handler if it is not disabled.
+        s.Handlers.Validate.Remove(corehandlers.ValidateParametersHandler)
+        if !aws.BoolValue(s.Config.DisableParamValidation) {
+                s.Handlers.Validate.PushBackNamed(corehandlers.ValidateParametersHandler)
+        }
+}
+
+// Copy creates and returns a copy of the current Session, coping the config
+// and handlers. If any additional configs are provided they will be merged
+// on top of the Session's copied config.
+//
+//     // Create a copy of the current Session, configured for the us-west-2 region.
+//     sess.Copy(&aws.Config{Region: aws.String("us-west-2")})
+func (s *Session) Copy(cfgs ...*aws.Config) *Session {
+        newSession := &Session{
+                Config:   s.Config.Copy(cfgs...),
+                Handlers: s.Handlers.Copy(),
+        }
+
+        initHandlers(newSession)
+
+        return newSession
+}
+
+// ClientConfig satisfies the client.ConfigProvider interface and is used to
+// configure the service client instances. Passing the Session to the service
+// client's constructor (New) will use this method to configure the client.
+func (s *Session) ClientConfig(serviceName string, cfgs ...*aws.Config) client.Config {
+        // Backwards compatibility, the error will be eaten if user calls ClientConfig
+        // directly. All SDK services will use ClientconfigWithError.
+        cfg, _ := s.clientConfigWithErr(serviceName, cfgs...)
+
+        return cfg
+}
+
+func (s *Session) clientConfigWithErr(serviceName string, cfgs ...*aws.Config) (client.Config, error) {
+        s = s.Copy(cfgs...)
+
+        var resolved endpoints.ResolvedEndpoint
+        var err error
+
+        region := aws.StringValue(s.Config.Region)
+
+        if endpoint := aws.StringValue(s.Config.Endpoint); len(endpoint) != 0 {
+                resolved.URL = endpoints.AddScheme(endpoint, aws.BoolValue(s.Config.DisableSSL))
+                resolved.SigningRegion = region
+        } else {
+                resolved, err = s.Config.EndpointResolver.EndpointFor(
+                        serviceName, region,
+                        func(opt *endpoints.Options) {
+                                opt.DisableSSL = aws.BoolValue(s.Config.DisableSSL)
+                                opt.UseDualStack = aws.BoolValue(s.Config.UseDualStack)
+
+                                // Support the condition where the service is modeled but its
+                                // endpoint metadata is not available.
+                                opt.ResolveUnknownService = true
+                        },
+                )
+        }
+
+        return client.Config{
+                Config:        s.Config,
+                Handlers:      s.Handlers,
+                Endpoint:      resolved.URL,
+                SigningRegion: resolved.SigningRegion,
+                SigningName:   resolved.SigningName,
+        }, err
+}
+
+// ClientConfigNoResolveEndpoint is the same as ClientConfig with the exception
+// that the EndpointResolver will not be used to resolve the endpoint. The only
+// endpoint set must come from the aws.Config.Endpoint field.
+func (s *Session) ClientConfigNoResolveEndpoint(cfgs ...*aws.Config) client.Config {
+        s = s.Copy(cfgs...)
+
+        var resolved endpoints.ResolvedEndpoint
+
+        region := aws.StringValue(s.Config.Region)
+
+        if ep := aws.StringValue(s.Config.Endpoint); len(ep) > 0 {
+                resolved.URL = endpoints.AddScheme(ep, aws.BoolValue(s.Config.DisableSSL))
+                resolved.SigningRegion = region
+        }
+
+        return client.Config{
+                Config:        s.Config,
+                Handlers:      s.Handlers,
+                Endpoint:      resolved.URL,
+                SigningRegion: resolved.SigningRegion,
+                SigningName:   resolved.SigningName,
+        }
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/session/shared_config.go b/vendor/github.com/aws/aws-sdk-go/aws/session/shared_config.go
new file mode 100644
index 0000000..b58076f
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/session/shared_config.go
@@ -0,0 +1,295 @@
+package session
+
+import (
+        "fmt"
+        "io/ioutil"
+
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/credentials"
+        "github.com/go-ini/ini"
+)
+
+const (
+        // Static Credentials group
+        accessKeyIDKey  = `aws_access_key_id`     // group required
+        secretAccessKey = `aws_secret_access_key` // group required
+        sessionTokenKey = `aws_session_token`     // optional
+
+        // Assume Role Credentials group
+        roleArnKey         = `role_arn`          // group required
+        sourceProfileKey   = `source_profile`    // group required
+        externalIDKey      = `external_id`       // optional
+        mfaSerialKey       = `mfa_serial`        // optional
+        roleSessionNameKey = `role_session_name` // optional
+
+        // Additional Config fields
+        regionKey = `region`
+
+        // DefaultSharedConfigProfile is the default profile to be used when
+        // loading configuration from the config files if another profile name
+        // is not provided.
+        DefaultSharedConfigProfile = `default`
+)
+
+type assumeRoleConfig struct {
+        RoleARN         string
+        SourceProfile   string
+        ExternalID      string
+        MFASerial       string
+        RoleSessionName string
+}
+
+// sharedConfig represents the configuration fields of the SDK config files.
+type sharedConfig struct {
+        // Credentials values from the config file. Both aws_access_key_id
+        // and aws_secret_access_key must be provided together in the same file
+        // to be considered valid. The values will be ignored if not a complete group.
+        // aws_session_token is an optional field that can be provided if both of the
+        // other two fields are also provided.
+        //
+        //      aws_access_key_id
+        //      aws_secret_access_key
+        //      aws_session_token
+        Creds credentials.Value
+
+        AssumeRole       assumeRoleConfig
+        AssumeRoleSource *sharedConfig
+
+        // Region is the region the SDK should use for looking up AWS service endpoints
+        // and signing requests.
+        //
+        //      region
+        Region string
+}
+
+type sharedConfigFile struct {
+        Filename string
+        IniData  *ini.File
+}
+
+// loadSharedConfig retrieves the configuration from the list of files
+// using the profile provided. The order the files are listed will determine
+// precedence. Values in subsequent files will overwrite values defined in
+// earlier files.
+//
+// For example, given two files A and B. Both define credentials. If the order
+// of the files are A then B, B's credential values will be used instead of A's.
+//
+// See sharedConfig.setFromFile for information how the config files
+// will be loaded.
+func loadSharedConfig(profile string, filenames []string) (sharedConfig, error) {
+        if len(profile) == 0 {
+                profile = DefaultSharedConfigProfile
+        }
+
+        files, err := loadSharedConfigIniFiles(filenames)
+        if err != nil {
+                return sharedConfig{}, err
+        }
+
+        cfg := sharedConfig{}
+        if err = cfg.setFromIniFiles(profile, files); err != nil {
+                return sharedConfig{}, err
+        }
+
+        if len(cfg.AssumeRole.SourceProfile) > 0 {
+                if err := cfg.setAssumeRoleSource(profile, files); err != nil {
+                        return sharedConfig{}, err
+                }
+        }
+
+        return cfg, nil
+}
+
+func loadSharedConfigIniFiles(filenames []string) ([]sharedConfigFile, error) {
+        files := make([]sharedConfigFile, 0, len(filenames))
+
+        for _, filename := range filenames {
+                b, err := ioutil.ReadFile(filename)
+                if err != nil {
+                        // Skip files which can't be opened and read for whatever reason
+                        continue
+                }
+
+                f, err := ini.Load(b)
+                if err != nil {
+                        return nil, SharedConfigLoadError{Filename: filename}
+                }
+
+                files = append(files, sharedConfigFile{
+                        Filename: filename, IniData: f,
+                })
+        }
+
+        return files, nil
+}
+
+func (cfg *sharedConfig) setAssumeRoleSource(origProfile string, files []sharedConfigFile) error {
+        var assumeRoleSrc sharedConfig
+
+        // Multiple level assume role chains are not support
+        if cfg.AssumeRole.SourceProfile == origProfile {
+                assumeRoleSrc = *cfg
+                assumeRoleSrc.AssumeRole = assumeRoleConfig{}
+        } else {
+                err := assumeRoleSrc.setFromIniFiles(cfg.AssumeRole.SourceProfile, files)
+                if err != nil {
+                        return err
+                }
+        }
+
+        if len(assumeRoleSrc.Creds.AccessKeyID) == 0 {
+                return SharedConfigAssumeRoleError{RoleARN: cfg.AssumeRole.RoleARN}
+        }
+
+        cfg.AssumeRoleSource = &assumeRoleSrc
+
+        return nil
+}
+
+func (cfg *sharedConfig) setFromIniFiles(profile string, files []sharedConfigFile) error {
+        // Trim files from the list that don't exist.
+        for _, f := range files {
+                if err := cfg.setFromIniFile(profile, f); err != nil {
+                        if _, ok := err.(SharedConfigProfileNotExistsError); ok {
+                                // Ignore proviles missings
+                                continue
+                        }
+                        return err
+                }
+        }
+
+        return nil
+}
+
+// setFromFile loads the configuration from the file using
+// the profile provided. A sharedConfig pointer type value is used so that
+// multiple config file loadings can be chained.
+//
+// Only loads complete logically grouped values, and will not set fields in cfg
+// for incomplete grouped values in the config. Such as credentials. For example
+// if a config file only includes aws_access_key_id but no aws_secret_access_key
+// the aws_access_key_id will be ignored.
+func (cfg *sharedConfig) setFromIniFile(profile string, file sharedConfigFile) error {
+        section, err := file.IniData.GetSection(profile)
+        if err != nil {
+                // Fallback to to alternate profile name: profile <name>
+                section, err = file.IniData.GetSection(fmt.Sprintf("profile %s", profile))
+                if err != nil {
+                        return SharedConfigProfileNotExistsError{Profile: profile, Err: err}
+                }
+        }
+
+        // Shared Credentials
+        akid := section.Key(accessKeyIDKey).String()
+        secret := section.Key(secretAccessKey).String()
+        if len(akid) > 0 && len(secret) > 0 {
+                cfg.Creds = credentials.Value{
+                        AccessKeyID:     akid,
+                        SecretAccessKey: secret,
+                        SessionToken:    section.Key(sessionTokenKey).String(),
+                        ProviderName:    fmt.Sprintf("SharedConfigCredentials: %s", file.Filename),
+                }
+        }
+
+        // Assume Role
+        roleArn := section.Key(roleArnKey).String()
+        srcProfile := section.Key(sourceProfileKey).String()
+        if len(roleArn) > 0 && len(srcProfile) > 0 {
+                cfg.AssumeRole = assumeRoleConfig{
+                        RoleARN:         roleArn,
+                        SourceProfile:   srcProfile,
+                        ExternalID:      section.Key(externalIDKey).String(),
+                        MFASerial:       section.Key(mfaSerialKey).String(),
+                        RoleSessionName: section.Key(roleSessionNameKey).String(),
+                }
+        }
+
+        // Region
+        if v := section.Key(regionKey).String(); len(v) > 0 {
+                cfg.Region = v
+        }
+
+        return nil
+}
+
+// SharedConfigLoadError is an error for the shared config file failed to load.
+type SharedConfigLoadError struct {
+        Filename string
+        Err      error
+}
+
+// Code is the short id of the error.
+func (e SharedConfigLoadError) Code() string {
+        return "SharedConfigLoadError"
+}
+
+// Message is the description of the error
+func (e SharedConfigLoadError) Message() string {
+        return fmt.Sprintf("failed to load config file, %s", e.Filename)
+}
+
+// OrigErr is the underlying error that caused the failure.
+func (e SharedConfigLoadError) OrigErr() error {
+        return e.Err
+}
+
+// Error satisfies the error interface.
+func (e SharedConfigLoadError) Error() string {
+        return awserr.SprintError(e.Code(), e.Message(), "", e.Err)
+}
+
+// SharedConfigProfileNotExistsError is an error for the shared config when
+// the profile was not find in the config file.
+type SharedConfigProfileNotExistsError struct {
+        Profile string
+        Err     error
+}
+
+// Code is the short id of the error.
+func (e SharedConfigProfileNotExistsError) Code() string {
+        return "SharedConfigProfileNotExistsError"
+}
+
+// Message is the description of the error
+func (e SharedConfigProfileNotExistsError) Message() string {
+        return fmt.Sprintf("failed to get profile, %s", e.Profile)
+}
+
+// OrigErr is the underlying error that caused the failure.
+func (e SharedConfigProfileNotExistsError) OrigErr() error {
+        return e.Err
+}
+
+// Error satisfies the error interface.
+func (e SharedConfigProfileNotExistsError) Error() string {
+        return awserr.SprintError(e.Code(), e.Message(), "", e.Err)
+}
+
+// SharedConfigAssumeRoleError is an error for the shared config when the
+// profile contains assume role information, but that information is invalid
+// or not complete.
+type SharedConfigAssumeRoleError struct {
+        RoleARN string
+}
+
+// Code is the short id of the error.
+func (e SharedConfigAssumeRoleError) Code() string {
+        return "SharedConfigAssumeRoleError"
+}
+
+// Message is the description of the error
+func (e SharedConfigAssumeRoleError) Message() string {
+        return fmt.Sprintf("failed to load assume role for %s, source profile has no shared credentials",
+                e.RoleARN)
+}
+
+// OrigErr is the underlying error that caused the failure.
+func (e SharedConfigAssumeRoleError) OrigErr() error {
+        return nil
+}
+
+// Error satisfies the error interface.
+func (e SharedConfigAssumeRoleError) Error() string {
+        return awserr.SprintError(e.Code(), e.Message(), "", nil)
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/header_rules.go b/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/header_rules.go
new file mode 100644
index 0000000..244c86d
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/header_rules.go
@@ -0,0 +1,82 @@
+package v4
+
+import (
+        "net/http"
+        "strings"
+)
+
+// validator houses a set of rule needed for validation of a
+// string value
+type rules []rule
+
+// rule interface allows for more flexible rules and just simply
+// checks whether or not a value adheres to that rule
+type rule interface {
+        IsValid(value string) bool
+}
+
+// IsValid will iterate through all rules and see if any rules
+// apply to the value and supports nested rules
+func (r rules) IsValid(value string) bool {
+        for _, rule := range r {
+                if rule.IsValid(value) {
+                        return true
+                }
+        }
+        return false
+}
+
+// mapRule generic rule for maps
+type mapRule map[string]struct{}
+
+// IsValid for the map rule satisfies whether it exists in the map
+func (m mapRule) IsValid(value string) bool {
+        _, ok := m[value]
+        return ok
+}
+
+// whitelist is a generic rule for whitelisting
+type whitelist struct {
+        rule
+}
+
+// IsValid for whitelist checks if the value is within the whitelist
+func (w whitelist) IsValid(value string) bool {
+        return w.rule.IsValid(value)
+}
+
+// blacklist is a generic rule for blacklisting
+type blacklist struct {
+        rule
+}
+
+// IsValid for whitelist checks if the value is within the whitelist
+func (b blacklist) IsValid(value string) bool {
+        return !b.rule.IsValid(value)
+}
+
+type patterns []string
+
+// IsValid for patterns checks each pattern and returns if a match has
+// been found
+func (p patterns) IsValid(value string) bool {
+        for _, pattern := range p {
+                if strings.HasPrefix(http.CanonicalHeaderKey(value), pattern) {
+                        return true
+                }
+        }
+        return false
+}
+
+// inclusiveRules rules allow for rules to depend on one another
+type inclusiveRules []rule
+
+// IsValid will return true if all rules are true
+func (r inclusiveRules) IsValid(value string) bool {
+        for _, rule := range r {
+                if !rule.IsValid(value) {
+                        return false
+                }
+        }
+        return true
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/options.go b/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/options.go
new file mode 100644
index 0000000..6aa2ed2
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/options.go
@@ -0,0 +1,7 @@
+package v4
+
+// WithUnsignedPayload will enable and set the UnsignedPayload field to
+// true of the signer.
+func WithUnsignedPayload(v4 *Signer) {
+        v4.UnsignedPayload = true
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/uri_path.go b/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/uri_path.go
new file mode 100644
index 0000000..bd082e9
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/uri_path.go
@@ -0,0 +1,24 @@
+// +build go1.5
+
+package v4
+
+import (
+        "net/url"
+        "strings"
+)
+
+func getURIPath(u *url.URL) string {
+        var uri string
+
+        if len(u.Opaque) > 0 {
+                uri = "/" + strings.Join(strings.Split(u.Opaque, "/")[3:], "/")
+        } else {
+                uri = u.EscapedPath()
+        }
+
+        if len(uri) == 0 {
+                uri = "/"
+        }
+
+        return uri
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/v4.go b/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/v4.go
new file mode 100644
index 0000000..434ac87
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/v4.go
@@ -0,0 +1,761 @@
+// Package v4 implements signing for AWS V4 signer
+//
+// Provides request signing for request that need to be signed with
+// AWS V4 Signatures.
+//
+// Standalone Signer
+//
+// Generally using the signer outside of the SDK should not require any additional
+// logic when using Go v1.5 or higher. The signer does this by taking advantage
+// of the URL.EscapedPath method. If your request URI requires additional escaping
+// you many need to use the URL.Opaque to define what the raw URI should be sent
+// to the service as.
+//
+// The signer will first check the URL.Opaque field, and use its value if set.
+// The signer does require the URL.Opaque field to be set in the form of:
+//
+//     "//<hostname>/<path>"
+//
+//     // e.g.
+//     "//example.com/some/path"
+//
+// The leading "//" and hostname are required or the URL.Opaque escaping will
+// not work correctly.
+//
+// If URL.Opaque is not set the signer will fallback to the URL.EscapedPath()
+// method and using the returned value. If you're using Go v1.4 you must set
+// URL.Opaque if the URI path needs escaping. If URL.Opaque is not set with
+// Go v1.5 the signer will fallback to URL.Path.
+//
+// AWS v4 signature validation requires that the canonical string's URI path
+// element must be the URI escaped form of the HTTP request's path.
+// http://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html
+//
+// The Go HTTP client will perform escaping automatically on the request. Some
+// of these escaping may cause signature validation errors because the HTTP
+// request differs from the URI path or query that the signature was generated.
+// https://golang.org/pkg/net/url/#URL.EscapedPath
+//
+// Because of this, it is recommended that when using the signer outside of the
+// SDK that explicitly escaping the request prior to being signed is preferable,
+// and will help prevent signature validation errors. This can be done by setting
+// the URL.Opaque or URL.RawPath. The SDK will use URL.Opaque first and then
+// call URL.EscapedPath() if Opaque is not set.
+//
+// If signing a request intended for HTTP2 server, and you're using Go 1.6.2
+// through 1.7.4 you should use the URL.RawPath as the pre-escaped form of the
+// request URL. https://github.com/golang/go/issues/16847 points to a bug in
+// Go pre 1.8 that failes to make HTTP2 requests using absolute URL in the HTTP
+// message. URL.Opaque generally will force Go to make requests with absolute URL.
+// URL.RawPath does not do this, but RawPath must be a valid escaping of Path
+// or url.EscapedPath will ignore the RawPath escaping.
+//
+// Test `TestStandaloneSign` provides a complete example of using the signer
+// outside of the SDK and pre-escaping the URI path.
+package v4
+
+import (
+        "bytes"
+        "crypto/hmac"
+        "crypto/sha256"
+        "encoding/hex"
+        "fmt"
+        "io"
+        "io/ioutil"
+        "net/http"
+        "net/url"
+        "sort"
+        "strconv"
+        "strings"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/credentials"
+        "github.com/aws/aws-sdk-go/aws/request"
+        "github.com/aws/aws-sdk-go/private/protocol/rest"
+)
+
+const (
+        authHeaderPrefix = "AWS4-HMAC-SHA256"
+        timeFormat       = "20060102T150405Z"
+        shortTimeFormat  = "20060102"
+
+        // emptyStringSHA256 is a SHA256 of an empty string
+        emptyStringSHA256 = `e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855`
+)
+
+var ignoredHeaders = rules{
+        blacklist{
+                mapRule{
+                        "Authorization":   struct{}{},
+                        "User-Agent":      struct{}{},
+                        "X-Amzn-Trace-Id": struct{}{},
+                },
+        },
+}
+
+// requiredSignedHeaders is a whitelist for build canonical headers.
+var requiredSignedHeaders = rules{
+        whitelist{
+                mapRule{
+                        "Cache-Control":                                               struct{}{},
+                        "Content-Disposition":                                         struct{}{},
+                        "Content-Encoding":                                            struct{}{},
+                        "Content-Language":                                            struct{}{},
+                        "Content-Md5":                                                 struct{}{},
+                        "Content-Type":                                                struct{}{},
+                        "Expires":                                                     struct{}{},
+                        "If-Match":                                                    struct{}{},
+                        "If-Modified-Since":                                           struct{}{},
+                        "If-None-Match":                                               struct{}{},
+                        "If-Unmodified-Since":                                         struct{}{},
+                        "Range":                                                       struct{}{},
+                        "X-Amz-Acl":                                                   struct{}{},
+                        "X-Amz-Copy-Source":                                           struct{}{},
+                        "X-Amz-Copy-Source-If-Match":                                  struct{}{},
+                        "X-Amz-Copy-Source-If-Modified-Since":                         struct{}{},
+                        "X-Amz-Copy-Source-If-None-Match":                             struct{}{},
+                        "X-Amz-Copy-Source-If-Unmodified-Since":                       struct{}{},
+                        "X-Amz-Copy-Source-Range":                                     struct{}{},
+                        "X-Amz-Copy-Source-Server-Side-Encryption-Customer-Algorithm": struct{}{},
+                        "X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key":       struct{}{},
+                        "X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key-Md5":   struct{}{},
+                        "X-Amz-Grant-Full-control":                                    struct{}{},
+                        "X-Amz-Grant-Read":                                            struct{}{},
+                        "X-Amz-Grant-Read-Acp":                                        struct{}{},
+                        "X-Amz-Grant-Write":                                           struct{}{},
+                        "X-Amz-Grant-Write-Acp":                                       struct{}{},
+                        "X-Amz-Metadata-Directive":                                    struct{}{},
+                        "X-Amz-Mfa":                                                   struct{}{},
+                        "X-Amz-Request-Payer":                                         struct{}{},
+                        "X-Amz-Server-Side-Encryption":                                struct{}{},
+                        "X-Amz-Server-Side-Encryption-Aws-Kms-Key-Id":                 struct{}{},
+                        "X-Amz-Server-Side-Encryption-Customer-Algorithm":             struct{}{},
+                        "X-Amz-Server-Side-Encryption-Customer-Key":                   struct{}{},
+                        "X-Amz-Server-Side-Encryption-Customer-Key-Md5":               struct{}{},
+                        "X-Amz-Storage-Class":                                         struct{}{},
+                        "X-Amz-Website-Redirect-Location":                             struct{}{},
+                },
+        },
+        patterns{"X-Amz-Meta-"},
+}
+
+// allowedHoisting is a whitelist for build query headers. The boolean value
+// represents whether or not it is a pattern.
+var allowedQueryHoisting = inclusiveRules{
+        blacklist{requiredSignedHeaders},
+        patterns{"X-Amz-"},
+}
+
+// Signer applies AWS v4 signing to given request. Use this to sign requests
+// that need to be signed with AWS V4 Signatures.
+type Signer struct {
+        // The authentication credentials the request will be signed against.
+        // This value must be set to sign requests.
+        Credentials *credentials.Credentials
+
+        // Sets the log level the signer should use when reporting information to
+        // the logger. If the logger is nil nothing will be logged. See
+        // aws.LogLevelType for more information on available logging levels
+        //
+        // By default nothing will be logged.
+        Debug aws.LogLevelType
+
+        // The logger loging information will be written to. If there the logger
+        // is nil, nothing will be logged.
+        Logger aws.Logger
+
+        // Disables the Signer's moving HTTP header key/value pairs from the HTTP
+        // request header to the request's query string. This is most commonly used
+        // with pre-signed requests preventing headers from being added to the
+        // request's query string.
+        DisableHeaderHoisting bool
+
+        // Disables the automatic escaping of the URI path of the request for the
+        // siganture's canonical string's path. For services that do not need additional
+        // escaping then use this to disable the signer escaping the path.
+        //
+        // S3 is an example of a service that does not need additional escaping.
+        //
+        // http://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html
+        DisableURIPathEscaping bool
+
+        // Disales the automatical setting of the HTTP request's Body field with the
+        // io.ReadSeeker passed in to the signer. This is useful if you're using a
+        // custom wrapper around the body for the io.ReadSeeker and want to preserve
+        // the Body value on the Request.Body.
+        //
+        // This does run the risk of signing a request with a body that will not be
+        // sent in the request. Need to ensure that the underlying data of the Body
+        // values are the same.
+        DisableRequestBodyOverwrite bool
+
+        // currentTimeFn returns the time value which represents the current time.
+        // This value should only be used for testing. If it is nil the default
+        // time.Now will be used.
+        currentTimeFn func() time.Time
+
+        // UnsignedPayload will prevent signing of the payload. This will only
+        // work for services that have support for this.
+        UnsignedPayload bool
+}
+
+// NewSigner returns a Signer pointer configured with the credentials and optional
+// option values provided. If not options are provided the Signer will use its
+// default configuration.
+func NewSigner(credentials *credentials.Credentials, options ...func(*Signer)) *Signer {
+        v4 := &Signer{
+                Credentials: credentials,
+        }
+
+        for _, option := range options {
+                option(v4)
+        }
+
+        return v4
+}
+
+type signingCtx struct {
+        ServiceName      string
+        Region           string
+        Request          *http.Request
+        Body             io.ReadSeeker
+        Query            url.Values
+        Time             time.Time
+        ExpireTime       time.Duration
+        SignedHeaderVals http.Header
+
+        DisableURIPathEscaping bool
+
+        credValues         credentials.Value
+        isPresign          bool
+        formattedTime      string
+        formattedShortTime string
+        unsignedPayload    bool
+
+        bodyDigest       string
+        signedHeaders    string
+        canonicalHeaders string
+        canonicalString  string
+        credentialString string
+        stringToSign     string
+        signature        string
+        authorization    string
+}
+
+// Sign signs AWS v4 requests with the provided body, service name, region the
+// request is made to, and time the request is signed at. The signTime allows
+// you to specify that a request is signed for the future, and cannot be
+// used until then.
+//
+// Returns a list of HTTP headers that were included in the signature or an
+// error if signing the request failed. Generally for signed requests this value
+// is not needed as the full request context will be captured by the http.Request
+// value. It is included for reference though.
+//
+// Sign will set the request's Body to be the `body` parameter passed in. If
+// the body is not already an io.ReadCloser, it will be wrapped within one. If
+// a `nil` body parameter passed to Sign, the request's Body field will be
+// also set to nil. Its important to note that this functionality will not
+// change the request's ContentLength of the request.
+//
+// Sign differs from Presign in that it will sign the request using HTTP
+// header values. This type of signing is intended for http.Request values that
+// will not be shared, or are shared in a way the header values on the request
+// will not be lost.
+//
+// The requests body is an io.ReadSeeker so the SHA256 of the body can be
+// generated. To bypass the signer computing the hash you can set the
+// "X-Amz-Content-Sha256" header with a precomputed value. The signer will
+// only compute the hash if the request header value is empty.
+func (v4 Signer) Sign(r *http.Request, body io.ReadSeeker, service, region string, signTime time.Time) (http.Header, error) {
+        return v4.signWithBody(r, body, service, region, 0, signTime)
+}
+
+// Presign signs AWS v4 requests with the provided body, service name, region
+// the request is made to, and time the request is signed at. The signTime
+// allows you to specify that a request is signed for the future, and cannot
+// be used until then.
+//
+// Returns a list of HTTP headers that were included in the signature or an
+// error if signing the request failed. For presigned requests these headers
+// and their values must be included on the HTTP request when it is made. This
+// is helpful to know what header values need to be shared with the party the
+// presigned request will be distributed to.
+//
+// Presign differs from Sign in that it will sign the request using query string
+// instead of header values. This allows you to share the Presigned Request's
+// URL with third parties, or distribute it throughout your system with minimal
+// dependencies.
+//
+// Presign also takes an exp value which is the duration the
+// signed request will be valid after the signing time. This is allows you to
+// set when the request will expire.
+//
+// The requests body is an io.ReadSeeker so the SHA256 of the body can be
+// generated. To bypass the signer computing the hash you can set the
+// "X-Amz-Content-Sha256" header with a precomputed value. The signer will
+// only compute the hash if the request header value is empty.
+//
+// Presigning a S3 request will not compute the body's SHA256 hash by default.
+// This is done due to the general use case for S3 presigned URLs is to share
+// PUT/GET capabilities. If you would like to include the body's SHA256 in the
+// presigned request's signature you can set the "X-Amz-Content-Sha256"
+// HTTP header and that will be included in the request's signature.
+func (v4 Signer) Presign(r *http.Request, body io.ReadSeeker, service, region string, exp time.Duration, signTime time.Time) (http.Header, error) {
+        return v4.signWithBody(r, body, service, region, exp, signTime)
+}
+
+func (v4 Signer) signWithBody(r *http.Request, body io.ReadSeeker, service, region string, exp time.Duration, signTime time.Time) (http.Header, error) {
+        currentTimeFn := v4.currentTimeFn
+        if currentTimeFn == nil {
+                currentTimeFn = time.Now
+        }
+
+        ctx := &signingCtx{
+                Request:                r,
+                Body:                   body,
+                Query:                  r.URL.Query(),
+                Time:                   signTime,
+                ExpireTime:             exp,
+                isPresign:              exp != 0,
+                ServiceName:            service,
+                Region:                 region,
+                DisableURIPathEscaping: v4.DisableURIPathEscaping,
+                unsignedPayload:        v4.UnsignedPayload,
+        }
+
+        for key := range ctx.Query {
+                sort.Strings(ctx.Query[key])
+        }
+
+        if ctx.isRequestSigned() {
+                ctx.Time = currentTimeFn()
+                ctx.handlePresignRemoval()
+        }
+
+        var err error
+        ctx.credValues, err = v4.Credentials.Get()
+        if err != nil {
+                return http.Header{}, err
+        }
+
+        ctx.assignAmzQueryValues()
+        ctx.build(v4.DisableHeaderHoisting)
+
+        // If the request is not presigned the body should be attached to it. This
+        // prevents the confusion of wanting to send a signed request without
+        // the body the request was signed for attached.
+        if !(v4.DisableRequestBodyOverwrite || ctx.isPresign) {
+                var reader io.ReadCloser
+                if body != nil {
+                        var ok bool
+                        if reader, ok = body.(io.ReadCloser); !ok {
+                                reader = ioutil.NopCloser(body)
+                        }
+                }
+                r.Body = reader
+        }
+
+        if v4.Debug.Matches(aws.LogDebugWithSigning) {
+                v4.logSigningInfo(ctx)
+        }
+
+        return ctx.SignedHeaderVals, nil
+}
+
+func (ctx *signingCtx) handlePresignRemoval() {
+        if !ctx.isPresign {
+                return
+        }
+
+        // The credentials have expired for this request. The current signing
+        // is invalid, and needs to be request because the request will fail.
+        ctx.removePresign()
+
+        // Update the request's query string to ensure the values stays in
+        // sync in the case retrieving the new credentials fails.
+        ctx.Request.URL.RawQuery = ctx.Query.Encode()
+}
+
+func (ctx *signingCtx) assignAmzQueryValues() {
+        if ctx.isPresign {
+                ctx.Query.Set("X-Amz-Algorithm", authHeaderPrefix)
+                if ctx.credValues.SessionToken != "" {
+                        ctx.Query.Set("X-Amz-Security-Token", ctx.credValues.SessionToken)
+                } else {
+                        ctx.Query.Del("X-Amz-Security-Token")
+                }
+
+                return
+        }
+
+        if ctx.credValues.SessionToken != "" {
+                ctx.Request.Header.Set("X-Amz-Security-Token", ctx.credValues.SessionToken)
+        }
+}
+
+// SignRequestHandler is a named request handler the SDK will use to sign
+// service client request with using the V4 signature.
+var SignRequestHandler = request.NamedHandler{
+        Name: "v4.SignRequestHandler", Fn: SignSDKRequest,
+}
+
+// SignSDKRequest signs an AWS request with the V4 signature. This
+// request handler is bested used only with the SDK's built in service client's
+// API operation requests.
+//
+// This function should not be used on its on its own, but in conjunction with
+// an AWS service client's API operation call. To sign a standalone request
+// not created by a service client's API operation method use the "Sign" or
+// "Presign" functions of the "Signer" type.
+//
+// If the credentials of the request's config are set to
+// credentials.AnonymousCredentials the request will not be signed.
+func SignSDKRequest(req *request.Request) {
+        signSDKRequestWithCurrTime(req, time.Now)
+}
+
+// BuildNamedHandler will build a generic handler for signing.
+func BuildNamedHandler(name string, opts ...func(*Signer)) request.NamedHandler {
+        return request.NamedHandler{
+                Name: name,
+                Fn: func(req *request.Request) {
+                        signSDKRequestWithCurrTime(req, time.Now, opts...)
+                },
+        }
+}
+
+func signSDKRequestWithCurrTime(req *request.Request, curTimeFn func() time.Time, opts ...func(*Signer)) {
+        // If the request does not need to be signed ignore the signing of the
+        // request if the AnonymousCredentials object is used.
+        if req.Config.Credentials == credentials.AnonymousCredentials {
+                return
+        }
+
+        region := req.ClientInfo.SigningRegion
+        if region == "" {
+                region = aws.StringValue(req.Config.Region)
+        }
+
+        name := req.ClientInfo.SigningName
+        if name == "" {
+                name = req.ClientInfo.ServiceName
+        }
+
+        v4 := NewSigner(req.Config.Credentials, func(v4 *Signer) {
+                v4.Debug = req.Config.LogLevel.Value()
+                v4.Logger = req.Config.Logger
+                v4.DisableHeaderHoisting = req.NotHoist
+                v4.currentTimeFn = curTimeFn
+                if name == "s3" {
+                        // S3 service should not have any escaping applied
+                        v4.DisableURIPathEscaping = true
+                }
+                // Prevents setting the HTTPRequest's Body. Since the Body could be
+                // wrapped in a custom io.Closer that we do not want to be stompped
+                // on top of by the signer.
+                v4.DisableRequestBodyOverwrite = true
+        })
+
+        for _, opt := range opts {
+                opt(v4)
+        }
+
+        signingTime := req.Time
+        if !req.LastSignedAt.IsZero() {
+                signingTime = req.LastSignedAt
+        }
+
+        signedHeaders, err := v4.signWithBody(req.HTTPRequest, req.GetBody(),
+                name, region, req.ExpireTime, signingTime,
+        )
+        if err != nil {
+                req.Error = err
+                req.SignedHeaderVals = nil
+                return
+        }
+
+        req.SignedHeaderVals = signedHeaders
+        req.LastSignedAt = curTimeFn()
+}
+
+const logSignInfoMsg = `DEBUG: Request Signature:
+---[ CANONICAL STRING  ]-----------------------------
+%s
+---[ STRING TO SIGN ]--------------------------------
+%s%s
+-----------------------------------------------------`
+const logSignedURLMsg = `
+---[ SIGNED URL ]------------------------------------
+%s`
+
+func (v4 *Signer) logSigningInfo(ctx *signingCtx) {
+        signedURLMsg := ""
+        if ctx.isPresign {
+                signedURLMsg = fmt.Sprintf(logSignedURLMsg, ctx.Request.URL.String())
+        }
+        msg := fmt.Sprintf(logSignInfoMsg, ctx.canonicalString, ctx.stringToSign, signedURLMsg)
+        v4.Logger.Log(msg)
+}
+
+func (ctx *signingCtx) build(disableHeaderHoisting bool) {
+        ctx.buildTime()             // no depends
+        ctx.buildCredentialString() // no depends
+
+        unsignedHeaders := ctx.Request.Header
+        if ctx.isPresign {
+                if !disableHeaderHoisting {
+                        urlValues := url.Values{}
+                        urlValues, unsignedHeaders = buildQuery(allowedQueryHoisting, unsignedHeaders) // no depends
+                        for k := range urlValues {
+                                ctx.Query[k] = urlValues[k]
+                        }
+                }
+        }
+
+        ctx.buildBodyDigest()
+        ctx.buildCanonicalHeaders(ignoredHeaders, unsignedHeaders)
+        ctx.buildCanonicalString() // depends on canon headers / signed headers
+        ctx.buildStringToSign()    // depends on canon string
+        ctx.buildSignature()       // depends on string to sign
+
+        if ctx.isPresign {
+                ctx.Request.URL.RawQuery += "&X-Amz-Signature=" + ctx.signature
+        } else {
+                parts := []string{
+                        authHeaderPrefix + " Credential=" + ctx.credValues.AccessKeyID + "/" + ctx.credentialString,
+                        "SignedHeaders=" + ctx.signedHeaders,
+                        "Signature=" + ctx.signature,
+                }
+                ctx.Request.Header.Set("Authorization", strings.Join(parts, ", "))
+        }
+}
+
+func (ctx *signingCtx) buildTime() {
+        ctx.formattedTime = ctx.Time.UTC().Format(timeFormat)
+        ctx.formattedShortTime = ctx.Time.UTC().Format(shortTimeFormat)
+
+        if ctx.isPresign {
+                duration := int64(ctx.ExpireTime / time.Second)
+                ctx.Query.Set("X-Amz-Date", ctx.formattedTime)
+                ctx.Query.Set("X-Amz-Expires", strconv.FormatInt(duration, 10))
+        } else {
+                ctx.Request.Header.Set("X-Amz-Date", ctx.formattedTime)
+        }
+}
+
+func (ctx *signingCtx) buildCredentialString() {
+        ctx.credentialString = strings.Join([]string{
+                ctx.formattedShortTime,
+                ctx.Region,
+                ctx.ServiceName,
+                "aws4_request",
+        }, "/")
+
+        if ctx.isPresign {
+                ctx.Query.Set("X-Amz-Credential", ctx.credValues.AccessKeyID+"/"+ctx.credentialString)
+        }
+}
+
+func buildQuery(r rule, header http.Header) (url.Values, http.Header) {
+        query := url.Values{}
+        unsignedHeaders := http.Header{}
+        for k, h := range header {
+                if r.IsValid(k) {
+                        query[k] = h
+                } else {
+                        unsignedHeaders[k] = h
+                }
+        }
+
+        return query, unsignedHeaders
+}
+func (ctx *signingCtx) buildCanonicalHeaders(r rule, header http.Header) {
+        var headers []string
+        headers = append(headers, "host")
+        for k, v := range header {
+                canonicalKey := http.CanonicalHeaderKey(k)
+                if !r.IsValid(canonicalKey) {
+                        continue // ignored header
+                }
+                if ctx.SignedHeaderVals == nil {
+                        ctx.SignedHeaderVals = make(http.Header)
+                }
+
+                lowerCaseKey := strings.ToLower(k)
+                if _, ok := ctx.SignedHeaderVals[lowerCaseKey]; ok {
+                        // include additional values
+                        ctx.SignedHeaderVals[lowerCaseKey] = append(ctx.SignedHeaderVals[lowerCaseKey], v...)
+                        continue
+                }
+
+                headers = append(headers, lowerCaseKey)
+                ctx.SignedHeaderVals[lowerCaseKey] = v
+        }
+        sort.Strings(headers)
+
+        ctx.signedHeaders = strings.Join(headers, ";")
+
+        if ctx.isPresign {
+                ctx.Query.Set("X-Amz-SignedHeaders", ctx.signedHeaders)
+        }
+
+        headerValues := make([]string, len(headers))
+        for i, k := range headers {
+                if k == "host" {
+                        headerValues[i] = "host:" + ctx.Request.URL.Host
+                } else {
+                        headerValues[i] = k + ":" +
+                                strings.Join(ctx.SignedHeaderVals[k], ",")
+                }
+        }
+
+        ctx.canonicalHeaders = strings.Join(stripExcessSpaces(headerValues), "\n")
+}
+
+func (ctx *signingCtx) buildCanonicalString() {
+        ctx.Request.URL.RawQuery = strings.Replace(ctx.Query.Encode(), "+", "%20", -1)
+
+        uri := getURIPath(ctx.Request.URL)
+
+        if !ctx.DisableURIPathEscaping {
+                uri = rest.EscapePath(uri, false)
+        }
+
+        ctx.canonicalString = strings.Join([]string{
+                ctx.Request.Method,
+                uri,
+                ctx.Request.URL.RawQuery,
+                ctx.canonicalHeaders + "\n",
+                ctx.signedHeaders,
+                ctx.bodyDigest,
+        }, "\n")
+}
+
+func (ctx *signingCtx) buildStringToSign() {
+        ctx.stringToSign = strings.Join([]string{
+                authHeaderPrefix,
+                ctx.formattedTime,
+                ctx.credentialString,
+                hex.EncodeToString(makeSha256([]byte(ctx.canonicalString))),
+        }, "\n")
+}
+
+func (ctx *signingCtx) buildSignature() {
+        secret := ctx.credValues.SecretAccessKey
+        date := makeHmac([]byte("AWS4"+secret), []byte(ctx.formattedShortTime))
+        region := makeHmac(date, []byte(ctx.Region))
+        service := makeHmac(region, []byte(ctx.ServiceName))
+        credentials := makeHmac(service, []byte("aws4_request"))
+        signature := makeHmac(credentials, []byte(ctx.stringToSign))
+        ctx.signature = hex.EncodeToString(signature)
+}
+
+func (ctx *signingCtx) buildBodyDigest() {
+        hash := ctx.Request.Header.Get("X-Amz-Content-Sha256")
+        if hash == "" {
+                if ctx.unsignedPayload || (ctx.isPresign && ctx.ServiceName == "s3") {
+                        hash = "UNSIGNED-PAYLOAD"
+                } else if ctx.Body == nil {
+                        hash = emptyStringSHA256
+                } else {
+                        hash = hex.EncodeToString(makeSha256Reader(ctx.Body))
+                }
+                if ctx.unsignedPayload || ctx.ServiceName == "s3" || ctx.ServiceName == "glacier" {
+                        ctx.Request.Header.Set("X-Amz-Content-Sha256", hash)
+                }
+        }
+        ctx.bodyDigest = hash
+}
+
+// isRequestSigned returns if the request is currently signed or presigned
+func (ctx *signingCtx) isRequestSigned() bool {
+        if ctx.isPresign && ctx.Query.Get("X-Amz-Signature") != "" {
+                return true
+        }
+        if ctx.Request.Header.Get("Authorization") != "" {
+                return true
+        }
+
+        return false
+}
+
+// unsign removes signing flags for both signed and presigned requests.
+func (ctx *signingCtx) removePresign() {
+        ctx.Query.Del("X-Amz-Algorithm")
+        ctx.Query.Del("X-Amz-Signature")
+        ctx.Query.Del("X-Amz-Security-Token")
+        ctx.Query.Del("X-Amz-Date")
+        ctx.Query.Del("X-Amz-Expires")
+        ctx.Query.Del("X-Amz-Credential")
+        ctx.Query.Del("X-Amz-SignedHeaders")
+}
+
+func makeHmac(key []byte, data []byte) []byte {
+        hash := hmac.New(sha256.New, key)
+        hash.Write(data)
+        return hash.Sum(nil)
+}
+
+func makeSha256(data []byte) []byte {
+        hash := sha256.New()
+        hash.Write(data)
+        return hash.Sum(nil)
+}
+
+func makeSha256Reader(reader io.ReadSeeker) []byte {
+        hash := sha256.New()
+        start, _ := reader.Seek(0, 1)
+        defer reader.Seek(start, 0)
+
+        io.Copy(hash, reader)
+        return hash.Sum(nil)
+}
+
+const doubleSpaces = "  "
+
+var doubleSpaceBytes = []byte(doubleSpaces)
+
+func stripExcessSpaces(headerVals []string) []string {
+        vals := make([]string, len(headerVals))
+        for i, str := range headerVals {
+                // Trim leading and trailing spaces
+                trimmed := strings.TrimSpace(str)
+
+                idx := strings.Index(trimmed, doubleSpaces)
+                var buf []byte
+                for idx > -1 {
+                        // Multiple adjacent spaces found
+                        if buf == nil {
+                                // first time create the buffer
+                                buf = []byte(trimmed)
+                        }
+
+                        stripToIdx := -1
+                        for j := idx + 1; j < len(buf); j++ {
+                                if buf[j] != ' ' {
+                                        buf = append(buf[:idx+1], buf[j:]...)
+                                        stripToIdx = j
+                                        break
+                                }
+                        }
+
+                        if stripToIdx >= 0 {
+                                idx = bytes.Index(buf[stripToIdx:], doubleSpaceBytes)
+                                if idx >= 0 {
+                                        idx += stripToIdx
+                                }
+                        } else {
+                                idx = -1
+                        }
+                }
+
+                if buf != nil {
+                        vals[i] = string(buf)
+                } else {
+                        vals[i] = trimmed
+                }
+        }
+        return vals
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/types.go b/vendor/github.com/aws/aws-sdk-go/aws/types.go
new file mode 100644
index 0000000..0e2d864
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/types.go
@@ -0,0 +1,118 @@
+package aws
+
+import (
+        "io"
+        "sync"
+)
+
+// ReadSeekCloser wraps a io.Reader returning a ReaderSeekerCloser. Should
+// only be used with an io.Reader that is also an io.Seeker. Doing so may
+// cause request signature errors, or request body's not sent for GET, HEAD
+// and DELETE HTTP methods.
+//
+// Deprecated: Should only be used with io.ReadSeeker. If using for
+// S3 PutObject to stream content use s3manager.Uploader instead.
+func ReadSeekCloser(r io.Reader) ReaderSeekerCloser {
+        return ReaderSeekerCloser{r}
+}
+
+// ReaderSeekerCloser represents a reader that can also delegate io.Seeker and
+// io.Closer interfaces to the underlying object if they are available.
+type ReaderSeekerCloser struct {
+        r io.Reader
+}
+
+// Read reads from the reader up to size of p. The number of bytes read, and
+// error if it occurred will be returned.
+//
+// If the reader is not an io.Reader zero bytes read, and nil error will be returned.
+//
+// Performs the same functionality as io.Reader Read
+func (r ReaderSeekerCloser) Read(p []byte) (int, error) {
+        switch t := r.r.(type) {
+        case io.Reader:
+                return t.Read(p)
+        }
+        return 0, nil
+}
+
+// Seek sets the offset for the next Read to offset, interpreted according to
+// whence: 0 means relative to the origin of the file, 1 means relative to the
+// current offset, and 2 means relative to the end. Seek returns the new offset
+// and an error, if any.
+//
+// If the ReaderSeekerCloser is not an io.Seeker nothing will be done.
+func (r ReaderSeekerCloser) Seek(offset int64, whence int) (int64, error) {
+        switch t := r.r.(type) {
+        case io.Seeker:
+                return t.Seek(offset, whence)
+        }
+        return int64(0), nil
+}
+
+// IsSeeker returns if the underlying reader is also a seeker.
+func (r ReaderSeekerCloser) IsSeeker() bool {
+        _, ok := r.r.(io.Seeker)
+        return ok
+}
+
+// Close closes the ReaderSeekerCloser.
+//
+// If the ReaderSeekerCloser is not an io.Closer nothing will be done.
+func (r ReaderSeekerCloser) Close() error {
+        switch t := r.r.(type) {
+        case io.Closer:
+                return t.Close()
+        }
+        return nil
+}
+
+// A WriteAtBuffer provides a in memory buffer supporting the io.WriterAt interface
+// Can be used with the s3manager.Downloader to download content to a buffer
+// in memory. Safe to use concurrently.
+type WriteAtBuffer struct {
+        buf []byte
+        m   sync.Mutex
+
+        // GrowthCoeff defines the growth rate of the internal buffer. By
+        // default, the growth rate is 1, where expanding the internal
+        // buffer will allocate only enough capacity to fit the new expected
+        // length.
+        GrowthCoeff float64
+}
+
+// NewWriteAtBuffer creates a WriteAtBuffer with an internal buffer
+// provided by buf.
+func NewWriteAtBuffer(buf []byte) *WriteAtBuffer {
+        return &WriteAtBuffer{buf: buf}
+}
+
+// WriteAt writes a slice of bytes to a buffer starting at the position provided
+// The number of bytes written will be returned, or error. Can overwrite previous
+// written slices if the write ats overlap.
+func (b *WriteAtBuffer) WriteAt(p []byte, pos int64) (n int, err error) {
+        pLen := len(p)
+        expLen := pos + int64(pLen)
+        b.m.Lock()
+        defer b.m.Unlock()
+        if int64(len(b.buf)) < expLen {
+                if int64(cap(b.buf)) < expLen {
+                        if b.GrowthCoeff < 1 {
+                                b.GrowthCoeff = 1
+                        }
+                        newBuf := make([]byte, expLen, int64(b.GrowthCoeff*float64(expLen)))
+                        copy(newBuf, b.buf)
+                        b.buf = newBuf
+                }
+                b.buf = b.buf[:expLen]
+        }
+        copy(b.buf[pos:], p)
+        return pLen, nil
+}
+
+// Bytes returns a slice of bytes written to the buffer.
+func (b *WriteAtBuffer) Bytes() []byte {
+        b.m.Lock()
+        defer b.m.Unlock()
+        return b.buf
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/url.go b/vendor/github.com/aws/aws-sdk-go/aws/url.go
new file mode 100644
index 0000000..6192b24
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/url.go
@@ -0,0 +1,12 @@
+// +build go1.8
+
+package aws
+
+import "net/url"
+
+// URLHostname will extract the Hostname without port from the URL value.
+//
+// Wrapper of net/url#URL.Hostname for backwards Go version compatibility.
+func URLHostname(url *url.URL) string {
+        return url.Hostname()
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/url_1_7.go b/vendor/github.com/aws/aws-sdk-go/aws/url_1_7.go
new file mode 100644
index 0000000..0210d27
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/url_1_7.go
@@ -0,0 +1,29 @@
+// +build !go1.8
+
+package aws
+
+import (
+        "net/url"
+        "strings"
+)
+
+// URLHostname will extract the Hostname without port from the URL value.
+//
+// Copy of Go 1.8's net/url#URL.Hostname functionality.
+func URLHostname(url *url.URL) string {
+        return stripPort(url.Host)
+
+}
+
+// stripPort is copy of Go 1.8 url#URL.Hostname functionality.
+// https://golang.org/src/net/url/url.go
+func stripPort(hostport string) string {
+        colon := strings.IndexByte(hostport, ':')
+        if colon == -1 {
+                return hostport
+        }
+        if i := strings.IndexByte(hostport, ']'); i != -1 {
+                return strings.TrimPrefix(hostport[:i], "[")
+        }
+        return hostport[:colon]
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/version.go b/vendor/github.com/aws/aws-sdk-go/aws/version.go
new file mode 100644
index 0000000..129dad9
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/version.go
@@ -0,0 +1,8 @@
+// Package aws provides core functionality for making requests to AWS services.
+package aws
+
+// SDKName is the name of this AWS SDK
+const SDKName = "aws-sdk-go"
+
+// SDKVersion is the version of this SDK
+const SDKVersion = "1.8.21"
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/idempotency.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/idempotency.go
new file mode 100644
index 0000000..53831df
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/idempotency.go
@@ -0,0 +1,75 @@
+package protocol
+
+import (
+        "crypto/rand"
+        "fmt"
+        "reflect"
+)
+
+// RandReader is the random reader the protocol package will use to read
+// random bytes from. This is exported for testing, and should not be used.
+var RandReader = rand.Reader
+
+const idempotencyTokenFillTag = `idempotencyToken`
+
+// CanSetIdempotencyToken returns true if the struct field should be
+// automatically populated with a Idempotency token.
+//
+// Only *string and string type fields that are tagged with idempotencyToken
+// which are not already set can be auto filled.
+func CanSetIdempotencyToken(v reflect.Value, f reflect.StructField) bool {
+        switch u := v.Interface().(type) {
+        // To auto fill an Idempotency token the field must be a string,
+        // tagged for auto fill, and have a zero value.
+        case *string:
+                return u == nil && len(f.Tag.Get(idempotencyTokenFillTag)) != 0
+        case string:
+                return len(u) == 0 && len(f.Tag.Get(idempotencyTokenFillTag)) != 0
+        }
+
+        return false
+}
+
+// GetIdempotencyToken returns a randomly generated idempotency token.
+func GetIdempotencyToken() string {
+        b := make([]byte, 16)
+        RandReader.Read(b)
+
+        return UUIDVersion4(b)
+}
+
+// SetIdempotencyToken will set the value provided with a Idempotency Token.
+// Given that the value can be set. Will panic if value is not setable.
+func SetIdempotencyToken(v reflect.Value) {
+        if v.Kind() == reflect.Ptr {
+                if v.IsNil() && v.CanSet() {
+                        v.Set(reflect.New(v.Type().Elem()))
+                }
+                v = v.Elem()
+        }
+        v = reflect.Indirect(v)
+
+        if !v.CanSet() {
+                panic(fmt.Sprintf("unable to set idempotnecy token %v", v))
+        }
+
+        b := make([]byte, 16)
+        _, err := rand.Read(b)
+        if err != nil {
+                // TODO handle error
+                return
+        }
+
+        v.Set(reflect.ValueOf(UUIDVersion4(b)))
+}
+
+// UUIDVersion4 returns a Version 4 random UUID from the byte slice provided
+func UUIDVersion4(u []byte) string {
+        // https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_4_.28random.29
+        // 13th character is "4"
+        u[6] = (u[6] | 0x40) & 0x4F
+        // 17th character is "8", "9", "a", or "b"
+        u[8] = (u[8] | 0x80) & 0xBF
+
+        return fmt.Sprintf(`%X-%X-%X-%X-%X`, u[0:4], u[4:6], u[6:8], u[8:10], u[10:])
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/query/build.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/build.go
new file mode 100644
index 0000000..18169f0
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/build.go
@@ -0,0 +1,36 @@
+// Package query provides serialization of AWS query requests, and responses.
+package query
+
+//go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/input/query.json build_test.go
+
+import (
+        "net/url"
+
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/request"
+        "github.com/aws/aws-sdk-go/private/protocol/query/queryutil"
+)
+
+// BuildHandler is a named request handler for building query protocol requests
+var BuildHandler = request.NamedHandler{Name: "awssdk.query.Build", Fn: Build}
+
+// Build builds a request for an AWS Query service.
+func Build(r *request.Request) {
+        body := url.Values{
+                "Action":  {r.Operation.Name},
+                "Version": {r.ClientInfo.APIVersion},
+        }
+        if err := queryutil.Parse(body, r.Params, false); err != nil {
+                r.Error = awserr.New("SerializationError", "failed encoding Query request", err)
+                return
+        }
+
+        if r.ExpireTime == 0 {
+                r.HTTPRequest.Method = "POST"
+                r.HTTPRequest.Header.Set("Content-Type", "application/x-www-form-urlencoded; charset=utf-8")
+                r.SetBufferBody([]byte(body.Encode()))
+        } else { // This is a pre-signed request
+                r.HTTPRequest.Method = "GET"
+                r.HTTPRequest.URL.RawQuery = body.Encode()
+        }
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/query/queryutil/queryutil.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/queryutil/queryutil.go
new file mode 100644
index 0000000..524ca95
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/queryutil/queryutil.go
@@ -0,0 +1,237 @@
+package queryutil
+
+import (
+        "encoding/base64"
+        "fmt"
+        "net/url"
+        "reflect"
+        "sort"
+        "strconv"
+        "strings"
+        "time"
+
+        "github.com/aws/aws-sdk-go/private/protocol"
+)
+
+// Parse parses an object i and fills a url.Values object. The isEC2 flag
+// indicates if this is the EC2 Query sub-protocol.
+func Parse(body url.Values, i interface{}, isEC2 bool) error {
+        q := queryParser{isEC2: isEC2}
+        return q.parseValue(body, reflect.ValueOf(i), "", "")
+}
+
+func elemOf(value reflect.Value) reflect.Value {
+        for value.Kind() == reflect.Ptr {
+                value = value.Elem()
+        }
+        return value
+}
+
+type queryParser struct {
+        isEC2 bool
+}
+
+func (q *queryParser) parseValue(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error {
+        value = elemOf(value)
+
+        // no need to handle zero values
+        if !value.IsValid() {
+                return nil
+        }
+
+        t := tag.Get("type")
+        if t == "" {
+                switch value.Kind() {
+                case reflect.Struct:
+                        t = "structure"
+                case reflect.Slice:
+                        t = "list"
+                case reflect.Map:
+                        t = "map"
+                }
+        }
+
+        switch t {
+        case "structure":
+                return q.parseStruct(v, value, prefix)
+        case "list":
+                return q.parseList(v, value, prefix, tag)
+        case "map":
+                return q.parseMap(v, value, prefix, tag)
+        default:
+                return q.parseScalar(v, value, prefix, tag)
+        }
+}
+
+func (q *queryParser) parseStruct(v url.Values, value reflect.Value, prefix string) error {
+        if !value.IsValid() {
+                return nil
+        }
+
+        t := value.Type()
+        for i := 0; i < value.NumField(); i++ {
+                elemValue := elemOf(value.Field(i))
+                field := t.Field(i)
+
+                if field.PkgPath != "" {
+                        continue // ignore unexported fields
+                }
+                if field.Tag.Get("ignore") != "" {
+                        continue
+                }
+
+                if protocol.CanSetIdempotencyToken(value.Field(i), field) {
+                        token := protocol.GetIdempotencyToken()
+                        elemValue = reflect.ValueOf(token)
+                }
+
+                var name string
+                if q.isEC2 {
+                        name = field.Tag.Get("queryName")
+                }
+                if name == "" {
+                        if field.Tag.Get("flattened") != "" && field.Tag.Get("locationNameList") != "" {
+                                name = field.Tag.Get("locationNameList")
+                        } else if locName := field.Tag.Get("locationName"); locName != "" {
+                                name = locName
+                        }
+                        if name != "" && q.isEC2 {
+                                name = strings.ToUpper(name[0:1]) + name[1:]
+                        }
+                }
+                if name == "" {
+                        name = field.Name
+                }
+
+                if prefix != "" {
+                        name = prefix + "." + name
+                }
+
+                if err := q.parseValue(v, elemValue, name, field.Tag); err != nil {
+                        return err
+                }
+        }
+        return nil
+}
+
+func (q *queryParser) parseList(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error {
+        // If it's empty, generate an empty value
+        if !value.IsNil() && value.Len() == 0 {
+                v.Set(prefix, "")
+                return nil
+        }
+
+        // check for unflattened list member
+        if !q.isEC2 && tag.Get("flattened") == "" {
+                if listName := tag.Get("locationNameList"); listName == "" {
+                        prefix += ".member"
+                } else {
+                        prefix += "." + listName
+                }
+        }
+
+        for i := 0; i < value.Len(); i++ {
+                slicePrefix := prefix
+                if slicePrefix == "" {
+                        slicePrefix = strconv.Itoa(i + 1)
+                } else {
+                        slicePrefix = slicePrefix + "." + strconv.Itoa(i+1)
+                }
+                if err := q.parseValue(v, value.Index(i), slicePrefix, ""); err != nil {
+                        return err
+                }
+        }
+        return nil
+}
+
+func (q *queryParser) parseMap(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error {
+        // If it's empty, generate an empty value
+        if !value.IsNil() && value.Len() == 0 {
+                v.Set(prefix, "")
+                return nil
+        }
+
+        // check for unflattened list member
+        if !q.isEC2 && tag.Get("flattened") == "" {
+                prefix += ".entry"
+        }
+
+        // sort keys for improved serialization consistency.
+        // this is not strictly necessary for protocol support.
+        mapKeyValues := value.MapKeys()
+        mapKeys := map[string]reflect.Value{}
+        mapKeyNames := make([]string, len(mapKeyValues))
+        for i, mapKey := range mapKeyValues {
+                name := mapKey.String()
+                mapKeys[name] = mapKey
+                mapKeyNames[i] = name
+        }
+        sort.Strings(mapKeyNames)
+
+        for i, mapKeyName := range mapKeyNames {
+                mapKey := mapKeys[mapKeyName]
+                mapValue := value.MapIndex(mapKey)
+
+                kname := tag.Get("locationNameKey")
+                if kname == "" {
+                        kname = "key"
+                }
+                vname := tag.Get("locationNameValue")
+                if vname == "" {
+                        vname = "value"
+                }
+
+                // serialize key
+                var keyName string
+                if prefix == "" {
+                        keyName = strconv.Itoa(i+1) + "." + kname
+                } else {
+                        keyName = prefix + "." + strconv.Itoa(i+1) + "." + kname
+                }
+
+                if err := q.parseValue(v, mapKey, keyName, ""); err != nil {
+                        return err
+                }
+
+                // serialize value
+                var valueName string
+                if prefix == "" {
+                        valueName = strconv.Itoa(i+1) + "." + vname
+                } else {
+                        valueName = prefix + "." + strconv.Itoa(i+1) + "." + vname
+                }
+
+                if err := q.parseValue(v, mapValue, valueName, ""); err != nil {
+                        return err
+                }
+        }
+
+        return nil
+}
+
+func (q *queryParser) parseScalar(v url.Values, r reflect.Value, name string, tag reflect.StructTag) error {
+        switch value := r.Interface().(type) {
+        case string:
+                v.Set(name, value)
+        case []byte:
+                if !r.IsNil() {
+                        v.Set(name, base64.StdEncoding.EncodeToString(value))
+                }
+        case bool:
+                v.Set(name, strconv.FormatBool(value))
+        case int64:
+                v.Set(name, strconv.FormatInt(value, 10))
+        case int:
+                v.Set(name, strconv.Itoa(value))
+        case float64:
+                v.Set(name, strconv.FormatFloat(value, 'f', -1, 64))
+        case float32:
+                v.Set(name, strconv.FormatFloat(float64(value), 'f', -1, 32))
+        case time.Time:
+                const ISO8601UTC = "2006-01-02T15:04:05Z"
+                v.Set(name, value.UTC().Format(ISO8601UTC))
+        default:
+                return fmt.Errorf("unsupported value for param %s: %v (%s)", name, r.Interface(), r.Type().Name())
+        }
+        return nil
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal.go
new file mode 100644
index 0000000..e0f4d5a
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal.go
@@ -0,0 +1,35 @@
+package query
+
+//go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/output/query.json unmarshal_test.go
+
+import (
+        "encoding/xml"
+
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/request"
+        "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil"
+)
+
+// UnmarshalHandler is a named request handler for unmarshaling query protocol requests
+var UnmarshalHandler = request.NamedHandler{Name: "awssdk.query.Unmarshal", Fn: Unmarshal}
+
+// UnmarshalMetaHandler is a named request handler for unmarshaling query protocol request metadata
+var UnmarshalMetaHandler = request.NamedHandler{Name: "awssdk.query.UnmarshalMeta", Fn: UnmarshalMeta}
+
+// Unmarshal unmarshals a response for an AWS Query service.
+func Unmarshal(r *request.Request) {
+        defer r.HTTPResponse.Body.Close()
+        if r.DataFilled() {
+                decoder := xml.NewDecoder(r.HTTPResponse.Body)
+                err := xmlutil.UnmarshalXML(r.Data, decoder, r.Operation.Name+"Result")
+                if err != nil {
+                        r.Error = awserr.New("SerializationError", "failed decoding Query response", err)
+                        return
+                }
+        }
+}
+
+// UnmarshalMeta unmarshals header response values for an AWS Query service.
+func UnmarshalMeta(r *request.Request) {
+        r.RequestID = r.HTTPResponse.Header.Get("X-Amzn-Requestid")
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal_error.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal_error.go
new file mode 100644
index 0000000..f214296
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal_error.go
@@ -0,0 +1,66 @@
+package query
+
+import (
+        "encoding/xml"
+        "io/ioutil"
+
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+type xmlErrorResponse struct {
+        XMLName   xml.Name `xml:"ErrorResponse"`
+        Code      string   `xml:"Error>Code"`
+        Message   string   `xml:"Error>Message"`
+        RequestID string   `xml:"RequestId"`
+}
+
+type xmlServiceUnavailableResponse struct {
+        XMLName xml.Name `xml:"ServiceUnavailableException"`
+}
+
+// UnmarshalErrorHandler is a name request handler to unmarshal request errors
+var UnmarshalErrorHandler = request.NamedHandler{Name: "awssdk.query.UnmarshalError", Fn: UnmarshalError}
+
+// UnmarshalError unmarshals an error response for an AWS Query service.
+func UnmarshalError(r *request.Request) {
+        defer r.HTTPResponse.Body.Close()
+
+        bodyBytes, err := ioutil.ReadAll(r.HTTPResponse.Body)
+        if err != nil {
+                r.Error = awserr.New("SerializationError", "failed to read from query HTTP response body", err)
+                return
+        }
+
+        // First check for specific error
+        resp := xmlErrorResponse{}
+        decodeErr := xml.Unmarshal(bodyBytes, &resp)
+        if decodeErr == nil {
+                reqID := resp.RequestID
+                if reqID == "" {
+                        reqID = r.RequestID
+                }
+                r.Error = awserr.NewRequestFailure(
+                        awserr.New(resp.Code, resp.Message, nil),
+                        r.HTTPResponse.StatusCode,
+                        reqID,
+                )
+                return
+        }
+
+        // Check for unhandled error
+        servUnavailResp := xmlServiceUnavailableResponse{}
+        unavailErr := xml.Unmarshal(bodyBytes, &servUnavailResp)
+        if unavailErr == nil {
+                r.Error = awserr.NewRequestFailure(
+                        awserr.New("ServiceUnavailableException", "service is unavailable", nil),
+                        r.HTTPResponse.StatusCode,
+                        r.RequestID,
+                )
+                return
+        }
+
+        // Failed to retrieve any error message from the response body
+        r.Error = awserr.New("SerializationError",
+                "failed to decode query XML error response", decodeErr)
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/build.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/build.go
new file mode 100644
index 0000000..7161835
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/build.go
@@ -0,0 +1,290 @@
+// Package rest provides RESTful serialization of AWS requests and responses.
+package rest
+
+import (
+        "bytes"
+        "encoding/base64"
+        "encoding/json"
+        "fmt"
+        "io"
+        "net/http"
+        "net/url"
+        "path"
+        "reflect"
+        "strconv"
+        "strings"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+// RFC822 returns an RFC822 formatted timestamp for AWS protocols
+const RFC822 = "Mon, 2 Jan 2006 15:04:05 GMT"
+
+// Whether the byte value can be sent without escaping in AWS URLs
+var noEscape [256]bool
+
+var errValueNotSet = fmt.Errorf("value not set")
+
+func init() {
+        for i := 0; i < len(noEscape); i++ {
+                // AWS expects every character except these to be escaped
+                noEscape[i] = (i >= 'A' && i <= 'Z') ||
+                        (i >= 'a' && i <= 'z') ||
+                        (i >= '0' && i <= '9') ||
+                        i == '-' ||
+                        i == '.' ||
+                        i == '_' ||
+                        i == '~'
+        }
+}
+
+// BuildHandler is a named request handler for building rest protocol requests
+var BuildHandler = request.NamedHandler{Name: "awssdk.rest.Build", Fn: Build}
+
+// Build builds the REST component of a service request.
+func Build(r *request.Request) {
+        if r.ParamsFilled() {
+                v := reflect.ValueOf(r.Params).Elem()
+                buildLocationElements(r, v, false)
+                buildBody(r, v)
+        }
+}
+
+// BuildAsGET builds the REST component of a service request with the ability to hoist
+// data from the body.
+func BuildAsGET(r *request.Request) {
+        if r.ParamsFilled() {
+                v := reflect.ValueOf(r.Params).Elem()
+                buildLocationElements(r, v, true)
+                buildBody(r, v)
+        }
+}
+
+func buildLocationElements(r *request.Request, v reflect.Value, buildGETQuery bool) {
+        query := r.HTTPRequest.URL.Query()
+
+        // Setup the raw path to match the base path pattern. This is needed
+        // so that when the path is mutated a custom escaped version can be
+        // stored in RawPath that will be used by the Go client.
+        r.HTTPRequest.URL.RawPath = r.HTTPRequest.URL.Path
+
+        for i := 0; i < v.NumField(); i++ {
+                m := v.Field(i)
+                if n := v.Type().Field(i).Name; n[0:1] == strings.ToLower(n[0:1]) {
+                        continue
+                }
+
+                if m.IsValid() {
+                        field := v.Type().Field(i)
+                        name := field.Tag.Get("locationName")
+                        if name == "" {
+                                name = field.Name
+                        }
+                        if kind := m.Kind(); kind == reflect.Ptr {
+                                m = m.Elem()
+                        } else if kind == reflect.Interface {
+                                if !m.Elem().IsValid() {
+                                        continue
+                                }
+                        }
+                        if !m.IsValid() {
+                                continue
+                        }
+                        if field.Tag.Get("ignore") != "" {
+                                continue
+                        }
+
+                        var err error
+                        switch field.Tag.Get("location") {
+                        case "headers": // header maps
+                                err = buildHeaderMap(&r.HTTPRequest.Header, m, field.Tag)
+                        case "header":
+                                err = buildHeader(&r.HTTPRequest.Header, m, name, field.Tag)
+                        case "uri":
+                                err = buildURI(r.HTTPRequest.URL, m, name, field.Tag)
+                        case "querystring":
+                                err = buildQueryString(query, m, name, field.Tag)
+                        default:
+                                if buildGETQuery {
+                                        err = buildQueryString(query, m, name, field.Tag)
+                                }
+                        }
+                        r.Error = err
+                }
+                if r.Error != nil {
+                        return
+                }
+        }
+
+        r.HTTPRequest.URL.RawQuery = query.Encode()
+        if !aws.BoolValue(r.Config.DisableRestProtocolURICleaning) {
+                cleanPath(r.HTTPRequest.URL)
+        }
+}
+
+func buildBody(r *request.Request, v reflect.Value) {
+        if field, ok := v.Type().FieldByName("_"); ok {
+                if payloadName := field.Tag.Get("payload"); payloadName != "" {
+                        pfield, _ := v.Type().FieldByName(payloadName)
+                        if ptag := pfield.Tag.Get("type"); ptag != "" && ptag != "structure" {
+                                payload := reflect.Indirect(v.FieldByName(payloadName))
+                                if payload.IsValid() && payload.Interface() != nil {
+                                        switch reader := payload.Interface().(type) {
+                                        case io.ReadSeeker:
+                                                r.SetReaderBody(reader)
+                                        case []byte:
+                                                r.SetBufferBody(reader)
+                                        case string:
+                                                r.SetStringBody(reader)
+                                        default:
+                                                r.Error = awserr.New("SerializationError",
+                                                        "failed to encode REST request",
+                                                        fmt.Errorf("unknown payload type %s", payload.Type()))
+                                        }
+                                }
+                        }
+                }
+        }
+}
+
+func buildHeader(header *http.Header, v reflect.Value, name string, tag reflect.StructTag) error {
+        str, err := convertType(v, tag)
+        if err == errValueNotSet {
+                return nil
+        } else if err != nil {
+                return awserr.New("SerializationError", "failed to encode REST request", err)
+        }
+
+        header.Add(name, str)
+
+        return nil
+}
+
+func buildHeaderMap(header *http.Header, v reflect.Value, tag reflect.StructTag) error {
+        prefix := tag.Get("locationName")
+        for _, key := range v.MapKeys() {
+                str, err := convertType(v.MapIndex(key), tag)
+                if err == errValueNotSet {
+                        continue
+                } else if err != nil {
+                        return awserr.New("SerializationError", "failed to encode REST request", err)
+
+                }
+
+                header.Add(prefix+key.String(), str)
+        }
+        return nil
+}
+
+func buildURI(u *url.URL, v reflect.Value, name string, tag reflect.StructTag) error {
+        value, err := convertType(v, tag)
+        if err == errValueNotSet {
+                return nil
+        } else if err != nil {
+                return awserr.New("SerializationError", "failed to encode REST request", err)
+        }
+
+        u.Path = strings.Replace(u.Path, "{"+name+"}", value, -1)
+        u.Path = strings.Replace(u.Path, "{"+name+"+}", value, -1)
+
+        u.RawPath = strings.Replace(u.RawPath, "{"+name+"}", EscapePath(value, true), -1)
+        u.RawPath = strings.Replace(u.RawPath, "{"+name+"+}", EscapePath(value, false), -1)
+
+        return nil
+}
+
+func buildQueryString(query url.Values, v reflect.Value, name string, tag reflect.StructTag) error {
+        switch value := v.Interface().(type) {
+        case []*string:
+                for _, item := range value {
+                        query.Add(name, *item)
+                }
+        case map[string]*string:
+                for key, item := range value {
+                        query.Add(key, *item)
+                }
+        case map[string][]*string:
+                for key, items := range value {
+                        for _, item := range items {
+                                query.Add(key, *item)
+                        }
+                }
+        default:
+                str, err := convertType(v, tag)
+                if err == errValueNotSet {
+                        return nil
+                } else if err != nil {
+                        return awserr.New("SerializationError", "failed to encode REST request", err)
+                }
+                query.Set(name, str)
+        }
+
+        return nil
+}
+
+func cleanPath(u *url.URL) {
+        hasSlash := strings.HasSuffix(u.Path, "/")
+
+        // clean up path, removing duplicate `/`
+        u.Path = path.Clean(u.Path)
+        u.RawPath = path.Clean(u.RawPath)
+
+        if hasSlash && !strings.HasSuffix(u.Path, "/") {
+                u.Path += "/"
+                u.RawPath += "/"
+        }
+}
+
+// EscapePath escapes part of a URL path in Amazon style
+func EscapePath(path string, encodeSep bool) string {
+        var buf bytes.Buffer
+        for i := 0; i < len(path); i++ {
+                c := path[i]
+                if noEscape[c] || (c == '/' && !encodeSep) {
+                        buf.WriteByte(c)
+                } else {
+                        fmt.Fprintf(&buf, "%%%02X", c)
+                }
+        }
+        return buf.String()
+}
+
+func convertType(v reflect.Value, tag reflect.StructTag) (string, error) {
+        v = reflect.Indirect(v)
+        if !v.IsValid() {
+                return "", errValueNotSet
+        }
+
+        var str string
+        switch value := v.Interface().(type) {
+        case string:
+                str = value
+        case []byte:
+                str = base64.StdEncoding.EncodeToString(value)
+        case bool:
+                str = strconv.FormatBool(value)
+        case int64:
+                str = strconv.FormatInt(value, 10)
+        case float64:
+                str = strconv.FormatFloat(value, 'f', -1, 64)
+        case time.Time:
+                str = value.UTC().Format(RFC822)
+        case aws.JSONValue:
+                b, err := json.Marshal(value)
+                if err != nil {
+                        return "", err
+                }
+                if tag.Get("location") == "header" {
+                        str = base64.StdEncoding.EncodeToString(b)
+                } else {
+                        str = string(b)
+                }
+        default:
+                err := fmt.Errorf("Unsupported value for param %v (%s)", v.Interface(), v.Type())
+                return "", err
+        }
+        return str, nil
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/payload.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/payload.go
new file mode 100644
index 0000000..4366de2
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/payload.go
@@ -0,0 +1,45 @@
+package rest
+
+import "reflect"
+
+// PayloadMember returns the payload field member of i if there is one, or nil.
+func PayloadMember(i interface{}) interface{} {
+        if i == nil {
+                return nil
+        }
+
+        v := reflect.ValueOf(i).Elem()
+        if !v.IsValid() {
+                return nil
+        }
+        if field, ok := v.Type().FieldByName("_"); ok {
+                if payloadName := field.Tag.Get("payload"); payloadName != "" {
+                        field, _ := v.Type().FieldByName(payloadName)
+                        if field.Tag.Get("type") != "structure" {
+                                return nil
+                        }
+
+                        payload := v.FieldByName(payloadName)
+                        if payload.IsValid() || (payload.Kind() == reflect.Ptr && !payload.IsNil()) {
+                                return payload.Interface()
+                        }
+                }
+        }
+        return nil
+}
+
+// PayloadType returns the type of a payload field member of i if there is one, or "".
+func PayloadType(i interface{}) string {
+        v := reflect.Indirect(reflect.ValueOf(i))
+        if !v.IsValid() {
+                return ""
+        }
+        if field, ok := v.Type().FieldByName("_"); ok {
+                if payloadName := field.Tag.Get("payload"); payloadName != "" {
+                        if member, ok := v.Type().FieldByName(payloadName); ok {
+                                return member.Tag.Get("type")
+                        }
+                }
+        }
+        return ""
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/unmarshal.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/unmarshal.go
new file mode 100644
index 0000000..7a779ee
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/unmarshal.go
@@ -0,0 +1,227 @@
+package rest
+
+import (
+        "bytes"
+        "encoding/base64"
+        "encoding/json"
+        "fmt"
+        "io"
+        "io/ioutil"
+        "net/http"
+        "reflect"
+        "strconv"
+        "strings"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+// UnmarshalHandler is a named request handler for unmarshaling rest protocol requests
+var UnmarshalHandler = request.NamedHandler{Name: "awssdk.rest.Unmarshal", Fn: Unmarshal}
+
+// UnmarshalMetaHandler is a named request handler for unmarshaling rest protocol request metadata
+var UnmarshalMetaHandler = request.NamedHandler{Name: "awssdk.rest.UnmarshalMeta", Fn: UnmarshalMeta}
+
+// Unmarshal unmarshals the REST component of a response in a REST service.
+func Unmarshal(r *request.Request) {
+        if r.DataFilled() {
+                v := reflect.Indirect(reflect.ValueOf(r.Data))
+                unmarshalBody(r, v)
+        }
+}
+
+// UnmarshalMeta unmarshals the REST metadata of a response in a REST service
+func UnmarshalMeta(r *request.Request) {
+        r.RequestID = r.HTTPResponse.Header.Get("X-Amzn-Requestid")
+        if r.RequestID == "" {
+                // Alternative version of request id in the header
+                r.RequestID = r.HTTPResponse.Header.Get("X-Amz-Request-Id")
+        }
+        if r.DataFilled() {
+                v := reflect.Indirect(reflect.ValueOf(r.Data))
+                unmarshalLocationElements(r, v)
+        }
+}
+
+func unmarshalBody(r *request.Request, v reflect.Value) {
+        if field, ok := v.Type().FieldByName("_"); ok {
+                if payloadName := field.Tag.Get("payload"); payloadName != "" {
+                        pfield, _ := v.Type().FieldByName(payloadName)
+                        if ptag := pfield.Tag.Get("type"); ptag != "" && ptag != "structure" {
+                                payload := v.FieldByName(payloadName)
+                                if payload.IsValid() {
+                                        switch payload.Interface().(type) {
+                                        case []byte:
+                                                defer r.HTTPResponse.Body.Close()
+                                                b, err := ioutil.ReadAll(r.HTTPResponse.Body)
+                                                if err != nil {
+                                                        r.Error = awserr.New("SerializationError", "failed to decode REST response", err)
+                                                } else {
+                                                        payload.Set(reflect.ValueOf(b))
+                                                }
+                                        case *string:
+                                                defer r.HTTPResponse.Body.Close()
+                                                b, err := ioutil.ReadAll(r.HTTPResponse.Body)
+                                                if err != nil {
+                                                        r.Error = awserr.New("SerializationError", "failed to decode REST response", err)
+                                                } else {
+                                                        str := string(b)
+                                                        payload.Set(reflect.ValueOf(&str))
+                                                }
+                                        default:
+                                                switch payload.Type().String() {
+                                                case "io.ReadCloser":
+                                                        payload.Set(reflect.ValueOf(r.HTTPResponse.Body))
+                                                case "io.ReadSeeker":
+                                                        b, err := ioutil.ReadAll(r.HTTPResponse.Body)
+                                                        if err != nil {
+                                                                r.Error = awserr.New("SerializationError",
+                                                                        "failed to read response body", err)
+                                                                return
+                                                        }
+                                                        payload.Set(reflect.ValueOf(ioutil.NopCloser(bytes.NewReader(b))))
+                                                default:
+                                                        io.Copy(ioutil.Discard, r.HTTPResponse.Body)
+                                                        defer r.HTTPResponse.Body.Close()
+                                                        r.Error = awserr.New("SerializationError",
+                                                                "failed to decode REST response",
+                                                                fmt.Errorf("unknown payload type %s", payload.Type()))
+                                                }
+                                        }
+                                }
+                        }
+                }
+        }
+}
+
+func unmarshalLocationElements(r *request.Request, v reflect.Value) {
+        for i := 0; i < v.NumField(); i++ {
+                m, field := v.Field(i), v.Type().Field(i)
+                if n := field.Name; n[0:1] == strings.ToLower(n[0:1]) {
+                        continue
+                }
+
+                if m.IsValid() {
+                        name := field.Tag.Get("locationName")
+                        if name == "" {
+                                name = field.Name
+                        }
+
+                        switch field.Tag.Get("location") {
+                        case "statusCode":
+                                unmarshalStatusCode(m, r.HTTPResponse.StatusCode)
+                        case "header":
+                                err := unmarshalHeader(m, r.HTTPResponse.Header.Get(name), field.Tag)
+                                if err != nil {
+                                        r.Error = awserr.New("SerializationError", "failed to decode REST response", err)
+                                        break
+                                }
+                        case "headers":
+                                prefix := field.Tag.Get("locationName")
+                                err := unmarshalHeaderMap(m, r.HTTPResponse.Header, prefix)
+                                if err != nil {
+                                        r.Error = awserr.New("SerializationError", "failed to decode REST response", err)
+                                        break
+                                }
+                        }
+                }
+                if r.Error != nil {
+                        return
+                }
+        }
+}
+
+func unmarshalStatusCode(v reflect.Value, statusCode int) {
+        if !v.IsValid() {
+                return
+        }
+
+        switch v.Interface().(type) {
+        case *int64:
+                s := int64(statusCode)
+                v.Set(reflect.ValueOf(&s))
+        }
+}
+
+func unmarshalHeaderMap(r reflect.Value, headers http.Header, prefix string) error {
+        switch r.Interface().(type) {
+        case map[string]*string: // we only support string map value types
+                out := map[string]*string{}
+                for k, v := range headers {
+                        k = http.CanonicalHeaderKey(k)
+                        if strings.HasPrefix(strings.ToLower(k), strings.ToLower(prefix)) {
+                                out[k[len(prefix):]] = &v[0]
+                        }
+                }
+                r.Set(reflect.ValueOf(out))
+        }
+        return nil
+}
+
+func unmarshalHeader(v reflect.Value, header string, tag reflect.StructTag) error {
+        isJSONValue := tag.Get("type") == "jsonvalue"
+        if isJSONValue {
+                if len(header) == 0 {
+                        return nil
+                }
+        } else if !v.IsValid() || (header == "" && v.Elem().Kind() != reflect.String) {
+                return nil
+        }
+
+        switch v.Interface().(type) {
+        case *string:
+                v.Set(reflect.ValueOf(&header))
+        case []byte:
+                b, err := base64.StdEncoding.DecodeString(header)
+                if err != nil {
+                        return err
+                }
+                v.Set(reflect.ValueOf(&b))
+        case *bool:
+                b, err := strconv.ParseBool(header)
+                if err != nil {
+                        return err
+                }
+                v.Set(reflect.ValueOf(&b))
+        case *int64:
+                i, err := strconv.ParseInt(header, 10, 64)
+                if err != nil {
+                        return err
+                }
+                v.Set(reflect.ValueOf(&i))
+        case *float64:
+                f, err := strconv.ParseFloat(header, 64)
+                if err != nil {
+                        return err
+                }
+                v.Set(reflect.ValueOf(&f))
+        case *time.Time:
+                t, err := time.Parse(RFC822, header)
+                if err != nil {
+                        return err
+                }
+                v.Set(reflect.ValueOf(&t))
+        case aws.JSONValue:
+                b := []byte(header)
+                var err error
+                if tag.Get("location") == "header" {
+                        b, err = base64.StdEncoding.DecodeString(header)
+                        if err != nil {
+                                return err
+                        }
+                }
+
+                m := aws.JSONValue{}
+                err = json.Unmarshal(b, &m)
+                if err != nil {
+                        return err
+                }
+                v.Set(reflect.ValueOf(m))
+        default:
+                err := fmt.Errorf("Unsupported value for param %v (%s)", v.Interface(), v.Type())
+                return err
+        }
+        return nil
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/restxml/restxml.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/restxml/restxml.go
new file mode 100644
index 0000000..7bdf4c8
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/restxml/restxml.go
@@ -0,0 +1,69 @@
+// Package restxml provides RESTful XML serialization of AWS
+// requests and responses.
+package restxml
+
+//go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/input/rest-xml.json build_test.go
+//go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/output/rest-xml.json unmarshal_test.go
+
+import (
+        "bytes"
+        "encoding/xml"
+
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/request"
+        "github.com/aws/aws-sdk-go/private/protocol/query"
+        "github.com/aws/aws-sdk-go/private/protocol/rest"
+        "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil"
+)
+
+// BuildHandler is a named request handler for building restxml protocol requests
+var BuildHandler = request.NamedHandler{Name: "awssdk.restxml.Build", Fn: Build}
+
+// UnmarshalHandler is a named request handler for unmarshaling restxml protocol requests
+var UnmarshalHandler = request.NamedHandler{Name: "awssdk.restxml.Unmarshal", Fn: Unmarshal}
+
+// UnmarshalMetaHandler is a named request handler for unmarshaling restxml protocol request metadata
+var UnmarshalMetaHandler = request.NamedHandler{Name: "awssdk.restxml.UnmarshalMeta", Fn: UnmarshalMeta}
+
+// UnmarshalErrorHandler is a named request handler for unmarshaling restxml protocol request errors
+var UnmarshalErrorHandler = request.NamedHandler{Name: "awssdk.restxml.UnmarshalError", Fn: UnmarshalError}
+
+// Build builds a request payload for the REST XML protocol.
+func Build(r *request.Request) {
+        rest.Build(r)
+
+        if t := rest.PayloadType(r.Params); t == "structure" || t == "" {
+                var buf bytes.Buffer
+                err := xmlutil.BuildXML(r.Params, xml.NewEncoder(&buf))
+                if err != nil {
+                        r.Error = awserr.New("SerializationError", "failed to encode rest XML request", err)
+                        return
+                }
+                r.SetBufferBody(buf.Bytes())
+        }
+}
+
+// Unmarshal unmarshals a payload response for the REST XML protocol.
+func Unmarshal(r *request.Request) {
+        if t := rest.PayloadType(r.Data); t == "structure" || t == "" {
+                defer r.HTTPResponse.Body.Close()
+                decoder := xml.NewDecoder(r.HTTPResponse.Body)
+                err := xmlutil.UnmarshalXML(r.Data, decoder, "")
+                if err != nil {
+                        r.Error = awserr.New("SerializationError", "failed to decode REST XML response", err)
+                        return
+                }
+        } else {
+                rest.Unmarshal(r)
+        }
+}
+
+// UnmarshalMeta unmarshals response headers for the REST XML protocol.
+func UnmarshalMeta(r *request.Request) {
+        rest.UnmarshalMeta(r)
+}
+
+// UnmarshalError unmarshals a response error for the REST XML protocol.
+func UnmarshalError(r *request.Request) {
+        query.UnmarshalError(r)
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/unmarshal.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/unmarshal.go
new file mode 100644
index 0000000..da1a681
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/unmarshal.go
@@ -0,0 +1,21 @@
+package protocol
+
+import (
+        "io"
+        "io/ioutil"
+
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+// UnmarshalDiscardBodyHandler is a named request handler to empty and close a response's body
+var UnmarshalDiscardBodyHandler = request.NamedHandler{Name: "awssdk.shared.UnmarshalDiscardBody", Fn: UnmarshalDiscardBody}
+
+// UnmarshalDiscardBody is a request handler to empty a response's body and closing it.
+func UnmarshalDiscardBody(r *request.Request) {
+        if r.HTTPResponse == nil || r.HTTPResponse.Body == nil {
+                return
+        }
+
+        io.Copy(ioutil.Discard, r.HTTPResponse.Body)
+        r.HTTPResponse.Body.Close()
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/build.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/build.go
new file mode 100644
index 0000000..7091b45
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/build.go
@@ -0,0 +1,296 @@
+// Package xmlutil provides XML serialization of AWS requests and responses.
+package xmlutil
+
+import (
+        "encoding/base64"
+        "encoding/xml"
+        "fmt"
+        "reflect"
+        "sort"
+        "strconv"
+        "time"
+
+        "github.com/aws/aws-sdk-go/private/protocol"
+)
+
+// BuildXML will serialize params into an xml.Encoder.
+// Error will be returned if the serialization of any of the params or nested values fails.
+func BuildXML(params interface{}, e *xml.Encoder) error {
+        b := xmlBuilder{encoder: e, namespaces: map[string]string{}}
+        root := NewXMLElement(xml.Name{})
+        if err := b.buildValue(reflect.ValueOf(params), root, ""); err != nil {
+                return err
+        }
+        for _, c := range root.Children {
+                for _, v := range c {
+                        return StructToXML(e, v, false)
+                }
+        }
+        return nil
+}
+
+// Returns the reflection element of a value, if it is a pointer.
+func elemOf(value reflect.Value) reflect.Value {
+        for value.Kind() == reflect.Ptr {
+                value = value.Elem()
+        }
+        return value
+}
+
+// A xmlBuilder serializes values from Go code to XML
+type xmlBuilder struct {
+        encoder    *xml.Encoder
+        namespaces map[string]string
+}
+
+// buildValue generic XMLNode builder for any type. Will build value for their specific type
+// struct, list, map, scalar.
+//
+// Also takes a "type" tag value to set what type a value should be converted to XMLNode as. If
+// type is not provided reflect will be used to determine the value's type.
+func (b *xmlBuilder) buildValue(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
+        value = elemOf(value)
+        if !value.IsValid() { // no need to handle zero values
+                return nil
+        } else if tag.Get("location") != "" { // don't handle non-body location values
+                return nil
+        }
+
+        t := tag.Get("type")
+        if t == "" {
+                switch value.Kind() {
+                case reflect.Struct:
+                        t = "structure"
+                case reflect.Slice:
+                        t = "list"
+                case reflect.Map:
+                        t = "map"
+                }
+        }
+
+        switch t {
+        case "structure":
+                if field, ok := value.Type().FieldByName("_"); ok {
+                        tag = tag + reflect.StructTag(" ") + field.Tag
+                }
+                return b.buildStruct(value, current, tag)
+        case "list":
+                return b.buildList(value, current, tag)
+        case "map":
+                return b.buildMap(value, current, tag)
+        default:
+                return b.buildScalar(value, current, tag)
+        }
+}
+
+// buildStruct adds a struct and its fields to the current XMLNode. All fields any any nested
+// types are converted to XMLNodes also.
+func (b *xmlBuilder) buildStruct(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
+        if !value.IsValid() {
+                return nil
+        }
+
+        fieldAdded := false
+
+        // unwrap payloads
+        if payload := tag.Get("payload"); payload != "" {
+                field, _ := value.Type().FieldByName(payload)
+                tag = field.Tag
+                value = elemOf(value.FieldByName(payload))
+
+                if !value.IsValid() {
+                        return nil
+                }
+        }
+
+        child := NewXMLElement(xml.Name{Local: tag.Get("locationName")})
+
+        // there is an xmlNamespace associated with this struct
+        if prefix, uri := tag.Get("xmlPrefix"), tag.Get("xmlURI"); uri != "" {
+                ns := xml.Attr{
+                        Name:  xml.Name{Local: "xmlns"},
+                        Value: uri,
+                }
+                if prefix != "" {
+                        b.namespaces[prefix] = uri // register the namespace
+                        ns.Name.Local = "xmlns:" + prefix
+                }
+
+                child.Attr = append(child.Attr, ns)
+        }
+
+        t := value.Type()
+        for i := 0; i < value.NumField(); i++ {
+                member := elemOf(value.Field(i))
+                field := t.Field(i)
+
+                if field.PkgPath != "" {
+                        continue // ignore unexported fields
+                }
+                if field.Tag.Get("ignore") != "" {
+                        continue
+                }
+
+                mTag := field.Tag
+                if mTag.Get("location") != "" { // skip non-body members
+                        continue
+                }
+
+                if protocol.CanSetIdempotencyToken(value.Field(i), field) {
+                        token := protocol.GetIdempotencyToken()
+                        member = reflect.ValueOf(token)
+                }
+
+                memberName := mTag.Get("locationName")
+                if memberName == "" {
+                        memberName = field.Name
+                        mTag = reflect.StructTag(string(mTag) + ` locationName:"` + memberName + `"`)
+                }
+                if err := b.buildValue(member, child, mTag); err != nil {
+                        return err
+                }
+
+                fieldAdded = true
+        }
+
+        if fieldAdded { // only append this child if we have one ore more valid members
+                current.AddChild(child)
+        }
+
+        return nil
+}
+
+// buildList adds the value's list items to the current XMLNode as children nodes. All
+// nested values in the list are converted to XMLNodes also.
+func (b *xmlBuilder) buildList(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
+        if value.IsNil() { // don't build omitted lists
+                return nil
+        }
+
+        // check for unflattened list member
+        flattened := tag.Get("flattened") != ""
+
+        xname := xml.Name{Local: tag.Get("locationName")}
+        if flattened {
+                for i := 0; i < value.Len(); i++ {
+                        child := NewXMLElement(xname)
+                        current.AddChild(child)
+                        if err := b.buildValue(value.Index(i), child, ""); err != nil {
+                                return err
+                        }
+                }
+        } else {
+                list := NewXMLElement(xname)
+                current.AddChild(list)
+
+                for i := 0; i < value.Len(); i++ {
+                        iname := tag.Get("locationNameList")
+                        if iname == "" {
+                                iname = "member"
+                        }
+
+                        child := NewXMLElement(xml.Name{Local: iname})
+                        list.AddChild(child)
+                        if err := b.buildValue(value.Index(i), child, ""); err != nil {
+                                return err
+                        }
+                }
+        }
+
+        return nil
+}
+
+// buildMap adds the value's key/value pairs to the current XMLNode as children nodes. All
+// nested values in the map are converted to XMLNodes also.
+//
+// Error will be returned if it is unable to build the map's values into XMLNodes
+func (b *xmlBuilder) buildMap(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
+        if value.IsNil() { // don't build omitted maps
+                return nil
+        }
+
+        maproot := NewXMLElement(xml.Name{Local: tag.Get("locationName")})
+        current.AddChild(maproot)
+        current = maproot
+
+        kname, vname := "key", "value"
+        if n := tag.Get("locationNameKey"); n != "" {
+                kname = n
+        }
+        if n := tag.Get("locationNameValue"); n != "" {
+                vname = n
+        }
+
+        // sorting is not required for compliance, but it makes testing easier
+        keys := make([]string, value.Len())
+        for i, k := range value.MapKeys() {
+                keys[i] = k.String()
+        }
+        sort.Strings(keys)
+
+        for _, k := range keys {
+                v := value.MapIndex(reflect.ValueOf(k))
+
+                mapcur := current
+                if tag.Get("flattened") == "" { // add "entry" tag to non-flat maps
+                        child := NewXMLElement(xml.Name{Local: "entry"})
+                        mapcur.AddChild(child)
+                        mapcur = child
+                }
+
+                kchild := NewXMLElement(xml.Name{Local: kname})
+                kchild.Text = k
+                vchild := NewXMLElement(xml.Name{Local: vname})
+                mapcur.AddChild(kchild)
+                mapcur.AddChild(vchild)
+
+                if err := b.buildValue(v, vchild, ""); err != nil {
+                        return err
+                }
+        }
+
+        return nil
+}
+
+// buildScalar will convert the value into a string and append it as a attribute or child
+// of the current XMLNode.
+//
+// The value will be added as an attribute if tag contains a "xmlAttribute" attribute value.
+//
+// Error will be returned if the value type is unsupported.
+func (b *xmlBuilder) buildScalar(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
+        var str string
+        switch converted := value.Interface().(type) {
+        case string:
+                str = converted
+        case []byte:
+                if !value.IsNil() {
+                        str = base64.StdEncoding.EncodeToString(converted)
+                }
+        case bool:
+                str = strconv.FormatBool(converted)
+        case int64:
+                str = strconv.FormatInt(converted, 10)
+        case int:
+                str = strconv.Itoa(converted)
+        case float64:
+                str = strconv.FormatFloat(converted, 'f', -1, 64)
+        case float32:
+                str = strconv.FormatFloat(float64(converted), 'f', -1, 32)
+        case time.Time:
+                const ISO8601UTC = "2006-01-02T15:04:05Z"
+                str = converted.UTC().Format(ISO8601UTC)
+        default:
+                return fmt.Errorf("unsupported value for param %s: %v (%s)",
+                        tag.Get("locationName"), value.Interface(), value.Type().Name())
+        }
+
+        xname := xml.Name{Local: tag.Get("locationName")}
+        if tag.Get("xmlAttribute") != "" { // put into current node's attribute list
+                attr := xml.Attr{Name: xname, Value: str}
+                current.Attr = append(current.Attr, attr)
+        } else { // regular text node
+                current.AddChild(&XMLNode{Name: xname, Text: str})
+        }
+        return nil
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/unmarshal.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/unmarshal.go
new file mode 100644
index 0000000..8758462
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/unmarshal.go
@@ -0,0 +1,260 @@
+package xmlutil
+
+import (
+        "encoding/base64"
+        "encoding/xml"
+        "fmt"
+        "io"
+        "reflect"
+        "strconv"
+        "strings"
+        "time"
+)
+
+// UnmarshalXML deserializes an xml.Decoder into the container v. V
+// 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, err := XMLToStruct(d, nil)
+        if err != nil {
+                return err
+        }
+        if n.Children != nil {
+                for _, root := range n.Children {
+                        for _, c := range root {
+                                if wrappedChild, ok := c.Children[wrapper]; ok {
+                                        c = wrappedChild[0] // pull out wrapped element
+                                }
+
+                                err = parse(reflect.ValueOf(v), c, "")
+                                if err != nil {
+                                        if err == io.EOF {
+                                                return nil
+                                        }
+                                        return err
+                                }
+                        }
+                }
+                return nil
+        }
+        return nil
+}
+
+// parse deserializes any value from the XMLNode. The type tag is used to infer the type, or reflect
+// will be used to determine the type from r.
+func parse(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
+        rtype := r.Type()
+        if rtype.Kind() == reflect.Ptr {
+                rtype = rtype.Elem() // check kind of actual element type
+        }
+
+        t := tag.Get("type")
+        if t == "" {
+                switch rtype.Kind() {
+                case reflect.Struct:
+                        t = "structure"
+                case reflect.Slice:
+                        t = "list"
+                case reflect.Map:
+                        t = "map"
+                }
+        }
+
+        switch t {
+        case "structure":
+                if field, ok := rtype.FieldByName("_"); ok {
+                        tag = field.Tag
+                }
+                return parseStruct(r, node, tag)
+        case "list":
+                return parseList(r, node, tag)
+        case "map":
+                return parseMap(r, node, tag)
+        default:
+                return parseScalar(r, node, tag)
+        }
+}
+
+// parseStruct deserializes a structure and its fields from an XMLNode. Any nested
+// types in the structure will also be deserialized.
+func parseStruct(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
+        t := r.Type()
+        if r.Kind() == reflect.Ptr {
+                if r.IsNil() { // create the structure if it's nil
+                        s := reflect.New(r.Type().Elem())
+                        r.Set(s)
+                        r = s
+                }
+
+                r = r.Elem()
+                t = t.Elem()
+        }
+
+        // unwrap any payloads
+        if payload := tag.Get("payload"); payload != "" {
+                field, _ := t.FieldByName(payload)
+                return parseStruct(r.FieldByName(payload), node, field.Tag)
+        }
+
+        for i := 0; i < t.NumField(); i++ {
+                field := t.Field(i)
+                if c := field.Name[0:1]; strings.ToLower(c) == c {
+                        continue // ignore unexported fields
+                }
+
+                // figure out what this field is called
+                name := field.Name
+                if field.Tag.Get("flattened") != "" && field.Tag.Get("locationNameList") != "" {
+                        name = field.Tag.Get("locationNameList")
+                } else if locName := field.Tag.Get("locationName"); locName != "" {
+                        name = locName
+                }
+
+                // try to find the field by name in elements
+                elems := node.Children[name]
+
+                if elems == nil { // try to find the field in attributes
+                        if val, ok := node.findElem(name); ok {
+                                elems = []*XMLNode{{Text: val}}
+                        }
+                }
+
+                member := r.FieldByName(field.Name)
+                for _, elem := range elems {
+                        err := parse(member, elem, field.Tag)
+                        if err != nil {
+                                return err
+                        }
+                }
+        }
+        return nil
+}
+
+// parseList deserializes a list of values from an XML node. Each list entry
+// will also be deserialized.
+func parseList(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
+        t := r.Type()
+
+        if tag.Get("flattened") == "" { // look at all item entries
+                mname := "member"
+                if name := tag.Get("locationNameList"); name != "" {
+                        mname = name
+                }
+
+                if Children, ok := node.Children[mname]; ok {
+                        if r.IsNil() {
+                                r.Set(reflect.MakeSlice(t, len(Children), len(Children)))
+                        }
+
+                        for i, c := range Children {
+                                err := parse(r.Index(i), c, "")
+                                if err != nil {
+                                        return err
+                                }
+                        }
+                }
+        } else { // flattened list means this is a single element
+                if r.IsNil() {
+                        r.Set(reflect.MakeSlice(t, 0, 0))
+                }
+
+                childR := reflect.Zero(t.Elem())
+                r.Set(reflect.Append(r, childR))
+                err := parse(r.Index(r.Len()-1), node, "")
+                if err != nil {
+                        return err
+                }
+        }
+
+        return nil
+}
+
+// parseMap deserializes a map from an XMLNode. The direct children of the XMLNode
+// will also be deserialized as map entries.
+func parseMap(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
+        if r.IsNil() {
+                r.Set(reflect.MakeMap(r.Type()))
+        }
+
+        if tag.Get("flattened") == "" { // look at all child entries
+                for _, entry := range node.Children["entry"] {
+                        parseMapEntry(r, entry, tag)
+                }
+        } else { // this element is itself an entry
+                parseMapEntry(r, node, tag)
+        }
+
+        return nil
+}
+
+// parseMapEntry deserializes a map entry from a XML node.
+func parseMapEntry(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
+        kname, vname := "key", "value"
+        if n := tag.Get("locationNameKey"); n != "" {
+                kname = n
+        }
+        if n := tag.Get("locationNameValue"); n != "" {
+                vname = n
+        }
+
+        keys, ok := node.Children[kname]
+        values := node.Children[vname]
+        if ok {
+                for i, key := range keys {
+                        keyR := reflect.ValueOf(key.Text)
+                        value := values[i]
+                        valueR := reflect.New(r.Type().Elem()).Elem()
+
+                        parse(valueR, value, "")
+                        r.SetMapIndex(keyR, valueR)
+                }
+        }
+        return nil
+}
+
+// parseScaller deserializes an XMLNode value into a concrete type based on the
+// interface type of r.
+//
+// Error is returned if the deserialization fails due to invalid type conversion,
+// or unsupported interface type.
+func parseScalar(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
+        switch r.Interface().(type) {
+        case *string:
+                r.Set(reflect.ValueOf(&node.Text))
+                return nil
+        case []byte:
+                b, err := base64.StdEncoding.DecodeString(node.Text)
+                if err != nil {
+                        return err
+                }
+                r.Set(reflect.ValueOf(b))
+        case *bool:
+                v, err := strconv.ParseBool(node.Text)
+                if err != nil {
+                        return err
+                }
+                r.Set(reflect.ValueOf(&v))
+        case *int64:
+                v, err := strconv.ParseInt(node.Text, 10, 64)
+                if err != nil {
+                        return err
+                }
+                r.Set(reflect.ValueOf(&v))
+        case *float64:
+                v, err := strconv.ParseFloat(node.Text, 64)
+                if err != nil {
+                        return err
+                }
+                r.Set(reflect.ValueOf(&v))
+        case *time.Time:
+                const ISO8601UTC = "2006-01-02T15:04:05Z"
+                t, err := time.Parse(ISO8601UTC, node.Text)
+                if err != nil {
+                        return err
+                }
+                r.Set(reflect.ValueOf(&t))
+        default:
+                return fmt.Errorf("unsupported value: %v (%s)", r.Interface(), r.Type())
+        }
+        return nil
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/xml_to_struct.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/xml_to_struct.go
new file mode 100644
index 0000000..3e970b6
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/xml_to_struct.go
@@ -0,0 +1,147 @@
+package xmlutil
+
+import (
+        "encoding/xml"
+        "fmt"
+        "io"
+        "sort"
+)
+
+// A XMLNode contains the values to be encoded or decoded.
+type XMLNode struct {
+        Name     xml.Name              `json:",omitempty"`
+        Children map[string][]*XMLNode `json:",omitempty"`
+        Text     string                `json:",omitempty"`
+        Attr     []xml.Attr            `json:",omitempty"`
+
+        namespaces map[string]string
+        parent     *XMLNode
+}
+
+// NewXMLElement returns a pointer to a new XMLNode initialized to default values.
+func NewXMLElement(name xml.Name) *XMLNode {
+        return &XMLNode{
+                Name:     name,
+                Children: map[string][]*XMLNode{},
+                Attr:     []xml.Attr{},
+        }
+}
+
+// AddChild adds child to the XMLNode.
+func (n *XMLNode) AddChild(child *XMLNode) {
+        if _, ok := n.Children[child.Name.Local]; !ok {
+                n.Children[child.Name.Local] = []*XMLNode{}
+        }
+        n.Children[child.Name.Local] = append(n.Children[child.Name.Local], child)
+}
+
+// XMLToStruct converts a xml.Decoder stream to XMLNode with nested values.
+func XMLToStruct(d *xml.Decoder, s *xml.StartElement) (*XMLNode, error) {
+        out := &XMLNode{}
+        for {
+                tok, err := d.Token()
+                if err != nil {
+                        if err == io.EOF {
+                                break
+                        } else {
+                                return out, err
+                        }
+                }
+
+                if tok == nil {
+                        break
+                }
+
+                switch typed := tok.(type) {
+                case xml.CharData:
+                        out.Text = string(typed.Copy())
+                case xml.StartElement:
+                        el := typed.Copy()
+                        out.Attr = el.Attr
+                        if out.Children == nil {
+                                out.Children = map[string][]*XMLNode{}
+                        }
+
+                        name := typed.Name.Local
+                        slice := out.Children[name]
+                        if slice == nil {
+                                slice = []*XMLNode{}
+                        }
+                        node, e := XMLToStruct(d, &el)
+                        out.findNamespaces()
+                        if e != nil {
+                                return out, e
+                        }
+                        node.Name = typed.Name
+                        node.findNamespaces()
+                        tempOut := *out
+                        // Save into a temp variable, simply because out gets squashed during
+                        // loop iterations
+                        node.parent = &tempOut
+                        slice = append(slice, node)
+                        out.Children[name] = slice
+                case xml.EndElement:
+                        if s != nil && s.Name.Local == typed.Name.Local { // matching end token
+                                return out, nil
+                        }
+                        out = &XMLNode{}
+                }
+        }
+        return out, nil
+}
+
+func (n *XMLNode) findNamespaces() {
+        ns := map[string]string{}
+        for _, a := range n.Attr {
+                if a.Name.Space == "xmlns" {
+                        ns[a.Value] = a.Name.Local
+                }
+        }
+
+        n.namespaces = ns
+}
+
+func (n *XMLNode) findElem(name string) (string, bool) {
+        for node := n; node != nil; node = node.parent {
+                for _, a := range node.Attr {
+                        namespace := a.Name.Space
+                        if v, ok := node.namespaces[namespace]; ok {
+                                namespace = v
+                        }
+                        if name == fmt.Sprintf("%s:%s", namespace, a.Name.Local) {
+                                return a.Value, true
+                        }
+                }
+        }
+        return "", false
+}
+
+// StructToXML writes an XMLNode to a xml.Encoder as tokens.
+func StructToXML(e *xml.Encoder, node *XMLNode, sorted bool) error {
+        e.EncodeToken(xml.StartElement{Name: node.Name, Attr: node.Attr})
+
+        if node.Text != "" {
+                e.EncodeToken(xml.CharData([]byte(node.Text)))
+        } else if sorted {
+                sortedNames := []string{}
+                for k := range node.Children {
+                        sortedNames = append(sortedNames, k)
+                }
+                sort.Strings(sortedNames)
+
+                for _, k := range sortedNames {
+                        for _, v := range node.Children[k] {
+                                StructToXML(e, v, sorted)
+                        }
+                }
+        } else {
+                for _, c := range node.Children {
+                        for _, v := range c {
+                                StructToXML(e, v, sorted)
+                        }
+                }
+        }
+
+        e.EncodeToken(xml.EndElement{Name: node.Name})
+        return e.Flush()
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/api.go b/vendor/github.com/aws/aws-sdk-go/service/s3/api.go
new file mode 100644
index 0000000..52ac02c
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/api.go
@@ -0,0 +1,19245 @@
+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
+
+package s3
+
+import (
+        "fmt"
+        "io"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awsutil"
+        "github.com/aws/aws-sdk-go/aws/request"
+        "github.com/aws/aws-sdk-go/private/protocol"
+        "github.com/aws/aws-sdk-go/private/protocol/restxml"
+)
+
+const opAbortMultipartUpload = "AbortMultipartUpload"
+
+// AbortMultipartUploadRequest generates a "aws/request.Request" representing the
+// client's request for the AbortMultipartUpload operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See AbortMultipartUpload for usage and error information.
+//
+// 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 AbortMultipartUpload method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the AbortMultipartUploadRequest method.
+//    req, resp := client.AbortMultipartUploadRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AbortMultipartUpload
+func (c *S3) AbortMultipartUploadRequest(input *AbortMultipartUploadInput) (req *request.Request, output *AbortMultipartUploadOutput) {
+        op := &request.Operation{
+                Name:       opAbortMultipartUpload,
+                HTTPMethod: "DELETE",
+                HTTPPath:   "/{Bucket}/{Key+}",
+        }
+
+        if input == nil {
+                input = &AbortMultipartUploadInput{}
+        }
+
+        output = &AbortMultipartUploadOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// AbortMultipartUpload API operation for Amazon Simple Storage Service.
+//
+// Aborts a multipart upload.
+//
+// To verify that all parts have been removed, so you don't get charged for
+// the part storage, you should call the List Parts operation and ensure the
+// parts list is empty.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation AbortMultipartUpload for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchUpload "NoSuchUpload"
+//   The specified multipart upload does not exist.
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AbortMultipartUpload
+func (c *S3) AbortMultipartUpload(input *AbortMultipartUploadInput) (*AbortMultipartUploadOutput, error) {
+        req, out := c.AbortMultipartUploadRequest(input)
+        return out, req.Send()
+}
+
+// AbortMultipartUploadWithContext is the same as AbortMultipartUpload with the addition of
+// the ability to pass a context and additional request options.
+//
+// See AbortMultipartUpload for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) AbortMultipartUploadWithContext(ctx aws.Context, input *AbortMultipartUploadInput, opts ...request.Option) (*AbortMultipartUploadOutput, error) {
+        req, out := c.AbortMultipartUploadRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opCompleteMultipartUpload = "CompleteMultipartUpload"
+
+// CompleteMultipartUploadRequest generates a "aws/request.Request" representing the
+// client's request for the CompleteMultipartUpload operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See CompleteMultipartUpload for usage and error information.
+//
+// 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 CompleteMultipartUpload method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the CompleteMultipartUploadRequest method.
+//    req, resp := client.CompleteMultipartUploadRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CompleteMultipartUpload
+func (c *S3) CompleteMultipartUploadRequest(input *CompleteMultipartUploadInput) (req *request.Request, output *CompleteMultipartUploadOutput) {
+        op := &request.Operation{
+                Name:       opCompleteMultipartUpload,
+                HTTPMethod: "POST",
+                HTTPPath:   "/{Bucket}/{Key+}",
+        }
+
+        if input == nil {
+                input = &CompleteMultipartUploadInput{}
+        }
+
+        output = &CompleteMultipartUploadOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// CompleteMultipartUpload API operation for Amazon Simple Storage Service.
+//
+// Completes a multipart upload by assembling previously uploaded parts.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation CompleteMultipartUpload for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CompleteMultipartUpload
+func (c *S3) CompleteMultipartUpload(input *CompleteMultipartUploadInput) (*CompleteMultipartUploadOutput, error) {
+        req, out := c.CompleteMultipartUploadRequest(input)
+        return out, req.Send()
+}
+
+// CompleteMultipartUploadWithContext is the same as CompleteMultipartUpload with the addition of
+// the ability to pass a context and additional request options.
+//
+// See CompleteMultipartUpload for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) CompleteMultipartUploadWithContext(ctx aws.Context, input *CompleteMultipartUploadInput, opts ...request.Option) (*CompleteMultipartUploadOutput, error) {
+        req, out := c.CompleteMultipartUploadRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opCopyObject = "CopyObject"
+
+// CopyObjectRequest generates a "aws/request.Request" representing the
+// client's request for the CopyObject operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See CopyObject for usage and error information.
+//
+// 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 CopyObject method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the CopyObjectRequest method.
+//    req, resp := client.CopyObjectRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CopyObject
+func (c *S3) CopyObjectRequest(input *CopyObjectInput) (req *request.Request, output *CopyObjectOutput) {
+        op := &request.Operation{
+                Name:       opCopyObject,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}/{Key+}",
+        }
+
+        if input == nil {
+                input = &CopyObjectInput{}
+        }
+
+        output = &CopyObjectOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// CopyObject API operation for Amazon Simple Storage Service.
+//
+// Creates a copy of an object that is already stored in Amazon S3.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation CopyObject for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeObjectNotInActiveTierError "ObjectNotInActiveTierError"
+//   The source object of the COPY operation is not in the active tier and is
+//   only stored in Amazon Glacier.
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CopyObject
+func (c *S3) CopyObject(input *CopyObjectInput) (*CopyObjectOutput, error) {
+        req, out := c.CopyObjectRequest(input)
+        return out, req.Send()
+}
+
+// CopyObjectWithContext is the same as CopyObject with the addition of
+// the ability to pass a context and additional request options.
+//
+// See CopyObject for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) CopyObjectWithContext(ctx aws.Context, input *CopyObjectInput, opts ...request.Option) (*CopyObjectOutput, error) {
+        req, out := c.CopyObjectRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opCreateBucket = "CreateBucket"
+
+// CreateBucketRequest generates a "aws/request.Request" representing the
+// client's request for the CreateBucket operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See CreateBucket for usage and error information.
+//
+// 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 CreateBucket method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the CreateBucketRequest method.
+//    req, resp := client.CreateBucketRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CreateBucket
+func (c *S3) CreateBucketRequest(input *CreateBucketInput) (req *request.Request, output *CreateBucketOutput) {
+        op := &request.Operation{
+                Name:       opCreateBucket,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}",
+        }
+
+        if input == nil {
+                input = &CreateBucketInput{}
+        }
+
+        output = &CreateBucketOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// CreateBucket API operation for Amazon Simple Storage Service.
+//
+// Creates a new bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation CreateBucket for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeBucketAlreadyExists "BucketAlreadyExists"
+//   The requested bucket name is not available. The bucket namespace is shared
+//   by all users of the system. Please select a different name and try again.
+//
+//   * ErrCodeBucketAlreadyOwnedByYou "BucketAlreadyOwnedByYou"
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CreateBucket
+func (c *S3) CreateBucket(input *CreateBucketInput) (*CreateBucketOutput, error) {
+        req, out := c.CreateBucketRequest(input)
+        return out, req.Send()
+}
+
+// CreateBucketWithContext is the same as CreateBucket with the addition of
+// the ability to pass a context and additional request options.
+//
+// See CreateBucket for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) CreateBucketWithContext(ctx aws.Context, input *CreateBucketInput, opts ...request.Option) (*CreateBucketOutput, error) {
+        req, out := c.CreateBucketRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opCreateMultipartUpload = "CreateMultipartUpload"
+
+// CreateMultipartUploadRequest generates a "aws/request.Request" representing the
+// client's request for the CreateMultipartUpload operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See CreateMultipartUpload for usage and error information.
+//
+// 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 CreateMultipartUpload method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the CreateMultipartUploadRequest method.
+//    req, resp := client.CreateMultipartUploadRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CreateMultipartUpload
+func (c *S3) CreateMultipartUploadRequest(input *CreateMultipartUploadInput) (req *request.Request, output *CreateMultipartUploadOutput) {
+        op := &request.Operation{
+                Name:       opCreateMultipartUpload,
+                HTTPMethod: "POST",
+                HTTPPath:   "/{Bucket}/{Key+}?uploads",
+        }
+
+        if input == nil {
+                input = &CreateMultipartUploadInput{}
+        }
+
+        output = &CreateMultipartUploadOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// CreateMultipartUpload API operation for Amazon Simple Storage Service.
+//
+// Initiates a multipart upload and returns an upload ID.
+//
+// Note: After you initiate multipart upload and upload one or more parts, you
+// must either complete or abort multipart upload in order to stop getting charged
+// for storage of the uploaded parts. Only after you either complete or abort
+// multipart upload, Amazon S3 frees up the parts storage and stops charging
+// you for the parts storage.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation CreateMultipartUpload for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CreateMultipartUpload
+func (c *S3) CreateMultipartUpload(input *CreateMultipartUploadInput) (*CreateMultipartUploadOutput, error) {
+        req, out := c.CreateMultipartUploadRequest(input)
+        return out, req.Send()
+}
+
+// CreateMultipartUploadWithContext is the same as CreateMultipartUpload with the addition of
+// the ability to pass a context and additional request options.
+//
+// See CreateMultipartUpload for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) CreateMultipartUploadWithContext(ctx aws.Context, input *CreateMultipartUploadInput, opts ...request.Option) (*CreateMultipartUploadOutput, error) {
+        req, out := c.CreateMultipartUploadRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opDeleteBucket = "DeleteBucket"
+
+// DeleteBucketRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteBucket operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See DeleteBucket for usage and error information.
+//
+// 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 DeleteBucket method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the DeleteBucketRequest method.
+//    req, resp := client.DeleteBucketRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucket
+func (c *S3) DeleteBucketRequest(input *DeleteBucketInput) (req *request.Request, output *DeleteBucketOutput) {
+        op := &request.Operation{
+                Name:       opDeleteBucket,
+                HTTPMethod: "DELETE",
+                HTTPPath:   "/{Bucket}",
+        }
+
+        if input == nil {
+                input = &DeleteBucketInput{}
+        }
+
+        output = &DeleteBucketOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// DeleteBucket API operation for Amazon Simple Storage Service.
+//
+// Deletes the bucket. All objects (including all object versions and Delete
+// Markers) in the bucket must be deleted before the bucket itself can be deleted.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation DeleteBucket for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucket
+func (c *S3) DeleteBucket(input *DeleteBucketInput) (*DeleteBucketOutput, error) {
+        req, out := c.DeleteBucketRequest(input)
+        return out, req.Send()
+}
+
+// DeleteBucketWithContext is the same as DeleteBucket with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteBucket for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) DeleteBucketWithContext(ctx aws.Context, input *DeleteBucketInput, opts ...request.Option) (*DeleteBucketOutput, error) {
+        req, out := c.DeleteBucketRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opDeleteBucketAnalyticsConfiguration = "DeleteBucketAnalyticsConfiguration"
+
+// DeleteBucketAnalyticsConfigurationRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteBucketAnalyticsConfiguration operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See DeleteBucketAnalyticsConfiguration for usage and error information.
+//
+// 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 DeleteBucketAnalyticsConfiguration method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the DeleteBucketAnalyticsConfigurationRequest method.
+//    req, resp := client.DeleteBucketAnalyticsConfigurationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketAnalyticsConfiguration
+func (c *S3) DeleteBucketAnalyticsConfigurationRequest(input *DeleteBucketAnalyticsConfigurationInput) (req *request.Request, output *DeleteBucketAnalyticsConfigurationOutput) {
+        op := &request.Operation{
+                Name:       opDeleteBucketAnalyticsConfiguration,
+                HTTPMethod: "DELETE",
+                HTTPPath:   "/{Bucket}?analytics",
+        }
+
+        if input == nil {
+                input = &DeleteBucketAnalyticsConfigurationInput{}
+        }
+
+        output = &DeleteBucketAnalyticsConfigurationOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// DeleteBucketAnalyticsConfiguration API operation for Amazon Simple Storage Service.
+//
+// Deletes an analytics configuration for the bucket (specified by the analytics
+// configuration ID).
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation DeleteBucketAnalyticsConfiguration for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketAnalyticsConfiguration
+func (c *S3) DeleteBucketAnalyticsConfiguration(input *DeleteBucketAnalyticsConfigurationInput) (*DeleteBucketAnalyticsConfigurationOutput, error) {
+        req, out := c.DeleteBucketAnalyticsConfigurationRequest(input)
+        return out, req.Send()
+}
+
+// DeleteBucketAnalyticsConfigurationWithContext is the same as DeleteBucketAnalyticsConfiguration with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteBucketAnalyticsConfiguration for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) DeleteBucketAnalyticsConfigurationWithContext(ctx aws.Context, input *DeleteBucketAnalyticsConfigurationInput, opts ...request.Option) (*DeleteBucketAnalyticsConfigurationOutput, error) {
+        req, out := c.DeleteBucketAnalyticsConfigurationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opDeleteBucketCors = "DeleteBucketCors"
+
+// DeleteBucketCorsRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteBucketCors operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See DeleteBucketCors for usage and error information.
+//
+// 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 DeleteBucketCors method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the DeleteBucketCorsRequest method.
+//    req, resp := client.DeleteBucketCorsRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketCors
+func (c *S3) DeleteBucketCorsRequest(input *DeleteBucketCorsInput) (req *request.Request, output *DeleteBucketCorsOutput) {
+        op := &request.Operation{
+                Name:       opDeleteBucketCors,
+                HTTPMethod: "DELETE",
+                HTTPPath:   "/{Bucket}?cors",
+        }
+
+        if input == nil {
+                input = &DeleteBucketCorsInput{}
+        }
+
+        output = &DeleteBucketCorsOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// DeleteBucketCors API operation for Amazon Simple Storage Service.
+//
+// Deletes the cors configuration information set for the bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation DeleteBucketCors for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketCors
+func (c *S3) DeleteBucketCors(input *DeleteBucketCorsInput) (*DeleteBucketCorsOutput, error) {
+        req, out := c.DeleteBucketCorsRequest(input)
+        return out, req.Send()
+}
+
+// DeleteBucketCorsWithContext is the same as DeleteBucketCors with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteBucketCors for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) DeleteBucketCorsWithContext(ctx aws.Context, input *DeleteBucketCorsInput, opts ...request.Option) (*DeleteBucketCorsOutput, error) {
+        req, out := c.DeleteBucketCorsRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opDeleteBucketInventoryConfiguration = "DeleteBucketInventoryConfiguration"
+
+// DeleteBucketInventoryConfigurationRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteBucketInventoryConfiguration operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See DeleteBucketInventoryConfiguration for usage and error information.
+//
+// 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 DeleteBucketInventoryConfiguration method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the DeleteBucketInventoryConfigurationRequest method.
+//    req, resp := client.DeleteBucketInventoryConfigurationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketInventoryConfiguration
+func (c *S3) DeleteBucketInventoryConfigurationRequest(input *DeleteBucketInventoryConfigurationInput) (req *request.Request, output *DeleteBucketInventoryConfigurationOutput) {
+        op := &request.Operation{
+                Name:       opDeleteBucketInventoryConfiguration,
+                HTTPMethod: "DELETE",
+                HTTPPath:   "/{Bucket}?inventory",
+        }
+
+        if input == nil {
+                input = &DeleteBucketInventoryConfigurationInput{}
+        }
+
+        output = &DeleteBucketInventoryConfigurationOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// DeleteBucketInventoryConfiguration API operation for Amazon Simple Storage Service.
+//
+// Deletes an inventory configuration (identified by the inventory ID) from
+// the bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation DeleteBucketInventoryConfiguration for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketInventoryConfiguration
+func (c *S3) DeleteBucketInventoryConfiguration(input *DeleteBucketInventoryConfigurationInput) (*DeleteBucketInventoryConfigurationOutput, error) {
+        req, out := c.DeleteBucketInventoryConfigurationRequest(input)
+        return out, req.Send()
+}
+
+// DeleteBucketInventoryConfigurationWithContext is the same as DeleteBucketInventoryConfiguration with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteBucketInventoryConfiguration for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) DeleteBucketInventoryConfigurationWithContext(ctx aws.Context, input *DeleteBucketInventoryConfigurationInput, opts ...request.Option) (*DeleteBucketInventoryConfigurationOutput, error) {
+        req, out := c.DeleteBucketInventoryConfigurationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opDeleteBucketLifecycle = "DeleteBucketLifecycle"
+
+// DeleteBucketLifecycleRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteBucketLifecycle operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See DeleteBucketLifecycle for usage and error information.
+//
+// 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 DeleteBucketLifecycle method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the DeleteBucketLifecycleRequest method.
+//    req, resp := client.DeleteBucketLifecycleRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketLifecycle
+func (c *S3) DeleteBucketLifecycleRequest(input *DeleteBucketLifecycleInput) (req *request.Request, output *DeleteBucketLifecycleOutput) {
+        op := &request.Operation{
+                Name:       opDeleteBucketLifecycle,
+                HTTPMethod: "DELETE",
+                HTTPPath:   "/{Bucket}?lifecycle",
+        }
+
+        if input == nil {
+                input = &DeleteBucketLifecycleInput{}
+        }
+
+        output = &DeleteBucketLifecycleOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// DeleteBucketLifecycle API operation for Amazon Simple Storage Service.
+//
+// Deletes the lifecycle configuration from the bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation DeleteBucketLifecycle for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketLifecycle
+func (c *S3) DeleteBucketLifecycle(input *DeleteBucketLifecycleInput) (*DeleteBucketLifecycleOutput, error) {
+        req, out := c.DeleteBucketLifecycleRequest(input)
+        return out, req.Send()
+}
+
+// DeleteBucketLifecycleWithContext is the same as DeleteBucketLifecycle with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteBucketLifecycle for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) DeleteBucketLifecycleWithContext(ctx aws.Context, input *DeleteBucketLifecycleInput, opts ...request.Option) (*DeleteBucketLifecycleOutput, error) {
+        req, out := c.DeleteBucketLifecycleRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opDeleteBucketMetricsConfiguration = "DeleteBucketMetricsConfiguration"
+
+// DeleteBucketMetricsConfigurationRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteBucketMetricsConfiguration operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See DeleteBucketMetricsConfiguration for usage and error information.
+//
+// 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 DeleteBucketMetricsConfiguration method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the DeleteBucketMetricsConfigurationRequest method.
+//    req, resp := client.DeleteBucketMetricsConfigurationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketMetricsConfiguration
+func (c *S3) DeleteBucketMetricsConfigurationRequest(input *DeleteBucketMetricsConfigurationInput) (req *request.Request, output *DeleteBucketMetricsConfigurationOutput) {
+        op := &request.Operation{
+                Name:       opDeleteBucketMetricsConfiguration,
+                HTTPMethod: "DELETE",
+                HTTPPath:   "/{Bucket}?metrics",
+        }
+
+        if input == nil {
+                input = &DeleteBucketMetricsConfigurationInput{}
+        }
+
+        output = &DeleteBucketMetricsConfigurationOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// DeleteBucketMetricsConfiguration API operation for Amazon Simple Storage Service.
+//
+// Deletes a metrics configuration (specified by the metrics configuration ID)
+// from the bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation DeleteBucketMetricsConfiguration for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketMetricsConfiguration
+func (c *S3) DeleteBucketMetricsConfiguration(input *DeleteBucketMetricsConfigurationInput) (*DeleteBucketMetricsConfigurationOutput, error) {
+        req, out := c.DeleteBucketMetricsConfigurationRequest(input)
+        return out, req.Send()
+}
+
+// DeleteBucketMetricsConfigurationWithContext is the same as DeleteBucketMetricsConfiguration with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteBucketMetricsConfiguration for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) DeleteBucketMetricsConfigurationWithContext(ctx aws.Context, input *DeleteBucketMetricsConfigurationInput, opts ...request.Option) (*DeleteBucketMetricsConfigurationOutput, error) {
+        req, out := c.DeleteBucketMetricsConfigurationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opDeleteBucketPolicy = "DeleteBucketPolicy"
+
+// DeleteBucketPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteBucketPolicy operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See DeleteBucketPolicy for usage and error information.
+//
+// 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 DeleteBucketPolicy method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the DeleteBucketPolicyRequest method.
+//    req, resp := client.DeleteBucketPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketPolicy
+func (c *S3) DeleteBucketPolicyRequest(input *DeleteBucketPolicyInput) (req *request.Request, output *DeleteBucketPolicyOutput) {
+        op := &request.Operation{
+                Name:       opDeleteBucketPolicy,
+                HTTPMethod: "DELETE",
+                HTTPPath:   "/{Bucket}?policy",
+        }
+
+        if input == nil {
+                input = &DeleteBucketPolicyInput{}
+        }
+
+        output = &DeleteBucketPolicyOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// DeleteBucketPolicy API operation for Amazon Simple Storage Service.
+//
+// Deletes the policy from the bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation DeleteBucketPolicy for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketPolicy
+func (c *S3) DeleteBucketPolicy(input *DeleteBucketPolicyInput) (*DeleteBucketPolicyOutput, error) {
+        req, out := c.DeleteBucketPolicyRequest(input)
+        return out, req.Send()
+}
+
+// DeleteBucketPolicyWithContext is the same as DeleteBucketPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteBucketPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) DeleteBucketPolicyWithContext(ctx aws.Context, input *DeleteBucketPolicyInput, opts ...request.Option) (*DeleteBucketPolicyOutput, error) {
+        req, out := c.DeleteBucketPolicyRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opDeleteBucketReplication = "DeleteBucketReplication"
+
+// DeleteBucketReplicationRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteBucketReplication operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See DeleteBucketReplication for usage and error information.
+//
+// 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 DeleteBucketReplication method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the DeleteBucketReplicationRequest method.
+//    req, resp := client.DeleteBucketReplicationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketReplication
+func (c *S3) DeleteBucketReplicationRequest(input *DeleteBucketReplicationInput) (req *request.Request, output *DeleteBucketReplicationOutput) {
+        op := &request.Operation{
+                Name:       opDeleteBucketReplication,
+                HTTPMethod: "DELETE",
+                HTTPPath:   "/{Bucket}?replication",
+        }
+
+        if input == nil {
+                input = &DeleteBucketReplicationInput{}
+        }
+
+        output = &DeleteBucketReplicationOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// DeleteBucketReplication API operation for Amazon Simple Storage Service.
+//
+// Deletes the replication configuration from the bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation DeleteBucketReplication for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketReplication
+func (c *S3) DeleteBucketReplication(input *DeleteBucketReplicationInput) (*DeleteBucketReplicationOutput, error) {
+        req, out := c.DeleteBucketReplicationRequest(input)
+        return out, req.Send()
+}
+
+// DeleteBucketReplicationWithContext is the same as DeleteBucketReplication with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteBucketReplication for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) DeleteBucketReplicationWithContext(ctx aws.Context, input *DeleteBucketReplicationInput, opts ...request.Option) (*DeleteBucketReplicationOutput, error) {
+        req, out := c.DeleteBucketReplicationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opDeleteBucketTagging = "DeleteBucketTagging"
+
+// DeleteBucketTaggingRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteBucketTagging operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See DeleteBucketTagging for usage and error information.
+//
+// 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 DeleteBucketTagging method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the DeleteBucketTaggingRequest method.
+//    req, resp := client.DeleteBucketTaggingRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketTagging
+func (c *S3) DeleteBucketTaggingRequest(input *DeleteBucketTaggingInput) (req *request.Request, output *DeleteBucketTaggingOutput) {
+        op := &request.Operation{
+                Name:       opDeleteBucketTagging,
+                HTTPMethod: "DELETE",
+                HTTPPath:   "/{Bucket}?tagging",
+        }
+
+        if input == nil {
+                input = &DeleteBucketTaggingInput{}
+        }
+
+        output = &DeleteBucketTaggingOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// DeleteBucketTagging API operation for Amazon Simple Storage Service.
+//
+// Deletes the tags from the bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation DeleteBucketTagging for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketTagging
+func (c *S3) DeleteBucketTagging(input *DeleteBucketTaggingInput) (*DeleteBucketTaggingOutput, error) {
+        req, out := c.DeleteBucketTaggingRequest(input)
+        return out, req.Send()
+}
+
+// DeleteBucketTaggingWithContext is the same as DeleteBucketTagging with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteBucketTagging for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) DeleteBucketTaggingWithContext(ctx aws.Context, input *DeleteBucketTaggingInput, opts ...request.Option) (*DeleteBucketTaggingOutput, error) {
+        req, out := c.DeleteBucketTaggingRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opDeleteBucketWebsite = "DeleteBucketWebsite"
+
+// DeleteBucketWebsiteRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteBucketWebsite operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See DeleteBucketWebsite for usage and error information.
+//
+// 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 DeleteBucketWebsite method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the DeleteBucketWebsiteRequest method.
+//    req, resp := client.DeleteBucketWebsiteRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketWebsite
+func (c *S3) DeleteBucketWebsiteRequest(input *DeleteBucketWebsiteInput) (req *request.Request, output *DeleteBucketWebsiteOutput) {
+        op := &request.Operation{
+                Name:       opDeleteBucketWebsite,
+                HTTPMethod: "DELETE",
+                HTTPPath:   "/{Bucket}?website",
+        }
+
+        if input == nil {
+                input = &DeleteBucketWebsiteInput{}
+        }
+
+        output = &DeleteBucketWebsiteOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// DeleteBucketWebsite API operation for Amazon Simple Storage Service.
+//
+// This operation removes the website configuration from the bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation DeleteBucketWebsite for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketWebsite
+func (c *S3) DeleteBucketWebsite(input *DeleteBucketWebsiteInput) (*DeleteBucketWebsiteOutput, error) {
+        req, out := c.DeleteBucketWebsiteRequest(input)
+        return out, req.Send()
+}
+
+// DeleteBucketWebsiteWithContext is the same as DeleteBucketWebsite with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteBucketWebsite for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) DeleteBucketWebsiteWithContext(ctx aws.Context, input *DeleteBucketWebsiteInput, opts ...request.Option) (*DeleteBucketWebsiteOutput, error) {
+        req, out := c.DeleteBucketWebsiteRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opDeleteObject = "DeleteObject"
+
+// DeleteObjectRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteObject operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See DeleteObject for usage and error information.
+//
+// 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 DeleteObject method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the DeleteObjectRequest method.
+//    req, resp := client.DeleteObjectRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteObject
+func (c *S3) DeleteObjectRequest(input *DeleteObjectInput) (req *request.Request, output *DeleteObjectOutput) {
+        op := &request.Operation{
+                Name:       opDeleteObject,
+                HTTPMethod: "DELETE",
+                HTTPPath:   "/{Bucket}/{Key+}",
+        }
+
+        if input == nil {
+                input = &DeleteObjectInput{}
+        }
+
+        output = &DeleteObjectOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// DeleteObject API operation for Amazon Simple Storage Service.
+//
+// Removes the null version (if there is one) of an object and inserts a delete
+// marker, which becomes the latest version of the object. If there isn't a
+// null version, Amazon S3 does not remove any objects.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation DeleteObject for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteObject
+func (c *S3) DeleteObject(input *DeleteObjectInput) (*DeleteObjectOutput, error) {
+        req, out := c.DeleteObjectRequest(input)
+        return out, req.Send()
+}
+
+// DeleteObjectWithContext is the same as DeleteObject with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteObject for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) DeleteObjectWithContext(ctx aws.Context, input *DeleteObjectInput, opts ...request.Option) (*DeleteObjectOutput, error) {
+        req, out := c.DeleteObjectRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opDeleteObjectTagging = "DeleteObjectTagging"
+
+// DeleteObjectTaggingRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteObjectTagging operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See DeleteObjectTagging for usage and error information.
+//
+// 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 DeleteObjectTagging method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the DeleteObjectTaggingRequest method.
+//    req, resp := client.DeleteObjectTaggingRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteObjectTagging
+func (c *S3) DeleteObjectTaggingRequest(input *DeleteObjectTaggingInput) (req *request.Request, output *DeleteObjectTaggingOutput) {
+        op := &request.Operation{
+                Name:       opDeleteObjectTagging,
+                HTTPMethod: "DELETE",
+                HTTPPath:   "/{Bucket}/{Key+}?tagging",
+        }
+
+        if input == nil {
+                input = &DeleteObjectTaggingInput{}
+        }
+
+        output = &DeleteObjectTaggingOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// DeleteObjectTagging API operation for Amazon Simple Storage Service.
+//
+// Removes the tag-set from an existing object.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation DeleteObjectTagging for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteObjectTagging
+func (c *S3) DeleteObjectTagging(input *DeleteObjectTaggingInput) (*DeleteObjectTaggingOutput, error) {
+        req, out := c.DeleteObjectTaggingRequest(input)
+        return out, req.Send()
+}
+
+// DeleteObjectTaggingWithContext is the same as DeleteObjectTagging with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteObjectTagging for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) DeleteObjectTaggingWithContext(ctx aws.Context, input *DeleteObjectTaggingInput, opts ...request.Option) (*DeleteObjectTaggingOutput, error) {
+        req, out := c.DeleteObjectTaggingRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opDeleteObjects = "DeleteObjects"
+
+// DeleteObjectsRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteObjects operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See DeleteObjects for usage and error information.
+//
+// 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 DeleteObjects method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the DeleteObjectsRequest method.
+//    req, resp := client.DeleteObjectsRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteObjects
+func (c *S3) DeleteObjectsRequest(input *DeleteObjectsInput) (req *request.Request, output *DeleteObjectsOutput) {
+        op := &request.Operation{
+                Name:       opDeleteObjects,
+                HTTPMethod: "POST",
+                HTTPPath:   "/{Bucket}?delete",
+        }
+
+        if input == nil {
+                input = &DeleteObjectsInput{}
+        }
+
+        output = &DeleteObjectsOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// DeleteObjects API operation for Amazon Simple Storage Service.
+//
+// This operation enables you to delete multiple objects from a bucket using
+// a single HTTP request. You may specify up to 1000 keys.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation DeleteObjects for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteObjects
+func (c *S3) DeleteObjects(input *DeleteObjectsInput) (*DeleteObjectsOutput, error) {
+        req, out := c.DeleteObjectsRequest(input)
+        return out, req.Send()
+}
+
+// DeleteObjectsWithContext is the same as DeleteObjects with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteObjects for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) DeleteObjectsWithContext(ctx aws.Context, input *DeleteObjectsInput, opts ...request.Option) (*DeleteObjectsOutput, error) {
+        req, out := c.DeleteObjectsRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetBucketAccelerateConfiguration = "GetBucketAccelerateConfiguration"
+
+// GetBucketAccelerateConfigurationRequest generates a "aws/request.Request" representing the
+// client's request for the GetBucketAccelerateConfiguration operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetBucketAccelerateConfiguration for usage and error information.
+//
+// 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 GetBucketAccelerateConfiguration method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetBucketAccelerateConfigurationRequest method.
+//    req, resp := client.GetBucketAccelerateConfigurationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketAccelerateConfiguration
+func (c *S3) GetBucketAccelerateConfigurationRequest(input *GetBucketAccelerateConfigurationInput) (req *request.Request, output *GetBucketAccelerateConfigurationOutput) {
+        op := &request.Operation{
+                Name:       opGetBucketAccelerateConfiguration,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?accelerate",
+        }
+
+        if input == nil {
+                input = &GetBucketAccelerateConfigurationInput{}
+        }
+
+        output = &GetBucketAccelerateConfigurationOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetBucketAccelerateConfiguration API operation for Amazon Simple Storage Service.
+//
+// Returns the accelerate configuration of a bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetBucketAccelerateConfiguration for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketAccelerateConfiguration
+func (c *S3) GetBucketAccelerateConfiguration(input *GetBucketAccelerateConfigurationInput) (*GetBucketAccelerateConfigurationOutput, error) {
+        req, out := c.GetBucketAccelerateConfigurationRequest(input)
+        return out, req.Send()
+}
+
+// GetBucketAccelerateConfigurationWithContext is the same as GetBucketAccelerateConfiguration with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetBucketAccelerateConfiguration for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetBucketAccelerateConfigurationWithContext(ctx aws.Context, input *GetBucketAccelerateConfigurationInput, opts ...request.Option) (*GetBucketAccelerateConfigurationOutput, error) {
+        req, out := c.GetBucketAccelerateConfigurationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetBucketAcl = "GetBucketAcl"
+
+// GetBucketAclRequest generates a "aws/request.Request" representing the
+// client's request for the GetBucketAcl operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetBucketAcl for usage and error information.
+//
+// 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 GetBucketAcl method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetBucketAclRequest method.
+//    req, resp := client.GetBucketAclRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketAcl
+func (c *S3) GetBucketAclRequest(input *GetBucketAclInput) (req *request.Request, output *GetBucketAclOutput) {
+        op := &request.Operation{
+                Name:       opGetBucketAcl,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?acl",
+        }
+
+        if input == nil {
+                input = &GetBucketAclInput{}
+        }
+
+        output = &GetBucketAclOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetBucketAcl API operation for Amazon Simple Storage Service.
+//
+// Gets the access control policy for the bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetBucketAcl for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketAcl
+func (c *S3) GetBucketAcl(input *GetBucketAclInput) (*GetBucketAclOutput, error) {
+        req, out := c.GetBucketAclRequest(input)
+        return out, req.Send()
+}
+
+// GetBucketAclWithContext is the same as GetBucketAcl with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetBucketAcl for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetBucketAclWithContext(ctx aws.Context, input *GetBucketAclInput, opts ...request.Option) (*GetBucketAclOutput, error) {
+        req, out := c.GetBucketAclRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetBucketAnalyticsConfiguration = "GetBucketAnalyticsConfiguration"
+
+// GetBucketAnalyticsConfigurationRequest generates a "aws/request.Request" representing the
+// client's request for the GetBucketAnalyticsConfiguration operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetBucketAnalyticsConfiguration for usage and error information.
+//
+// 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 GetBucketAnalyticsConfiguration method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetBucketAnalyticsConfigurationRequest method.
+//    req, resp := client.GetBucketAnalyticsConfigurationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketAnalyticsConfiguration
+func (c *S3) GetBucketAnalyticsConfigurationRequest(input *GetBucketAnalyticsConfigurationInput) (req *request.Request, output *GetBucketAnalyticsConfigurationOutput) {
+        op := &request.Operation{
+                Name:       opGetBucketAnalyticsConfiguration,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?analytics",
+        }
+
+        if input == nil {
+                input = &GetBucketAnalyticsConfigurationInput{}
+        }
+
+        output = &GetBucketAnalyticsConfigurationOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetBucketAnalyticsConfiguration API operation for Amazon Simple Storage Service.
+//
+// Gets an analytics configuration for the bucket (specified by the analytics
+// configuration ID).
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetBucketAnalyticsConfiguration for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketAnalyticsConfiguration
+func (c *S3) GetBucketAnalyticsConfiguration(input *GetBucketAnalyticsConfigurationInput) (*GetBucketAnalyticsConfigurationOutput, error) {
+        req, out := c.GetBucketAnalyticsConfigurationRequest(input)
+        return out, req.Send()
+}
+
+// GetBucketAnalyticsConfigurationWithContext is the same as GetBucketAnalyticsConfiguration with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetBucketAnalyticsConfiguration for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetBucketAnalyticsConfigurationWithContext(ctx aws.Context, input *GetBucketAnalyticsConfigurationInput, opts ...request.Option) (*GetBucketAnalyticsConfigurationOutput, error) {
+        req, out := c.GetBucketAnalyticsConfigurationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetBucketCors = "GetBucketCors"
+
+// GetBucketCorsRequest generates a "aws/request.Request" representing the
+// client's request for the GetBucketCors operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetBucketCors for usage and error information.
+//
+// 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 GetBucketCors method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetBucketCorsRequest method.
+//    req, resp := client.GetBucketCorsRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketCors
+func (c *S3) GetBucketCorsRequest(input *GetBucketCorsInput) (req *request.Request, output *GetBucketCorsOutput) {
+        op := &request.Operation{
+                Name:       opGetBucketCors,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?cors",
+        }
+
+        if input == nil {
+                input = &GetBucketCorsInput{}
+        }
+
+        output = &GetBucketCorsOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetBucketCors API operation for Amazon Simple Storage Service.
+//
+// Returns the cors configuration for the bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetBucketCors for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketCors
+func (c *S3) GetBucketCors(input *GetBucketCorsInput) (*GetBucketCorsOutput, error) {
+        req, out := c.GetBucketCorsRequest(input)
+        return out, req.Send()
+}
+
+// GetBucketCorsWithContext is the same as GetBucketCors with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetBucketCors for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetBucketCorsWithContext(ctx aws.Context, input *GetBucketCorsInput, opts ...request.Option) (*GetBucketCorsOutput, error) {
+        req, out := c.GetBucketCorsRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetBucketInventoryConfiguration = "GetBucketInventoryConfiguration"
+
+// GetBucketInventoryConfigurationRequest generates a "aws/request.Request" representing the
+// client's request for the GetBucketInventoryConfiguration operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetBucketInventoryConfiguration for usage and error information.
+//
+// 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 GetBucketInventoryConfiguration method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetBucketInventoryConfigurationRequest method.
+//    req, resp := client.GetBucketInventoryConfigurationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketInventoryConfiguration
+func (c *S3) GetBucketInventoryConfigurationRequest(input *GetBucketInventoryConfigurationInput) (req *request.Request, output *GetBucketInventoryConfigurationOutput) {
+        op := &request.Operation{
+                Name:       opGetBucketInventoryConfiguration,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?inventory",
+        }
+
+        if input == nil {
+                input = &GetBucketInventoryConfigurationInput{}
+        }
+
+        output = &GetBucketInventoryConfigurationOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetBucketInventoryConfiguration API operation for Amazon Simple Storage Service.
+//
+// Returns an inventory configuration (identified by the inventory ID) from
+// the bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetBucketInventoryConfiguration for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketInventoryConfiguration
+func (c *S3) GetBucketInventoryConfiguration(input *GetBucketInventoryConfigurationInput) (*GetBucketInventoryConfigurationOutput, error) {
+        req, out := c.GetBucketInventoryConfigurationRequest(input)
+        return out, req.Send()
+}
+
+// GetBucketInventoryConfigurationWithContext is the same as GetBucketInventoryConfiguration with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetBucketInventoryConfiguration for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetBucketInventoryConfigurationWithContext(ctx aws.Context, input *GetBucketInventoryConfigurationInput, opts ...request.Option) (*GetBucketInventoryConfigurationOutput, error) {
+        req, out := c.GetBucketInventoryConfigurationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetBucketLifecycle = "GetBucketLifecycle"
+
+// GetBucketLifecycleRequest generates a "aws/request.Request" representing the
+// client's request for the GetBucketLifecycle operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetBucketLifecycle for usage and error information.
+//
+// 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 GetBucketLifecycle method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetBucketLifecycleRequest method.
+//    req, resp := client.GetBucketLifecycleRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLifecycle
+func (c *S3) GetBucketLifecycleRequest(input *GetBucketLifecycleInput) (req *request.Request, output *GetBucketLifecycleOutput) {
+        if c.Client.Config.Logger != nil {
+                c.Client.Config.Logger.Log("This operation, GetBucketLifecycle, has been deprecated")
+        }
+        op := &request.Operation{
+                Name:       opGetBucketLifecycle,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?lifecycle",
+        }
+
+        if input == nil {
+                input = &GetBucketLifecycleInput{}
+        }
+
+        output = &GetBucketLifecycleOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetBucketLifecycle API operation for Amazon Simple Storage Service.
+//
+// Deprecated, see the GetBucketLifecycleConfiguration operation.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetBucketLifecycle for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLifecycle
+func (c *S3) GetBucketLifecycle(input *GetBucketLifecycleInput) (*GetBucketLifecycleOutput, error) {
+        req, out := c.GetBucketLifecycleRequest(input)
+        return out, req.Send()
+}
+
+// GetBucketLifecycleWithContext is the same as GetBucketLifecycle with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetBucketLifecycle for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetBucketLifecycleWithContext(ctx aws.Context, input *GetBucketLifecycleInput, opts ...request.Option) (*GetBucketLifecycleOutput, error) {
+        req, out := c.GetBucketLifecycleRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetBucketLifecycleConfiguration = "GetBucketLifecycleConfiguration"
+
+// GetBucketLifecycleConfigurationRequest generates a "aws/request.Request" representing the
+// client's request for the GetBucketLifecycleConfiguration operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetBucketLifecycleConfiguration for usage and error information.
+//
+// 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 GetBucketLifecycleConfiguration method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetBucketLifecycleConfigurationRequest method.
+//    req, resp := client.GetBucketLifecycleConfigurationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLifecycleConfiguration
+func (c *S3) GetBucketLifecycleConfigurationRequest(input *GetBucketLifecycleConfigurationInput) (req *request.Request, output *GetBucketLifecycleConfigurationOutput) {
+        op := &request.Operation{
+                Name:       opGetBucketLifecycleConfiguration,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?lifecycle",
+        }
+
+        if input == nil {
+                input = &GetBucketLifecycleConfigurationInput{}
+        }
+
+        output = &GetBucketLifecycleConfigurationOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetBucketLifecycleConfiguration API operation for Amazon Simple Storage Service.
+//
+// Returns the lifecycle configuration information set on the bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetBucketLifecycleConfiguration for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLifecycleConfiguration
+func (c *S3) GetBucketLifecycleConfiguration(input *GetBucketLifecycleConfigurationInput) (*GetBucketLifecycleConfigurationOutput, error) {
+        req, out := c.GetBucketLifecycleConfigurationRequest(input)
+        return out, req.Send()
+}
+
+// GetBucketLifecycleConfigurationWithContext is the same as GetBucketLifecycleConfiguration with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetBucketLifecycleConfiguration for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetBucketLifecycleConfigurationWithContext(ctx aws.Context, input *GetBucketLifecycleConfigurationInput, opts ...request.Option) (*GetBucketLifecycleConfigurationOutput, error) {
+        req, out := c.GetBucketLifecycleConfigurationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetBucketLocation = "GetBucketLocation"
+
+// GetBucketLocationRequest generates a "aws/request.Request" representing the
+// client's request for the GetBucketLocation operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetBucketLocation for usage and error information.
+//
+// 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 GetBucketLocation method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetBucketLocationRequest method.
+//    req, resp := client.GetBucketLocationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLocation
+func (c *S3) GetBucketLocationRequest(input *GetBucketLocationInput) (req *request.Request, output *GetBucketLocationOutput) {
+        op := &request.Operation{
+                Name:       opGetBucketLocation,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?location",
+        }
+
+        if input == nil {
+                input = &GetBucketLocationInput{}
+        }
+
+        output = &GetBucketLocationOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetBucketLocation API operation for Amazon Simple Storage Service.
+//
+// Returns the region the bucket resides in.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetBucketLocation for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLocation
+func (c *S3) GetBucketLocation(input *GetBucketLocationInput) (*GetBucketLocationOutput, error) {
+        req, out := c.GetBucketLocationRequest(input)
+        return out, req.Send()
+}
+
+// GetBucketLocationWithContext is the same as GetBucketLocation with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetBucketLocation for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetBucketLocationWithContext(ctx aws.Context, input *GetBucketLocationInput, opts ...request.Option) (*GetBucketLocationOutput, error) {
+        req, out := c.GetBucketLocationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetBucketLogging = "GetBucketLogging"
+
+// GetBucketLoggingRequest generates a "aws/request.Request" representing the
+// client's request for the GetBucketLogging operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetBucketLogging for usage and error information.
+//
+// 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 GetBucketLogging method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetBucketLoggingRequest method.
+//    req, resp := client.GetBucketLoggingRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLogging
+func (c *S3) GetBucketLoggingRequest(input *GetBucketLoggingInput) (req *request.Request, output *GetBucketLoggingOutput) {
+        op := &request.Operation{
+                Name:       opGetBucketLogging,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?logging",
+        }
+
+        if input == nil {
+                input = &GetBucketLoggingInput{}
+        }
+
+        output = &GetBucketLoggingOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetBucketLogging API operation for Amazon Simple Storage Service.
+//
+// Returns the logging status of a bucket and the permissions users have to
+// view and modify that status. To use GET, you must be the bucket owner.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetBucketLogging for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLogging
+func (c *S3) GetBucketLogging(input *GetBucketLoggingInput) (*GetBucketLoggingOutput, error) {
+        req, out := c.GetBucketLoggingRequest(input)
+        return out, req.Send()
+}
+
+// GetBucketLoggingWithContext is the same as GetBucketLogging with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetBucketLogging for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetBucketLoggingWithContext(ctx aws.Context, input *GetBucketLoggingInput, opts ...request.Option) (*GetBucketLoggingOutput, error) {
+        req, out := c.GetBucketLoggingRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetBucketMetricsConfiguration = "GetBucketMetricsConfiguration"
+
+// GetBucketMetricsConfigurationRequest generates a "aws/request.Request" representing the
+// client's request for the GetBucketMetricsConfiguration operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetBucketMetricsConfiguration for usage and error information.
+//
+// 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 GetBucketMetricsConfiguration method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetBucketMetricsConfigurationRequest method.
+//    req, resp := client.GetBucketMetricsConfigurationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketMetricsConfiguration
+func (c *S3) GetBucketMetricsConfigurationRequest(input *GetBucketMetricsConfigurationInput) (req *request.Request, output *GetBucketMetricsConfigurationOutput) {
+        op := &request.Operation{
+                Name:       opGetBucketMetricsConfiguration,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?metrics",
+        }
+
+        if input == nil {
+                input = &GetBucketMetricsConfigurationInput{}
+        }
+
+        output = &GetBucketMetricsConfigurationOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetBucketMetricsConfiguration API operation for Amazon Simple Storage Service.
+//
+// Gets a metrics configuration (specified by the metrics configuration ID)
+// from the bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetBucketMetricsConfiguration for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketMetricsConfiguration
+func (c *S3) GetBucketMetricsConfiguration(input *GetBucketMetricsConfigurationInput) (*GetBucketMetricsConfigurationOutput, error) {
+        req, out := c.GetBucketMetricsConfigurationRequest(input)
+        return out, req.Send()
+}
+
+// GetBucketMetricsConfigurationWithContext is the same as GetBucketMetricsConfiguration with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetBucketMetricsConfiguration for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetBucketMetricsConfigurationWithContext(ctx aws.Context, input *GetBucketMetricsConfigurationInput, opts ...request.Option) (*GetBucketMetricsConfigurationOutput, error) {
+        req, out := c.GetBucketMetricsConfigurationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetBucketNotification = "GetBucketNotification"
+
+// GetBucketNotificationRequest generates a "aws/request.Request" representing the
+// client's request for the GetBucketNotification operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetBucketNotification for usage and error information.
+//
+// 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 GetBucketNotification method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetBucketNotificationRequest method.
+//    req, resp := client.GetBucketNotificationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketNotification
+func (c *S3) GetBucketNotificationRequest(input *GetBucketNotificationConfigurationRequest) (req *request.Request, output *NotificationConfigurationDeprecated) {
+        if c.Client.Config.Logger != nil {
+                c.Client.Config.Logger.Log("This operation, GetBucketNotification, has been deprecated")
+        }
+        op := &request.Operation{
+                Name:       opGetBucketNotification,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?notification",
+        }
+
+        if input == nil {
+                input = &GetBucketNotificationConfigurationRequest{}
+        }
+
+        output = &NotificationConfigurationDeprecated{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetBucketNotification API operation for Amazon Simple Storage Service.
+//
+// Deprecated, see the GetBucketNotificationConfiguration operation.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetBucketNotification for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketNotification
+func (c *S3) GetBucketNotification(input *GetBucketNotificationConfigurationRequest) (*NotificationConfigurationDeprecated, error) {
+        req, out := c.GetBucketNotificationRequest(input)
+        return out, req.Send()
+}
+
+// GetBucketNotificationWithContext is the same as GetBucketNotification with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetBucketNotification for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetBucketNotificationWithContext(ctx aws.Context, input *GetBucketNotificationConfigurationRequest, opts ...request.Option) (*NotificationConfigurationDeprecated, error) {
+        req, out := c.GetBucketNotificationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetBucketNotificationConfiguration = "GetBucketNotificationConfiguration"
+
+// GetBucketNotificationConfigurationRequest generates a "aws/request.Request" representing the
+// client's request for the GetBucketNotificationConfiguration operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetBucketNotificationConfiguration for usage and error information.
+//
+// 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 GetBucketNotificationConfiguration method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetBucketNotificationConfigurationRequest method.
+//    req, resp := client.GetBucketNotificationConfigurationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketNotificationConfiguration
+func (c *S3) GetBucketNotificationConfigurationRequest(input *GetBucketNotificationConfigurationRequest) (req *request.Request, output *NotificationConfiguration) {
+        op := &request.Operation{
+                Name:       opGetBucketNotificationConfiguration,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?notification",
+        }
+
+        if input == nil {
+                input = &GetBucketNotificationConfigurationRequest{}
+        }
+
+        output = &NotificationConfiguration{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetBucketNotificationConfiguration API operation for Amazon Simple Storage Service.
+//
+// Returns the notification configuration of a bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetBucketNotificationConfiguration for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketNotificationConfiguration
+func (c *S3) GetBucketNotificationConfiguration(input *GetBucketNotificationConfigurationRequest) (*NotificationConfiguration, error) {
+        req, out := c.GetBucketNotificationConfigurationRequest(input)
+        return out, req.Send()
+}
+
+// GetBucketNotificationConfigurationWithContext is the same as GetBucketNotificationConfiguration with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetBucketNotificationConfiguration for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetBucketNotificationConfigurationWithContext(ctx aws.Context, input *GetBucketNotificationConfigurationRequest, opts ...request.Option) (*NotificationConfiguration, error) {
+        req, out := c.GetBucketNotificationConfigurationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetBucketPolicy = "GetBucketPolicy"
+
+// GetBucketPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the GetBucketPolicy operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetBucketPolicy for usage and error information.
+//
+// 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 GetBucketPolicy method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetBucketPolicyRequest method.
+//    req, resp := client.GetBucketPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketPolicy
+func (c *S3) GetBucketPolicyRequest(input *GetBucketPolicyInput) (req *request.Request, output *GetBucketPolicyOutput) {
+        op := &request.Operation{
+                Name:       opGetBucketPolicy,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?policy",
+        }
+
+        if input == nil {
+                input = &GetBucketPolicyInput{}
+        }
+
+        output = &GetBucketPolicyOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetBucketPolicy API operation for Amazon Simple Storage Service.
+//
+// Returns the policy of a specified bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetBucketPolicy for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketPolicy
+func (c *S3) GetBucketPolicy(input *GetBucketPolicyInput) (*GetBucketPolicyOutput, error) {
+        req, out := c.GetBucketPolicyRequest(input)
+        return out, req.Send()
+}
+
+// GetBucketPolicyWithContext is the same as GetBucketPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetBucketPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetBucketPolicyWithContext(ctx aws.Context, input *GetBucketPolicyInput, opts ...request.Option) (*GetBucketPolicyOutput, error) {
+        req, out := c.GetBucketPolicyRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetBucketReplication = "GetBucketReplication"
+
+// GetBucketReplicationRequest generates a "aws/request.Request" representing the
+// client's request for the GetBucketReplication operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetBucketReplication for usage and error information.
+//
+// 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 GetBucketReplication method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetBucketReplicationRequest method.
+//    req, resp := client.GetBucketReplicationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketReplication
+func (c *S3) GetBucketReplicationRequest(input *GetBucketReplicationInput) (req *request.Request, output *GetBucketReplicationOutput) {
+        op := &request.Operation{
+                Name:       opGetBucketReplication,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?replication",
+        }
+
+        if input == nil {
+                input = &GetBucketReplicationInput{}
+        }
+
+        output = &GetBucketReplicationOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetBucketReplication API operation for Amazon Simple Storage Service.
+//
+// Returns the replication configuration of a bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetBucketReplication for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketReplication
+func (c *S3) GetBucketReplication(input *GetBucketReplicationInput) (*GetBucketReplicationOutput, error) {
+        req, out := c.GetBucketReplicationRequest(input)
+        return out, req.Send()
+}
+
+// GetBucketReplicationWithContext is the same as GetBucketReplication with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetBucketReplication for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetBucketReplicationWithContext(ctx aws.Context, input *GetBucketReplicationInput, opts ...request.Option) (*GetBucketReplicationOutput, error) {
+        req, out := c.GetBucketReplicationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetBucketRequestPayment = "GetBucketRequestPayment"
+
+// GetBucketRequestPaymentRequest generates a "aws/request.Request" representing the
+// client's request for the GetBucketRequestPayment operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetBucketRequestPayment for usage and error information.
+//
+// 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 GetBucketRequestPayment method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetBucketRequestPaymentRequest method.
+//    req, resp := client.GetBucketRequestPaymentRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketRequestPayment
+func (c *S3) GetBucketRequestPaymentRequest(input *GetBucketRequestPaymentInput) (req *request.Request, output *GetBucketRequestPaymentOutput) {
+        op := &request.Operation{
+                Name:       opGetBucketRequestPayment,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?requestPayment",
+        }
+
+        if input == nil {
+                input = &GetBucketRequestPaymentInput{}
+        }
+
+        output = &GetBucketRequestPaymentOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetBucketRequestPayment API operation for Amazon Simple Storage Service.
+//
+// Returns the request payment configuration of a bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetBucketRequestPayment for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketRequestPayment
+func (c *S3) GetBucketRequestPayment(input *GetBucketRequestPaymentInput) (*GetBucketRequestPaymentOutput, error) {
+        req, out := c.GetBucketRequestPaymentRequest(input)
+        return out, req.Send()
+}
+
+// GetBucketRequestPaymentWithContext is the same as GetBucketRequestPayment with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetBucketRequestPayment for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetBucketRequestPaymentWithContext(ctx aws.Context, input *GetBucketRequestPaymentInput, opts ...request.Option) (*GetBucketRequestPaymentOutput, error) {
+        req, out := c.GetBucketRequestPaymentRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetBucketTagging = "GetBucketTagging"
+
+// GetBucketTaggingRequest generates a "aws/request.Request" representing the
+// client's request for the GetBucketTagging operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetBucketTagging for usage and error information.
+//
+// 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 GetBucketTagging method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetBucketTaggingRequest method.
+//    req, resp := client.GetBucketTaggingRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketTagging
+func (c *S3) GetBucketTaggingRequest(input *GetBucketTaggingInput) (req *request.Request, output *GetBucketTaggingOutput) {
+        op := &request.Operation{
+                Name:       opGetBucketTagging,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?tagging",
+        }
+
+        if input == nil {
+                input = &GetBucketTaggingInput{}
+        }
+
+        output = &GetBucketTaggingOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetBucketTagging API operation for Amazon Simple Storage Service.
+//
+// Returns the tag set associated with the bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetBucketTagging for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketTagging
+func (c *S3) GetBucketTagging(input *GetBucketTaggingInput) (*GetBucketTaggingOutput, error) {
+        req, out := c.GetBucketTaggingRequest(input)
+        return out, req.Send()
+}
+
+// GetBucketTaggingWithContext is the same as GetBucketTagging with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetBucketTagging for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetBucketTaggingWithContext(ctx aws.Context, input *GetBucketTaggingInput, opts ...request.Option) (*GetBucketTaggingOutput, error) {
+        req, out := c.GetBucketTaggingRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetBucketVersioning = "GetBucketVersioning"
+
+// GetBucketVersioningRequest generates a "aws/request.Request" representing the
+// client's request for the GetBucketVersioning operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetBucketVersioning for usage and error information.
+//
+// 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 GetBucketVersioning method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetBucketVersioningRequest method.
+//    req, resp := client.GetBucketVersioningRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketVersioning
+func (c *S3) GetBucketVersioningRequest(input *GetBucketVersioningInput) (req *request.Request, output *GetBucketVersioningOutput) {
+        op := &request.Operation{
+                Name:       opGetBucketVersioning,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?versioning",
+        }
+
+        if input == nil {
+                input = &GetBucketVersioningInput{}
+        }
+
+        output = &GetBucketVersioningOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetBucketVersioning API operation for Amazon Simple Storage Service.
+//
+// Returns the versioning state of a bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetBucketVersioning for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketVersioning
+func (c *S3) GetBucketVersioning(input *GetBucketVersioningInput) (*GetBucketVersioningOutput, error) {
+        req, out := c.GetBucketVersioningRequest(input)
+        return out, req.Send()
+}
+
+// GetBucketVersioningWithContext is the same as GetBucketVersioning with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetBucketVersioning for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetBucketVersioningWithContext(ctx aws.Context, input *GetBucketVersioningInput, opts ...request.Option) (*GetBucketVersioningOutput, error) {
+        req, out := c.GetBucketVersioningRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetBucketWebsite = "GetBucketWebsite"
+
+// GetBucketWebsiteRequest generates a "aws/request.Request" representing the
+// client's request for the GetBucketWebsite operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetBucketWebsite for usage and error information.
+//
+// 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 GetBucketWebsite method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetBucketWebsiteRequest method.
+//    req, resp := client.GetBucketWebsiteRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketWebsite
+func (c *S3) GetBucketWebsiteRequest(input *GetBucketWebsiteInput) (req *request.Request, output *GetBucketWebsiteOutput) {
+        op := &request.Operation{
+                Name:       opGetBucketWebsite,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?website",
+        }
+
+        if input == nil {
+                input = &GetBucketWebsiteInput{}
+        }
+
+        output = &GetBucketWebsiteOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetBucketWebsite API operation for Amazon Simple Storage Service.
+//
+// Returns the website configuration for a bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetBucketWebsite for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketWebsite
+func (c *S3) GetBucketWebsite(input *GetBucketWebsiteInput) (*GetBucketWebsiteOutput, error) {
+        req, out := c.GetBucketWebsiteRequest(input)
+        return out, req.Send()
+}
+
+// GetBucketWebsiteWithContext is the same as GetBucketWebsite with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetBucketWebsite for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetBucketWebsiteWithContext(ctx aws.Context, input *GetBucketWebsiteInput, opts ...request.Option) (*GetBucketWebsiteOutput, error) {
+        req, out := c.GetBucketWebsiteRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetObject = "GetObject"
+
+// GetObjectRequest generates a "aws/request.Request" representing the
+// client's request for the GetObject operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetObject for usage and error information.
+//
+// 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 GetObject method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetObjectRequest method.
+//    req, resp := client.GetObjectRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObject
+func (c *S3) GetObjectRequest(input *GetObjectInput) (req *request.Request, output *GetObjectOutput) {
+        op := &request.Operation{
+                Name:       opGetObject,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}/{Key+}",
+        }
+
+        if input == nil {
+                input = &GetObjectInput{}
+        }
+
+        output = &GetObjectOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetObject API operation for Amazon Simple Storage Service.
+//
+// Retrieves objects from Amazon S3.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetObject for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchKey "NoSuchKey"
+//   The specified key does not exist.
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObject
+func (c *S3) GetObject(input *GetObjectInput) (*GetObjectOutput, error) {
+        req, out := c.GetObjectRequest(input)
+        return out, req.Send()
+}
+
+// GetObjectWithContext is the same as GetObject with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetObject for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetObjectWithContext(ctx aws.Context, input *GetObjectInput, opts ...request.Option) (*GetObjectOutput, error) {
+        req, out := c.GetObjectRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetObjectAcl = "GetObjectAcl"
+
+// GetObjectAclRequest generates a "aws/request.Request" representing the
+// client's request for the GetObjectAcl operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetObjectAcl for usage and error information.
+//
+// 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 GetObjectAcl method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetObjectAclRequest method.
+//    req, resp := client.GetObjectAclRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectAcl
+func (c *S3) GetObjectAclRequest(input *GetObjectAclInput) (req *request.Request, output *GetObjectAclOutput) {
+        op := &request.Operation{
+                Name:       opGetObjectAcl,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}/{Key+}?acl",
+        }
+
+        if input == nil {
+                input = &GetObjectAclInput{}
+        }
+
+        output = &GetObjectAclOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetObjectAcl API operation for Amazon Simple Storage Service.
+//
+// Returns the access control list (ACL) of an object.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetObjectAcl for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchKey "NoSuchKey"
+//   The specified key does not exist.
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectAcl
+func (c *S3) GetObjectAcl(input *GetObjectAclInput) (*GetObjectAclOutput, error) {
+        req, out := c.GetObjectAclRequest(input)
+        return out, req.Send()
+}
+
+// GetObjectAclWithContext is the same as GetObjectAcl with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetObjectAcl for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetObjectAclWithContext(ctx aws.Context, input *GetObjectAclInput, opts ...request.Option) (*GetObjectAclOutput, error) {
+        req, out := c.GetObjectAclRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetObjectTagging = "GetObjectTagging"
+
+// GetObjectTaggingRequest generates a "aws/request.Request" representing the
+// client's request for the GetObjectTagging operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetObjectTagging for usage and error information.
+//
+// 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 GetObjectTagging method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetObjectTaggingRequest method.
+//    req, resp := client.GetObjectTaggingRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectTagging
+func (c *S3) GetObjectTaggingRequest(input *GetObjectTaggingInput) (req *request.Request, output *GetObjectTaggingOutput) {
+        op := &request.Operation{
+                Name:       opGetObjectTagging,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}/{Key+}?tagging",
+        }
+
+        if input == nil {
+                input = &GetObjectTaggingInput{}
+        }
+
+        output = &GetObjectTaggingOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetObjectTagging API operation for Amazon Simple Storage Service.
+//
+// Returns the tag-set of an object.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetObjectTagging for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectTagging
+func (c *S3) GetObjectTagging(input *GetObjectTaggingInput) (*GetObjectTaggingOutput, error) {
+        req, out := c.GetObjectTaggingRequest(input)
+        return out, req.Send()
+}
+
+// GetObjectTaggingWithContext is the same as GetObjectTagging with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetObjectTagging for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetObjectTaggingWithContext(ctx aws.Context, input *GetObjectTaggingInput, opts ...request.Option) (*GetObjectTaggingOutput, error) {
+        req, out := c.GetObjectTaggingRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetObjectTorrent = "GetObjectTorrent"
+
+// GetObjectTorrentRequest generates a "aws/request.Request" representing the
+// client's request for the GetObjectTorrent operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetObjectTorrent for usage and error information.
+//
+// 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 GetObjectTorrent method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetObjectTorrentRequest method.
+//    req, resp := client.GetObjectTorrentRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectTorrent
+func (c *S3) GetObjectTorrentRequest(input *GetObjectTorrentInput) (req *request.Request, output *GetObjectTorrentOutput) {
+        op := &request.Operation{
+                Name:       opGetObjectTorrent,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}/{Key+}?torrent",
+        }
+
+        if input == nil {
+                input = &GetObjectTorrentInput{}
+        }
+
+        output = &GetObjectTorrentOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetObjectTorrent API operation for Amazon Simple Storage Service.
+//
+// Return torrent files from a bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation GetObjectTorrent for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectTorrent
+func (c *S3) GetObjectTorrent(input *GetObjectTorrentInput) (*GetObjectTorrentOutput, error) {
+        req, out := c.GetObjectTorrentRequest(input)
+        return out, req.Send()
+}
+
+// GetObjectTorrentWithContext is the same as GetObjectTorrent with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetObjectTorrent for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) GetObjectTorrentWithContext(ctx aws.Context, input *GetObjectTorrentInput, opts ...request.Option) (*GetObjectTorrentOutput, error) {
+        req, out := c.GetObjectTorrentRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opHeadBucket = "HeadBucket"
+
+// HeadBucketRequest generates a "aws/request.Request" representing the
+// client's request for the HeadBucket operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See HeadBucket for usage and error information.
+//
+// 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 HeadBucket method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the HeadBucketRequest method.
+//    req, resp := client.HeadBucketRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/HeadBucket
+func (c *S3) HeadBucketRequest(input *HeadBucketInput) (req *request.Request, output *HeadBucketOutput) {
+        op := &request.Operation{
+                Name:       opHeadBucket,
+                HTTPMethod: "HEAD",
+                HTTPPath:   "/{Bucket}",
+        }
+
+        if input == nil {
+                input = &HeadBucketInput{}
+        }
+
+        output = &HeadBucketOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// HeadBucket API operation for Amazon Simple Storage Service.
+//
+// This operation is useful to determine if a bucket exists and you have permission
+// to access it.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation HeadBucket for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchBucket "NoSuchBucket"
+//   The specified bucket does not exist.
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/HeadBucket
+func (c *S3) HeadBucket(input *HeadBucketInput) (*HeadBucketOutput, error) {
+        req, out := c.HeadBucketRequest(input)
+        return out, req.Send()
+}
+
+// HeadBucketWithContext is the same as HeadBucket with the addition of
+// the ability to pass a context and additional request options.
+//
+// See HeadBucket for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) HeadBucketWithContext(ctx aws.Context, input *HeadBucketInput, opts ...request.Option) (*HeadBucketOutput, error) {
+        req, out := c.HeadBucketRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opHeadObject = "HeadObject"
+
+// HeadObjectRequest generates a "aws/request.Request" representing the
+// client's request for the HeadObject operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See HeadObject for usage and error information.
+//
+// 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 HeadObject method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the HeadObjectRequest method.
+//    req, resp := client.HeadObjectRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/HeadObject
+func (c *S3) HeadObjectRequest(input *HeadObjectInput) (req *request.Request, output *HeadObjectOutput) {
+        op := &request.Operation{
+                Name:       opHeadObject,
+                HTTPMethod: "HEAD",
+                HTTPPath:   "/{Bucket}/{Key+}",
+        }
+
+        if input == nil {
+                input = &HeadObjectInput{}
+        }
+
+        output = &HeadObjectOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// HeadObject API operation for Amazon Simple Storage Service.
+//
+// The HEAD operation retrieves metadata from an object without returning the
+// object itself. This operation is useful if you're only interested in an object's
+// metadata. To use HEAD, you must have READ access to the object.
+//
+// See http://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html#RESTErrorResponses
+// for more information on returned errors.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation HeadObject for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/HeadObject
+func (c *S3) HeadObject(input *HeadObjectInput) (*HeadObjectOutput, error) {
+        req, out := c.HeadObjectRequest(input)
+        return out, req.Send()
+}
+
+// HeadObjectWithContext is the same as HeadObject with the addition of
+// the ability to pass a context and additional request options.
+//
+// See HeadObject for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) HeadObjectWithContext(ctx aws.Context, input *HeadObjectInput, opts ...request.Option) (*HeadObjectOutput, error) {
+        req, out := c.HeadObjectRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opListBucketAnalyticsConfigurations = "ListBucketAnalyticsConfigurations"
+
+// ListBucketAnalyticsConfigurationsRequest generates a "aws/request.Request" representing the
+// client's request for the ListBucketAnalyticsConfigurations operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See ListBucketAnalyticsConfigurations for usage and error information.
+//
+// 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 ListBucketAnalyticsConfigurations method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the ListBucketAnalyticsConfigurationsRequest method.
+//    req, resp := client.ListBucketAnalyticsConfigurationsRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBucketAnalyticsConfigurations
+func (c *S3) ListBucketAnalyticsConfigurationsRequest(input *ListBucketAnalyticsConfigurationsInput) (req *request.Request, output *ListBucketAnalyticsConfigurationsOutput) {
+        op := &request.Operation{
+                Name:       opListBucketAnalyticsConfigurations,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?analytics",
+        }
+
+        if input == nil {
+                input = &ListBucketAnalyticsConfigurationsInput{}
+        }
+
+        output = &ListBucketAnalyticsConfigurationsOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// ListBucketAnalyticsConfigurations API operation for Amazon Simple Storage Service.
+//
+// Lists the analytics configurations for the bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation ListBucketAnalyticsConfigurations for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBucketAnalyticsConfigurations
+func (c *S3) ListBucketAnalyticsConfigurations(input *ListBucketAnalyticsConfigurationsInput) (*ListBucketAnalyticsConfigurationsOutput, error) {
+        req, out := c.ListBucketAnalyticsConfigurationsRequest(input)
+        return out, req.Send()
+}
+
+// ListBucketAnalyticsConfigurationsWithContext is the same as ListBucketAnalyticsConfigurations with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListBucketAnalyticsConfigurations for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) ListBucketAnalyticsConfigurationsWithContext(ctx aws.Context, input *ListBucketAnalyticsConfigurationsInput, opts ...request.Option) (*ListBucketAnalyticsConfigurationsOutput, error) {
+        req, out := c.ListBucketAnalyticsConfigurationsRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opListBucketInventoryConfigurations = "ListBucketInventoryConfigurations"
+
+// ListBucketInventoryConfigurationsRequest generates a "aws/request.Request" representing the
+// client's request for the ListBucketInventoryConfigurations operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See ListBucketInventoryConfigurations for usage and error information.
+//
+// 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 ListBucketInventoryConfigurations method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the ListBucketInventoryConfigurationsRequest method.
+//    req, resp := client.ListBucketInventoryConfigurationsRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBucketInventoryConfigurations
+func (c *S3) ListBucketInventoryConfigurationsRequest(input *ListBucketInventoryConfigurationsInput) (req *request.Request, output *ListBucketInventoryConfigurationsOutput) {
+        op := &request.Operation{
+                Name:       opListBucketInventoryConfigurations,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?inventory",
+        }
+
+        if input == nil {
+                input = &ListBucketInventoryConfigurationsInput{}
+        }
+
+        output = &ListBucketInventoryConfigurationsOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// ListBucketInventoryConfigurations API operation for Amazon Simple Storage Service.
+//
+// Returns a list of inventory configurations for the bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation ListBucketInventoryConfigurations for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBucketInventoryConfigurations
+func (c *S3) ListBucketInventoryConfigurations(input *ListBucketInventoryConfigurationsInput) (*ListBucketInventoryConfigurationsOutput, error) {
+        req, out := c.ListBucketInventoryConfigurationsRequest(input)
+        return out, req.Send()
+}
+
+// ListBucketInventoryConfigurationsWithContext is the same as ListBucketInventoryConfigurations with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListBucketInventoryConfigurations for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) ListBucketInventoryConfigurationsWithContext(ctx aws.Context, input *ListBucketInventoryConfigurationsInput, opts ...request.Option) (*ListBucketInventoryConfigurationsOutput, error) {
+        req, out := c.ListBucketInventoryConfigurationsRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opListBucketMetricsConfigurations = "ListBucketMetricsConfigurations"
+
+// ListBucketMetricsConfigurationsRequest generates a "aws/request.Request" representing the
+// client's request for the ListBucketMetricsConfigurations operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See ListBucketMetricsConfigurations for usage and error information.
+//
+// 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 ListBucketMetricsConfigurations method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the ListBucketMetricsConfigurationsRequest method.
+//    req, resp := client.ListBucketMetricsConfigurationsRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBucketMetricsConfigurations
+func (c *S3) ListBucketMetricsConfigurationsRequest(input *ListBucketMetricsConfigurationsInput) (req *request.Request, output *ListBucketMetricsConfigurationsOutput) {
+        op := &request.Operation{
+                Name:       opListBucketMetricsConfigurations,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?metrics",
+        }
+
+        if input == nil {
+                input = &ListBucketMetricsConfigurationsInput{}
+        }
+
+        output = &ListBucketMetricsConfigurationsOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// ListBucketMetricsConfigurations API operation for Amazon Simple Storage Service.
+//
+// Lists the metrics configurations for the bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation ListBucketMetricsConfigurations for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBucketMetricsConfigurations
+func (c *S3) ListBucketMetricsConfigurations(input *ListBucketMetricsConfigurationsInput) (*ListBucketMetricsConfigurationsOutput, error) {
+        req, out := c.ListBucketMetricsConfigurationsRequest(input)
+        return out, req.Send()
+}
+
+// ListBucketMetricsConfigurationsWithContext is the same as ListBucketMetricsConfigurations with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListBucketMetricsConfigurations for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) ListBucketMetricsConfigurationsWithContext(ctx aws.Context, input *ListBucketMetricsConfigurationsInput, opts ...request.Option) (*ListBucketMetricsConfigurationsOutput, error) {
+        req, out := c.ListBucketMetricsConfigurationsRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opListBuckets = "ListBuckets"
+
+// ListBucketsRequest generates a "aws/request.Request" representing the
+// client's request for the ListBuckets operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See ListBuckets for usage and error information.
+//
+// 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 ListBuckets method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the ListBucketsRequest method.
+//    req, resp := client.ListBucketsRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBuckets
+func (c *S3) ListBucketsRequest(input *ListBucketsInput) (req *request.Request, output *ListBucketsOutput) {
+        op := &request.Operation{
+                Name:       opListBuckets,
+                HTTPMethod: "GET",
+                HTTPPath:   "/",
+        }
+
+        if input == nil {
+                input = &ListBucketsInput{}
+        }
+
+        output = &ListBucketsOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// ListBuckets API operation for Amazon Simple Storage Service.
+//
+// Returns a list of all buckets owned by the authenticated sender of the request.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation ListBuckets for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBuckets
+func (c *S3) ListBuckets(input *ListBucketsInput) (*ListBucketsOutput, error) {
+        req, out := c.ListBucketsRequest(input)
+        return out, req.Send()
+}
+
+// ListBucketsWithContext is the same as ListBuckets with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListBuckets for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) ListBucketsWithContext(ctx aws.Context, input *ListBucketsInput, opts ...request.Option) (*ListBucketsOutput, error) {
+        req, out := c.ListBucketsRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opListMultipartUploads = "ListMultipartUploads"
+
+// ListMultipartUploadsRequest generates a "aws/request.Request" representing the
+// client's request for the ListMultipartUploads operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See ListMultipartUploads for usage and error information.
+//
+// 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 ListMultipartUploads method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the ListMultipartUploadsRequest method.
+//    req, resp := client.ListMultipartUploadsRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListMultipartUploads
+func (c *S3) ListMultipartUploadsRequest(input *ListMultipartUploadsInput) (req *request.Request, output *ListMultipartUploadsOutput) {
+        op := &request.Operation{
+                Name:       opListMultipartUploads,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?uploads",
+                Paginator: &request.Paginator{
+                        InputTokens:     []string{"KeyMarker", "UploadIdMarker"},
+                        OutputTokens:    []string{"NextKeyMarker", "NextUploadIdMarker"},
+                        LimitToken:      "MaxUploads",
+                        TruncationToken: "IsTruncated",
+                },
+        }
+
+        if input == nil {
+                input = &ListMultipartUploadsInput{}
+        }
+
+        output = &ListMultipartUploadsOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// ListMultipartUploads API operation for Amazon Simple Storage Service.
+//
+// This operation lists in-progress multipart uploads.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation ListMultipartUploads for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListMultipartUploads
+func (c *S3) ListMultipartUploads(input *ListMultipartUploadsInput) (*ListMultipartUploadsOutput, error) {
+        req, out := c.ListMultipartUploadsRequest(input)
+        return out, req.Send()
+}
+
+// ListMultipartUploadsWithContext is the same as ListMultipartUploads with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListMultipartUploads for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) ListMultipartUploadsWithContext(ctx aws.Context, input *ListMultipartUploadsInput, opts ...request.Option) (*ListMultipartUploadsOutput, error) {
+        req, out := c.ListMultipartUploadsRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+// ListMultipartUploadsPages iterates over the pages of a ListMultipartUploads operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListMultipartUploads method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListMultipartUploads operation.
+//    pageNum := 0
+//    err := client.ListMultipartUploadsPages(params,
+//        func(page *ListMultipartUploadsOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *S3) ListMultipartUploadsPages(input *ListMultipartUploadsInput, fn func(*ListMultipartUploadsOutput, bool) bool) error {
+        return c.ListMultipartUploadsPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListMultipartUploadsPagesWithContext same as ListMultipartUploadsPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) ListMultipartUploadsPagesWithContext(ctx aws.Context, input *ListMultipartUploadsInput, fn func(*ListMultipartUploadsOutput, bool) bool, opts ...request.Option) error {
+        p := request.Pagination{
+                NewRequest: func() (*request.Request, error) {
+                        var inCpy *ListMultipartUploadsInput
+                        if input != nil {
+                                tmp := *input
+                                inCpy = &tmp
+                        }
+                        req, _ := c.ListMultipartUploadsRequest(inCpy)
+                        req.SetContext(ctx)
+                        req.ApplyOptions(opts...)
+                        return req, nil
+                },
+        }
+
+        cont := true
+        for p.Next() && cont {
+                cont = fn(p.Page().(*ListMultipartUploadsOutput), !p.HasNextPage())
+        }
+        return p.Err()
+}
+
+const opListObjectVersions = "ListObjectVersions"
+
+// ListObjectVersionsRequest generates a "aws/request.Request" representing the
+// client's request for the ListObjectVersions operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See ListObjectVersions for usage and error information.
+//
+// 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 ListObjectVersions method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the ListObjectVersionsRequest method.
+//    req, resp := client.ListObjectVersionsRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListObjectVersions
+func (c *S3) ListObjectVersionsRequest(input *ListObjectVersionsInput) (req *request.Request, output *ListObjectVersionsOutput) {
+        op := &request.Operation{
+                Name:       opListObjectVersions,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?versions",
+                Paginator: &request.Paginator{
+                        InputTokens:     []string{"KeyMarker", "VersionIdMarker"},
+                        OutputTokens:    []string{"NextKeyMarker", "NextVersionIdMarker"},
+                        LimitToken:      "MaxKeys",
+                        TruncationToken: "IsTruncated",
+                },
+        }
+
+        if input == nil {
+                input = &ListObjectVersionsInput{}
+        }
+
+        output = &ListObjectVersionsOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// ListObjectVersions API operation for Amazon Simple Storage Service.
+//
+// Returns metadata about all of the versions of objects in a bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation ListObjectVersions for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListObjectVersions
+func (c *S3) ListObjectVersions(input *ListObjectVersionsInput) (*ListObjectVersionsOutput, error) {
+        req, out := c.ListObjectVersionsRequest(input)
+        return out, req.Send()
+}
+
+// ListObjectVersionsWithContext is the same as ListObjectVersions with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListObjectVersions for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) ListObjectVersionsWithContext(ctx aws.Context, input *ListObjectVersionsInput, opts ...request.Option) (*ListObjectVersionsOutput, error) {
+        req, out := c.ListObjectVersionsRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+// ListObjectVersionsPages iterates over the pages of a ListObjectVersions operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListObjectVersions method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListObjectVersions operation.
+//    pageNum := 0
+//    err := client.ListObjectVersionsPages(params,
+//        func(page *ListObjectVersionsOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *S3) ListObjectVersionsPages(input *ListObjectVersionsInput, fn func(*ListObjectVersionsOutput, bool) bool) error {
+        return c.ListObjectVersionsPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListObjectVersionsPagesWithContext same as ListObjectVersionsPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) ListObjectVersionsPagesWithContext(ctx aws.Context, input *ListObjectVersionsInput, fn func(*ListObjectVersionsOutput, bool) bool, opts ...request.Option) error {
+        p := request.Pagination{
+                NewRequest: func() (*request.Request, error) {
+                        var inCpy *ListObjectVersionsInput
+                        if input != nil {
+                                tmp := *input
+                                inCpy = &tmp
+                        }
+                        req, _ := c.ListObjectVersionsRequest(inCpy)
+                        req.SetContext(ctx)
+                        req.ApplyOptions(opts...)
+                        return req, nil
+                },
+        }
+
+        cont := true
+        for p.Next() && cont {
+                cont = fn(p.Page().(*ListObjectVersionsOutput), !p.HasNextPage())
+        }
+        return p.Err()
+}
+
+const opListObjects = "ListObjects"
+
+// ListObjectsRequest generates a "aws/request.Request" representing the
+// client's request for the ListObjects operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See ListObjects for usage and error information.
+//
+// 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 ListObjects method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the ListObjectsRequest method.
+//    req, resp := client.ListObjectsRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListObjects
+func (c *S3) ListObjectsRequest(input *ListObjectsInput) (req *request.Request, output *ListObjectsOutput) {
+        op := &request.Operation{
+                Name:       opListObjects,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}",
+                Paginator: &request.Paginator{
+                        InputTokens:     []string{"Marker"},
+                        OutputTokens:    []string{"NextMarker || Contents[-1].Key"},
+                        LimitToken:      "MaxKeys",
+                        TruncationToken: "IsTruncated",
+                },
+        }
+
+        if input == nil {
+                input = &ListObjectsInput{}
+        }
+
+        output = &ListObjectsOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// ListObjects API operation for Amazon Simple Storage Service.
+//
+// Returns some or all (up to 1000) of the objects in a bucket. You can use
+// the request parameters as selection criteria to return a subset of the objects
+// in a bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation ListObjects for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchBucket "NoSuchBucket"
+//   The specified bucket does not exist.
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListObjects
+func (c *S3) ListObjects(input *ListObjectsInput) (*ListObjectsOutput, error) {
+        req, out := c.ListObjectsRequest(input)
+        return out, req.Send()
+}
+
+// ListObjectsWithContext is the same as ListObjects with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListObjects for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) ListObjectsWithContext(ctx aws.Context, input *ListObjectsInput, opts ...request.Option) (*ListObjectsOutput, error) {
+        req, out := c.ListObjectsRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+// ListObjectsPages iterates over the pages of a ListObjects operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListObjects method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListObjects operation.
+//    pageNum := 0
+//    err := client.ListObjectsPages(params,
+//        func(page *ListObjectsOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *S3) ListObjectsPages(input *ListObjectsInput, fn func(*ListObjectsOutput, bool) bool) error {
+        return c.ListObjectsPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListObjectsPagesWithContext same as ListObjectsPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) ListObjectsPagesWithContext(ctx aws.Context, input *ListObjectsInput, fn func(*ListObjectsOutput, bool) bool, opts ...request.Option) error {
+        p := request.Pagination{
+                NewRequest: func() (*request.Request, error) {
+                        var inCpy *ListObjectsInput
+                        if input != nil {
+                                tmp := *input
+                                inCpy = &tmp
+                        }
+                        req, _ := c.ListObjectsRequest(inCpy)
+                        req.SetContext(ctx)
+                        req.ApplyOptions(opts...)
+                        return req, nil
+                },
+        }
+
+        cont := true
+        for p.Next() && cont {
+                cont = fn(p.Page().(*ListObjectsOutput), !p.HasNextPage())
+        }
+        return p.Err()
+}
+
+const opListObjectsV2 = "ListObjectsV2"
+
+// ListObjectsV2Request generates a "aws/request.Request" representing the
+// client's request for the ListObjectsV2 operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See ListObjectsV2 for usage and error information.
+//
+// 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 ListObjectsV2 method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the ListObjectsV2Request method.
+//    req, resp := client.ListObjectsV2Request(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListObjectsV2
+func (c *S3) ListObjectsV2Request(input *ListObjectsV2Input) (req *request.Request, output *ListObjectsV2Output) {
+        op := &request.Operation{
+                Name:       opListObjectsV2,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}?list-type=2",
+                Paginator: &request.Paginator{
+                        InputTokens:     []string{"ContinuationToken"},
+                        OutputTokens:    []string{"NextContinuationToken"},
+                        LimitToken:      "MaxKeys",
+                        TruncationToken: "",
+                },
+        }
+
+        if input == nil {
+                input = &ListObjectsV2Input{}
+        }
+
+        output = &ListObjectsV2Output{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// ListObjectsV2 API operation for Amazon Simple Storage Service.
+//
+// Returns some or all (up to 1000) of the objects in a bucket. You can use
+// the request parameters as selection criteria to return a subset of the objects
+// in a bucket. Note: ListObjectsV2 is the revised List Objects API and we recommend
+// you use this revised API for new application development.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation ListObjectsV2 for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchBucket "NoSuchBucket"
+//   The specified bucket does not exist.
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListObjectsV2
+func (c *S3) ListObjectsV2(input *ListObjectsV2Input) (*ListObjectsV2Output, error) {
+        req, out := c.ListObjectsV2Request(input)
+        return out, req.Send()
+}
+
+// ListObjectsV2WithContext is the same as ListObjectsV2 with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListObjectsV2 for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) ListObjectsV2WithContext(ctx aws.Context, input *ListObjectsV2Input, opts ...request.Option) (*ListObjectsV2Output, error) {
+        req, out := c.ListObjectsV2Request(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+// ListObjectsV2Pages iterates over the pages of a ListObjectsV2 operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListObjectsV2 method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListObjectsV2 operation.
+//    pageNum := 0
+//    err := client.ListObjectsV2Pages(params,
+//        func(page *ListObjectsV2Output, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *S3) ListObjectsV2Pages(input *ListObjectsV2Input, fn func(*ListObjectsV2Output, bool) bool) error {
+        return c.ListObjectsV2PagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListObjectsV2PagesWithContext same as ListObjectsV2Pages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) ListObjectsV2PagesWithContext(ctx aws.Context, input *ListObjectsV2Input, fn func(*ListObjectsV2Output, bool) bool, opts ...request.Option) error {
+        p := request.Pagination{
+                NewRequest: func() (*request.Request, error) {
+                        var inCpy *ListObjectsV2Input
+                        if input != nil {
+                                tmp := *input
+                                inCpy = &tmp
+                        }
+                        req, _ := c.ListObjectsV2Request(inCpy)
+                        req.SetContext(ctx)
+                        req.ApplyOptions(opts...)
+                        return req, nil
+                },
+        }
+
+        cont := true
+        for p.Next() && cont {
+                cont = fn(p.Page().(*ListObjectsV2Output), !p.HasNextPage())
+        }
+        return p.Err()
+}
+
+const opListParts = "ListParts"
+
+// ListPartsRequest generates a "aws/request.Request" representing the
+// client's request for the ListParts operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See ListParts for usage and error information.
+//
+// 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 ListParts method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the ListPartsRequest method.
+//    req, resp := client.ListPartsRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListParts
+func (c *S3) ListPartsRequest(input *ListPartsInput) (req *request.Request, output *ListPartsOutput) {
+        op := &request.Operation{
+                Name:       opListParts,
+                HTTPMethod: "GET",
+                HTTPPath:   "/{Bucket}/{Key+}",
+                Paginator: &request.Paginator{
+                        InputTokens:     []string{"PartNumberMarker"},
+                        OutputTokens:    []string{"NextPartNumberMarker"},
+                        LimitToken:      "MaxParts",
+                        TruncationToken: "IsTruncated",
+                },
+        }
+
+        if input == nil {
+                input = &ListPartsInput{}
+        }
+
+        output = &ListPartsOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// ListParts API operation for Amazon Simple Storage Service.
+//
+// Lists the parts that have been uploaded for a specific multipart upload.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation ListParts for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListParts
+func (c *S3) ListParts(input *ListPartsInput) (*ListPartsOutput, error) {
+        req, out := c.ListPartsRequest(input)
+        return out, req.Send()
+}
+
+// ListPartsWithContext is the same as ListParts with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListParts for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) ListPartsWithContext(ctx aws.Context, input *ListPartsInput, opts ...request.Option) (*ListPartsOutput, error) {
+        req, out := c.ListPartsRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+// ListPartsPages iterates over the pages of a ListParts operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListParts method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListParts operation.
+//    pageNum := 0
+//    err := client.ListPartsPages(params,
+//        func(page *ListPartsOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *S3) ListPartsPages(input *ListPartsInput, fn func(*ListPartsOutput, bool) bool) error {
+        return c.ListPartsPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListPartsPagesWithContext same as ListPartsPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) ListPartsPagesWithContext(ctx aws.Context, input *ListPartsInput, fn func(*ListPartsOutput, bool) bool, opts ...request.Option) error {
+        p := request.Pagination{
+                NewRequest: func() (*request.Request, error) {
+                        var inCpy *ListPartsInput
+                        if input != nil {
+                                tmp := *input
+                                inCpy = &tmp
+                        }
+                        req, _ := c.ListPartsRequest(inCpy)
+                        req.SetContext(ctx)
+                        req.ApplyOptions(opts...)
+                        return req, nil
+                },
+        }
+
+        cont := true
+        for p.Next() && cont {
+                cont = fn(p.Page().(*ListPartsOutput), !p.HasNextPage())
+        }
+        return p.Err()
+}
+
+const opPutBucketAccelerateConfiguration = "PutBucketAccelerateConfiguration"
+
+// PutBucketAccelerateConfigurationRequest generates a "aws/request.Request" representing the
+// client's request for the PutBucketAccelerateConfiguration operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See PutBucketAccelerateConfiguration for usage and error information.
+//
+// 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 PutBucketAccelerateConfiguration method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the PutBucketAccelerateConfigurationRequest method.
+//    req, resp := client.PutBucketAccelerateConfigurationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketAccelerateConfiguration
+func (c *S3) PutBucketAccelerateConfigurationRequest(input *PutBucketAccelerateConfigurationInput) (req *request.Request, output *PutBucketAccelerateConfigurationOutput) {
+        op := &request.Operation{
+                Name:       opPutBucketAccelerateConfiguration,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}?accelerate",
+        }
+
+        if input == nil {
+                input = &PutBucketAccelerateConfigurationInput{}
+        }
+
+        output = &PutBucketAccelerateConfigurationOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// PutBucketAccelerateConfiguration API operation for Amazon Simple Storage Service.
+//
+// Sets the accelerate configuration of an existing bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation PutBucketAccelerateConfiguration for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketAccelerateConfiguration
+func (c *S3) PutBucketAccelerateConfiguration(input *PutBucketAccelerateConfigurationInput) (*PutBucketAccelerateConfigurationOutput, error) {
+        req, out := c.PutBucketAccelerateConfigurationRequest(input)
+        return out, req.Send()
+}
+
+// PutBucketAccelerateConfigurationWithContext is the same as PutBucketAccelerateConfiguration with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutBucketAccelerateConfiguration for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) PutBucketAccelerateConfigurationWithContext(ctx aws.Context, input *PutBucketAccelerateConfigurationInput, opts ...request.Option) (*PutBucketAccelerateConfigurationOutput, error) {
+        req, out := c.PutBucketAccelerateConfigurationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opPutBucketAcl = "PutBucketAcl"
+
+// PutBucketAclRequest generates a "aws/request.Request" representing the
+// client's request for the PutBucketAcl operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See PutBucketAcl for usage and error information.
+//
+// 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 PutBucketAcl method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the PutBucketAclRequest method.
+//    req, resp := client.PutBucketAclRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketAcl
+func (c *S3) PutBucketAclRequest(input *PutBucketAclInput) (req *request.Request, output *PutBucketAclOutput) {
+        op := &request.Operation{
+                Name:       opPutBucketAcl,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}?acl",
+        }
+
+        if input == nil {
+                input = &PutBucketAclInput{}
+        }
+
+        output = &PutBucketAclOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// PutBucketAcl API operation for Amazon Simple Storage Service.
+//
+// Sets the permissions on a bucket using access control lists (ACL).
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation PutBucketAcl for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketAcl
+func (c *S3) PutBucketAcl(input *PutBucketAclInput) (*PutBucketAclOutput, error) {
+        req, out := c.PutBucketAclRequest(input)
+        return out, req.Send()
+}
+
+// PutBucketAclWithContext is the same as PutBucketAcl with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutBucketAcl for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) PutBucketAclWithContext(ctx aws.Context, input *PutBucketAclInput, opts ...request.Option) (*PutBucketAclOutput, error) {
+        req, out := c.PutBucketAclRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opPutBucketAnalyticsConfiguration = "PutBucketAnalyticsConfiguration"
+
+// PutBucketAnalyticsConfigurationRequest generates a "aws/request.Request" representing the
+// client's request for the PutBucketAnalyticsConfiguration operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See PutBucketAnalyticsConfiguration for usage and error information.
+//
+// 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 PutBucketAnalyticsConfiguration method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the PutBucketAnalyticsConfigurationRequest method.
+//    req, resp := client.PutBucketAnalyticsConfigurationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketAnalyticsConfiguration
+func (c *S3) PutBucketAnalyticsConfigurationRequest(input *PutBucketAnalyticsConfigurationInput) (req *request.Request, output *PutBucketAnalyticsConfigurationOutput) {
+        op := &request.Operation{
+                Name:       opPutBucketAnalyticsConfiguration,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}?analytics",
+        }
+
+        if input == nil {
+                input = &PutBucketAnalyticsConfigurationInput{}
+        }
+
+        output = &PutBucketAnalyticsConfigurationOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// PutBucketAnalyticsConfiguration API operation for Amazon Simple Storage Service.
+//
+// Sets an analytics configuration for the bucket (specified by the analytics
+// configuration ID).
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation PutBucketAnalyticsConfiguration for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketAnalyticsConfiguration
+func (c *S3) PutBucketAnalyticsConfiguration(input *PutBucketAnalyticsConfigurationInput) (*PutBucketAnalyticsConfigurationOutput, error) {
+        req, out := c.PutBucketAnalyticsConfigurationRequest(input)
+        return out, req.Send()
+}
+
+// PutBucketAnalyticsConfigurationWithContext is the same as PutBucketAnalyticsConfiguration with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutBucketAnalyticsConfiguration for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) PutBucketAnalyticsConfigurationWithContext(ctx aws.Context, input *PutBucketAnalyticsConfigurationInput, opts ...request.Option) (*PutBucketAnalyticsConfigurationOutput, error) {
+        req, out := c.PutBucketAnalyticsConfigurationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opPutBucketCors = "PutBucketCors"
+
+// PutBucketCorsRequest generates a "aws/request.Request" representing the
+// client's request for the PutBucketCors operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See PutBucketCors for usage and error information.
+//
+// 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 PutBucketCors method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the PutBucketCorsRequest method.
+//    req, resp := client.PutBucketCorsRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketCors
+func (c *S3) PutBucketCorsRequest(input *PutBucketCorsInput) (req *request.Request, output *PutBucketCorsOutput) {
+        op := &request.Operation{
+                Name:       opPutBucketCors,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}?cors",
+        }
+
+        if input == nil {
+                input = &PutBucketCorsInput{}
+        }
+
+        output = &PutBucketCorsOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// PutBucketCors API operation for Amazon Simple Storage Service.
+//
+// Sets the cors configuration for a bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation PutBucketCors for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketCors
+func (c *S3) PutBucketCors(input *PutBucketCorsInput) (*PutBucketCorsOutput, error) {
+        req, out := c.PutBucketCorsRequest(input)
+        return out, req.Send()
+}
+
+// PutBucketCorsWithContext is the same as PutBucketCors with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutBucketCors for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) PutBucketCorsWithContext(ctx aws.Context, input *PutBucketCorsInput, opts ...request.Option) (*PutBucketCorsOutput, error) {
+        req, out := c.PutBucketCorsRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opPutBucketInventoryConfiguration = "PutBucketInventoryConfiguration"
+
+// PutBucketInventoryConfigurationRequest generates a "aws/request.Request" representing the
+// client's request for the PutBucketInventoryConfiguration operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See PutBucketInventoryConfiguration for usage and error information.
+//
+// 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 PutBucketInventoryConfiguration method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the PutBucketInventoryConfigurationRequest method.
+//    req, resp := client.PutBucketInventoryConfigurationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketInventoryConfiguration
+func (c *S3) PutBucketInventoryConfigurationRequest(input *PutBucketInventoryConfigurationInput) (req *request.Request, output *PutBucketInventoryConfigurationOutput) {
+        op := &request.Operation{
+                Name:       opPutBucketInventoryConfiguration,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}?inventory",
+        }
+
+        if input == nil {
+                input = &PutBucketInventoryConfigurationInput{}
+        }
+
+        output = &PutBucketInventoryConfigurationOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// PutBucketInventoryConfiguration API operation for Amazon Simple Storage Service.
+//
+// Adds an inventory configuration (identified by the inventory ID) from the
+// bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation PutBucketInventoryConfiguration for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketInventoryConfiguration
+func (c *S3) PutBucketInventoryConfiguration(input *PutBucketInventoryConfigurationInput) (*PutBucketInventoryConfigurationOutput, error) {
+        req, out := c.PutBucketInventoryConfigurationRequest(input)
+        return out, req.Send()
+}
+
+// PutBucketInventoryConfigurationWithContext is the same as PutBucketInventoryConfiguration with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutBucketInventoryConfiguration for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) PutBucketInventoryConfigurationWithContext(ctx aws.Context, input *PutBucketInventoryConfigurationInput, opts ...request.Option) (*PutBucketInventoryConfigurationOutput, error) {
+        req, out := c.PutBucketInventoryConfigurationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opPutBucketLifecycle = "PutBucketLifecycle"
+
+// PutBucketLifecycleRequest generates a "aws/request.Request" representing the
+// client's request for the PutBucketLifecycle operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See PutBucketLifecycle for usage and error information.
+//
+// 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 PutBucketLifecycle method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the PutBucketLifecycleRequest method.
+//    req, resp := client.PutBucketLifecycleRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketLifecycle
+func (c *S3) PutBucketLifecycleRequest(input *PutBucketLifecycleInput) (req *request.Request, output *PutBucketLifecycleOutput) {
+        if c.Client.Config.Logger != nil {
+                c.Client.Config.Logger.Log("This operation, PutBucketLifecycle, has been deprecated")
+        }
+        op := &request.Operation{
+                Name:       opPutBucketLifecycle,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}?lifecycle",
+        }
+
+        if input == nil {
+                input = &PutBucketLifecycleInput{}
+        }
+
+        output = &PutBucketLifecycleOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// PutBucketLifecycle API operation for Amazon Simple Storage Service.
+//
+// Deprecated, see the PutBucketLifecycleConfiguration operation.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation PutBucketLifecycle for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketLifecycle
+func (c *S3) PutBucketLifecycle(input *PutBucketLifecycleInput) (*PutBucketLifecycleOutput, error) {
+        req, out := c.PutBucketLifecycleRequest(input)
+        return out, req.Send()
+}
+
+// PutBucketLifecycleWithContext is the same as PutBucketLifecycle with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutBucketLifecycle for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) PutBucketLifecycleWithContext(ctx aws.Context, input *PutBucketLifecycleInput, opts ...request.Option) (*PutBucketLifecycleOutput, error) {
+        req, out := c.PutBucketLifecycleRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opPutBucketLifecycleConfiguration = "PutBucketLifecycleConfiguration"
+
+// PutBucketLifecycleConfigurationRequest generates a "aws/request.Request" representing the
+// client's request for the PutBucketLifecycleConfiguration operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See PutBucketLifecycleConfiguration for usage and error information.
+//
+// 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 PutBucketLifecycleConfiguration method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the PutBucketLifecycleConfigurationRequest method.
+//    req, resp := client.PutBucketLifecycleConfigurationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketLifecycleConfiguration
+func (c *S3) PutBucketLifecycleConfigurationRequest(input *PutBucketLifecycleConfigurationInput) (req *request.Request, output *PutBucketLifecycleConfigurationOutput) {
+        op := &request.Operation{
+                Name:       opPutBucketLifecycleConfiguration,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}?lifecycle",
+        }
+
+        if input == nil {
+                input = &PutBucketLifecycleConfigurationInput{}
+        }
+
+        output = &PutBucketLifecycleConfigurationOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// PutBucketLifecycleConfiguration API operation for Amazon Simple Storage Service.
+//
+// Sets lifecycle configuration for your bucket. If a lifecycle configuration
+// exists, it replaces it.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation PutBucketLifecycleConfiguration for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketLifecycleConfiguration
+func (c *S3) PutBucketLifecycleConfiguration(input *PutBucketLifecycleConfigurationInput) (*PutBucketLifecycleConfigurationOutput, error) {
+        req, out := c.PutBucketLifecycleConfigurationRequest(input)
+        return out, req.Send()
+}
+
+// PutBucketLifecycleConfigurationWithContext is the same as PutBucketLifecycleConfiguration with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutBucketLifecycleConfiguration for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) PutBucketLifecycleConfigurationWithContext(ctx aws.Context, input *PutBucketLifecycleConfigurationInput, opts ...request.Option) (*PutBucketLifecycleConfigurationOutput, error) {
+        req, out := c.PutBucketLifecycleConfigurationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opPutBucketLogging = "PutBucketLogging"
+
+// PutBucketLoggingRequest generates a "aws/request.Request" representing the
+// client's request for the PutBucketLogging operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See PutBucketLogging for usage and error information.
+//
+// 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 PutBucketLogging method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the PutBucketLoggingRequest method.
+//    req, resp := client.PutBucketLoggingRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketLogging
+func (c *S3) PutBucketLoggingRequest(input *PutBucketLoggingInput) (req *request.Request, output *PutBucketLoggingOutput) {
+        op := &request.Operation{
+                Name:       opPutBucketLogging,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}?logging",
+        }
+
+        if input == nil {
+                input = &PutBucketLoggingInput{}
+        }
+
+        output = &PutBucketLoggingOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// PutBucketLogging API operation for Amazon Simple Storage Service.
+//
+// Set the logging parameters for a bucket and to specify permissions for who
+// can view and modify the logging parameters. To set the logging status of
+// a bucket, you must be the bucket owner.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation PutBucketLogging for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketLogging
+func (c *S3) PutBucketLogging(input *PutBucketLoggingInput) (*PutBucketLoggingOutput, error) {
+        req, out := c.PutBucketLoggingRequest(input)
+        return out, req.Send()
+}
+
+// PutBucketLoggingWithContext is the same as PutBucketLogging with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutBucketLogging for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) PutBucketLoggingWithContext(ctx aws.Context, input *PutBucketLoggingInput, opts ...request.Option) (*PutBucketLoggingOutput, error) {
+        req, out := c.PutBucketLoggingRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opPutBucketMetricsConfiguration = "PutBucketMetricsConfiguration"
+
+// PutBucketMetricsConfigurationRequest generates a "aws/request.Request" representing the
+// client's request for the PutBucketMetricsConfiguration operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See PutBucketMetricsConfiguration for usage and error information.
+//
+// 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 PutBucketMetricsConfiguration method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the PutBucketMetricsConfigurationRequest method.
+//    req, resp := client.PutBucketMetricsConfigurationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketMetricsConfiguration
+func (c *S3) PutBucketMetricsConfigurationRequest(input *PutBucketMetricsConfigurationInput) (req *request.Request, output *PutBucketMetricsConfigurationOutput) {
+        op := &request.Operation{
+                Name:       opPutBucketMetricsConfiguration,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}?metrics",
+        }
+
+        if input == nil {
+                input = &PutBucketMetricsConfigurationInput{}
+        }
+
+        output = &PutBucketMetricsConfigurationOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// PutBucketMetricsConfiguration API operation for Amazon Simple Storage Service.
+//
+// Sets a metrics configuration (specified by the metrics configuration ID)
+// for the bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation PutBucketMetricsConfiguration for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketMetricsConfiguration
+func (c *S3) PutBucketMetricsConfiguration(input *PutBucketMetricsConfigurationInput) (*PutBucketMetricsConfigurationOutput, error) {
+        req, out := c.PutBucketMetricsConfigurationRequest(input)
+        return out, req.Send()
+}
+
+// PutBucketMetricsConfigurationWithContext is the same as PutBucketMetricsConfiguration with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutBucketMetricsConfiguration for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) PutBucketMetricsConfigurationWithContext(ctx aws.Context, input *PutBucketMetricsConfigurationInput, opts ...request.Option) (*PutBucketMetricsConfigurationOutput, error) {
+        req, out := c.PutBucketMetricsConfigurationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opPutBucketNotification = "PutBucketNotification"
+
+// PutBucketNotificationRequest generates a "aws/request.Request" representing the
+// client's request for the PutBucketNotification operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See PutBucketNotification for usage and error information.
+//
+// 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 PutBucketNotification method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the PutBucketNotificationRequest method.
+//    req, resp := client.PutBucketNotificationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketNotification
+func (c *S3) PutBucketNotificationRequest(input *PutBucketNotificationInput) (req *request.Request, output *PutBucketNotificationOutput) {
+        if c.Client.Config.Logger != nil {
+                c.Client.Config.Logger.Log("This operation, PutBucketNotification, has been deprecated")
+        }
+        op := &request.Operation{
+                Name:       opPutBucketNotification,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}?notification",
+        }
+
+        if input == nil {
+                input = &PutBucketNotificationInput{}
+        }
+
+        output = &PutBucketNotificationOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// PutBucketNotification API operation for Amazon Simple Storage Service.
+//
+// Deprecated, see the PutBucketNotificationConfiguraiton operation.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation PutBucketNotification for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketNotification
+func (c *S3) PutBucketNotification(input *PutBucketNotificationInput) (*PutBucketNotificationOutput, error) {
+        req, out := c.PutBucketNotificationRequest(input)
+        return out, req.Send()
+}
+
+// PutBucketNotificationWithContext is the same as PutBucketNotification with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutBucketNotification for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) PutBucketNotificationWithContext(ctx aws.Context, input *PutBucketNotificationInput, opts ...request.Option) (*PutBucketNotificationOutput, error) {
+        req, out := c.PutBucketNotificationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opPutBucketNotificationConfiguration = "PutBucketNotificationConfiguration"
+
+// PutBucketNotificationConfigurationRequest generates a "aws/request.Request" representing the
+// client's request for the PutBucketNotificationConfiguration operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See PutBucketNotificationConfiguration for usage and error information.
+//
+// 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 PutBucketNotificationConfiguration method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the PutBucketNotificationConfigurationRequest method.
+//    req, resp := client.PutBucketNotificationConfigurationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketNotificationConfiguration
+func (c *S3) PutBucketNotificationConfigurationRequest(input *PutBucketNotificationConfigurationInput) (req *request.Request, output *PutBucketNotificationConfigurationOutput) {
+        op := &request.Operation{
+                Name:       opPutBucketNotificationConfiguration,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}?notification",
+        }
+
+        if input == nil {
+                input = &PutBucketNotificationConfigurationInput{}
+        }
+
+        output = &PutBucketNotificationConfigurationOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// PutBucketNotificationConfiguration API operation for Amazon Simple Storage Service.
+//
+// Enables notifications of specified events for a bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation PutBucketNotificationConfiguration for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketNotificationConfiguration
+func (c *S3) PutBucketNotificationConfiguration(input *PutBucketNotificationConfigurationInput) (*PutBucketNotificationConfigurationOutput, error) {
+        req, out := c.PutBucketNotificationConfigurationRequest(input)
+        return out, req.Send()
+}
+
+// PutBucketNotificationConfigurationWithContext is the same as PutBucketNotificationConfiguration with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutBucketNotificationConfiguration for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) PutBucketNotificationConfigurationWithContext(ctx aws.Context, input *PutBucketNotificationConfigurationInput, opts ...request.Option) (*PutBucketNotificationConfigurationOutput, error) {
+        req, out := c.PutBucketNotificationConfigurationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opPutBucketPolicy = "PutBucketPolicy"
+
+// PutBucketPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the PutBucketPolicy operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See PutBucketPolicy for usage and error information.
+//
+// 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 PutBucketPolicy method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the PutBucketPolicyRequest method.
+//    req, resp := client.PutBucketPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketPolicy
+func (c *S3) PutBucketPolicyRequest(input *PutBucketPolicyInput) (req *request.Request, output *PutBucketPolicyOutput) {
+        op := &request.Operation{
+                Name:       opPutBucketPolicy,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}?policy",
+        }
+
+        if input == nil {
+                input = &PutBucketPolicyInput{}
+        }
+
+        output = &PutBucketPolicyOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// PutBucketPolicy API operation for Amazon Simple Storage Service.
+//
+// Replaces a policy on a bucket. If the bucket already has a policy, the one
+// in this request completely replaces it.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation PutBucketPolicy for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketPolicy
+func (c *S3) PutBucketPolicy(input *PutBucketPolicyInput) (*PutBucketPolicyOutput, error) {
+        req, out := c.PutBucketPolicyRequest(input)
+        return out, req.Send()
+}
+
+// PutBucketPolicyWithContext is the same as PutBucketPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutBucketPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) PutBucketPolicyWithContext(ctx aws.Context, input *PutBucketPolicyInput, opts ...request.Option) (*PutBucketPolicyOutput, error) {
+        req, out := c.PutBucketPolicyRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opPutBucketReplication = "PutBucketReplication"
+
+// PutBucketReplicationRequest generates a "aws/request.Request" representing the
+// client's request for the PutBucketReplication operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See PutBucketReplication for usage and error information.
+//
+// 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 PutBucketReplication method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the PutBucketReplicationRequest method.
+//    req, resp := client.PutBucketReplicationRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketReplication
+func (c *S3) PutBucketReplicationRequest(input *PutBucketReplicationInput) (req *request.Request, output *PutBucketReplicationOutput) {
+        op := &request.Operation{
+                Name:       opPutBucketReplication,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}?replication",
+        }
+
+        if input == nil {
+                input = &PutBucketReplicationInput{}
+        }
+
+        output = &PutBucketReplicationOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// PutBucketReplication API operation for Amazon Simple Storage Service.
+//
+// Creates a new replication configuration (or replaces an existing one, if
+// present).
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation PutBucketReplication for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketReplication
+func (c *S3) PutBucketReplication(input *PutBucketReplicationInput) (*PutBucketReplicationOutput, error) {
+        req, out := c.PutBucketReplicationRequest(input)
+        return out, req.Send()
+}
+
+// PutBucketReplicationWithContext is the same as PutBucketReplication with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutBucketReplication for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) PutBucketReplicationWithContext(ctx aws.Context, input *PutBucketReplicationInput, opts ...request.Option) (*PutBucketReplicationOutput, error) {
+        req, out := c.PutBucketReplicationRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opPutBucketRequestPayment = "PutBucketRequestPayment"
+
+// PutBucketRequestPaymentRequest generates a "aws/request.Request" representing the
+// client's request for the PutBucketRequestPayment operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See PutBucketRequestPayment for usage and error information.
+//
+// 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 PutBucketRequestPayment method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the PutBucketRequestPaymentRequest method.
+//    req, resp := client.PutBucketRequestPaymentRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketRequestPayment
+func (c *S3) PutBucketRequestPaymentRequest(input *PutBucketRequestPaymentInput) (req *request.Request, output *PutBucketRequestPaymentOutput) {
+        op := &request.Operation{
+                Name:       opPutBucketRequestPayment,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}?requestPayment",
+        }
+
+        if input == nil {
+                input = &PutBucketRequestPaymentInput{}
+        }
+
+        output = &PutBucketRequestPaymentOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// PutBucketRequestPayment API operation for Amazon Simple Storage Service.
+//
+// Sets the request payment configuration for a bucket. By default, the bucket
+// owner pays for downloads from the bucket. This configuration parameter enables
+// the bucket owner (only) to specify that the person requesting the download
+// will be charged for the download. Documentation on requester pays buckets
+// can be found at http://docs.aws.amazon.com/AmazonS3/latest/dev/RequesterPaysBuckets.html
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation PutBucketRequestPayment for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketRequestPayment
+func (c *S3) PutBucketRequestPayment(input *PutBucketRequestPaymentInput) (*PutBucketRequestPaymentOutput, error) {
+        req, out := c.PutBucketRequestPaymentRequest(input)
+        return out, req.Send()
+}
+
+// PutBucketRequestPaymentWithContext is the same as PutBucketRequestPayment with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutBucketRequestPayment for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) PutBucketRequestPaymentWithContext(ctx aws.Context, input *PutBucketRequestPaymentInput, opts ...request.Option) (*PutBucketRequestPaymentOutput, error) {
+        req, out := c.PutBucketRequestPaymentRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opPutBucketTagging = "PutBucketTagging"
+
+// PutBucketTaggingRequest generates a "aws/request.Request" representing the
+// client's request for the PutBucketTagging operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See PutBucketTagging for usage and error information.
+//
+// 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 PutBucketTagging method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the PutBucketTaggingRequest method.
+//    req, resp := client.PutBucketTaggingRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketTagging
+func (c *S3) PutBucketTaggingRequest(input *PutBucketTaggingInput) (req *request.Request, output *PutBucketTaggingOutput) {
+        op := &request.Operation{
+                Name:       opPutBucketTagging,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}?tagging",
+        }
+
+        if input == nil {
+                input = &PutBucketTaggingInput{}
+        }
+
+        output = &PutBucketTaggingOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// PutBucketTagging API operation for Amazon Simple Storage Service.
+//
+// Sets the tags for a bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation PutBucketTagging for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketTagging
+func (c *S3) PutBucketTagging(input *PutBucketTaggingInput) (*PutBucketTaggingOutput, error) {
+        req, out := c.PutBucketTaggingRequest(input)
+        return out, req.Send()
+}
+
+// PutBucketTaggingWithContext is the same as PutBucketTagging with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutBucketTagging for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) PutBucketTaggingWithContext(ctx aws.Context, input *PutBucketTaggingInput, opts ...request.Option) (*PutBucketTaggingOutput, error) {
+        req, out := c.PutBucketTaggingRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opPutBucketVersioning = "PutBucketVersioning"
+
+// PutBucketVersioningRequest generates a "aws/request.Request" representing the
+// client's request for the PutBucketVersioning operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See PutBucketVersioning for usage and error information.
+//
+// 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 PutBucketVersioning method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the PutBucketVersioningRequest method.
+//    req, resp := client.PutBucketVersioningRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketVersioning
+func (c *S3) PutBucketVersioningRequest(input *PutBucketVersioningInput) (req *request.Request, output *PutBucketVersioningOutput) {
+        op := &request.Operation{
+                Name:       opPutBucketVersioning,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}?versioning",
+        }
+
+        if input == nil {
+                input = &PutBucketVersioningInput{}
+        }
+
+        output = &PutBucketVersioningOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// PutBucketVersioning API operation for Amazon Simple Storage Service.
+//
+// Sets the versioning state of an existing bucket. To set the versioning state,
+// you must be the bucket owner.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation PutBucketVersioning for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketVersioning
+func (c *S3) PutBucketVersioning(input *PutBucketVersioningInput) (*PutBucketVersioningOutput, error) {
+        req, out := c.PutBucketVersioningRequest(input)
+        return out, req.Send()
+}
+
+// PutBucketVersioningWithContext is the same as PutBucketVersioning with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutBucketVersioning for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) PutBucketVersioningWithContext(ctx aws.Context, input *PutBucketVersioningInput, opts ...request.Option) (*PutBucketVersioningOutput, error) {
+        req, out := c.PutBucketVersioningRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opPutBucketWebsite = "PutBucketWebsite"
+
+// PutBucketWebsiteRequest generates a "aws/request.Request" representing the
+// client's request for the PutBucketWebsite operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See PutBucketWebsite for usage and error information.
+//
+// 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 PutBucketWebsite method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the PutBucketWebsiteRequest method.
+//    req, resp := client.PutBucketWebsiteRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketWebsite
+func (c *S3) PutBucketWebsiteRequest(input *PutBucketWebsiteInput) (req *request.Request, output *PutBucketWebsiteOutput) {
+        op := &request.Operation{
+                Name:       opPutBucketWebsite,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}?website",
+        }
+
+        if input == nil {
+                input = &PutBucketWebsiteInput{}
+        }
+
+        output = &PutBucketWebsiteOutput{}
+        req = c.newRequest(op, input, output)
+        req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
+        req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+        return
+}
+
+// PutBucketWebsite API operation for Amazon Simple Storage Service.
+//
+// Set the website configuration for a bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation PutBucketWebsite for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketWebsite
+func (c *S3) PutBucketWebsite(input *PutBucketWebsiteInput) (*PutBucketWebsiteOutput, error) {
+        req, out := c.PutBucketWebsiteRequest(input)
+        return out, req.Send()
+}
+
+// PutBucketWebsiteWithContext is the same as PutBucketWebsite with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutBucketWebsite for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) PutBucketWebsiteWithContext(ctx aws.Context, input *PutBucketWebsiteInput, opts ...request.Option) (*PutBucketWebsiteOutput, error) {
+        req, out := c.PutBucketWebsiteRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opPutObject = "PutObject"
+
+// PutObjectRequest generates a "aws/request.Request" representing the
+// client's request for the PutObject operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See PutObject for usage and error information.
+//
+// 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 PutObject method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the PutObjectRequest method.
+//    req, resp := client.PutObjectRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObject
+func (c *S3) PutObjectRequest(input *PutObjectInput) (req *request.Request, output *PutObjectOutput) {
+        op := &request.Operation{
+                Name:       opPutObject,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}/{Key+}",
+        }
+
+        if input == nil {
+                input = &PutObjectInput{}
+        }
+
+        output = &PutObjectOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// PutObject API operation for Amazon Simple Storage Service.
+//
+// Adds an object to a bucket.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation PutObject for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObject
+func (c *S3) PutObject(input *PutObjectInput) (*PutObjectOutput, error) {
+        req, out := c.PutObjectRequest(input)
+        return out, req.Send()
+}
+
+// PutObjectWithContext is the same as PutObject with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutObject for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) PutObjectWithContext(ctx aws.Context, input *PutObjectInput, opts ...request.Option) (*PutObjectOutput, error) {
+        req, out := c.PutObjectRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opPutObjectAcl = "PutObjectAcl"
+
+// PutObjectAclRequest generates a "aws/request.Request" representing the
+// client's request for the PutObjectAcl operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See PutObjectAcl for usage and error information.
+//
+// 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 PutObjectAcl method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the PutObjectAclRequest method.
+//    req, resp := client.PutObjectAclRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObjectAcl
+func (c *S3) PutObjectAclRequest(input *PutObjectAclInput) (req *request.Request, output *PutObjectAclOutput) {
+        op := &request.Operation{
+                Name:       opPutObjectAcl,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}/{Key+}?acl",
+        }
+
+        if input == nil {
+                input = &PutObjectAclInput{}
+        }
+
+        output = &PutObjectAclOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// PutObjectAcl API operation for Amazon Simple Storage Service.
+//
+// uses the acl subresource to set the access control list (ACL) permissions
+// for an object that already exists in a bucket
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation PutObjectAcl for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchKey "NoSuchKey"
+//   The specified key does not exist.
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObjectAcl
+func (c *S3) PutObjectAcl(input *PutObjectAclInput) (*PutObjectAclOutput, error) {
+        req, out := c.PutObjectAclRequest(input)
+        return out, req.Send()
+}
+
+// PutObjectAclWithContext is the same as PutObjectAcl with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutObjectAcl for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) PutObjectAclWithContext(ctx aws.Context, input *PutObjectAclInput, opts ...request.Option) (*PutObjectAclOutput, error) {
+        req, out := c.PutObjectAclRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opPutObjectTagging = "PutObjectTagging"
+
+// PutObjectTaggingRequest generates a "aws/request.Request" representing the
+// client's request for the PutObjectTagging operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See PutObjectTagging for usage and error information.
+//
+// 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 PutObjectTagging method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the PutObjectTaggingRequest method.
+//    req, resp := client.PutObjectTaggingRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObjectTagging
+func (c *S3) PutObjectTaggingRequest(input *PutObjectTaggingInput) (req *request.Request, output *PutObjectTaggingOutput) {
+        op := &request.Operation{
+                Name:       opPutObjectTagging,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}/{Key+}?tagging",
+        }
+
+        if input == nil {
+                input = &PutObjectTaggingInput{}
+        }
+
+        output = &PutObjectTaggingOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// PutObjectTagging API operation for Amazon Simple Storage Service.
+//
+// Sets the supplied tag-set to an object that already exists in a bucket
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation PutObjectTagging for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObjectTagging
+func (c *S3) PutObjectTagging(input *PutObjectTaggingInput) (*PutObjectTaggingOutput, error) {
+        req, out := c.PutObjectTaggingRequest(input)
+        return out, req.Send()
+}
+
+// PutObjectTaggingWithContext is the same as PutObjectTagging with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutObjectTagging for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) PutObjectTaggingWithContext(ctx aws.Context, input *PutObjectTaggingInput, opts ...request.Option) (*PutObjectTaggingOutput, error) {
+        req, out := c.PutObjectTaggingRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opRestoreObject = "RestoreObject"
+
+// RestoreObjectRequest generates a "aws/request.Request" representing the
+// client's request for the RestoreObject operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See RestoreObject for usage and error information.
+//
+// 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 RestoreObject method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the RestoreObjectRequest method.
+//    req, resp := client.RestoreObjectRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/RestoreObject
+func (c *S3) RestoreObjectRequest(input *RestoreObjectInput) (req *request.Request, output *RestoreObjectOutput) {
+        op := &request.Operation{
+                Name:       opRestoreObject,
+                HTTPMethod: "POST",
+                HTTPPath:   "/{Bucket}/{Key+}?restore",
+        }
+
+        if input == nil {
+                input = &RestoreObjectInput{}
+        }
+
+        output = &RestoreObjectOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// RestoreObject API operation for Amazon Simple Storage Service.
+//
+// Restores an archived copy of an object back into Amazon S3
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation RestoreObject for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeObjectAlreadyInActiveTierError "ObjectAlreadyInActiveTierError"
+//   This operation is not allowed against this storage tier
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/RestoreObject
+func (c *S3) RestoreObject(input *RestoreObjectInput) (*RestoreObjectOutput, error) {
+        req, out := c.RestoreObjectRequest(input)
+        return out, req.Send()
+}
+
+// RestoreObjectWithContext is the same as RestoreObject with the addition of
+// the ability to pass a context and additional request options.
+//
+// See RestoreObject for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) RestoreObjectWithContext(ctx aws.Context, input *RestoreObjectInput, opts ...request.Option) (*RestoreObjectOutput, error) {
+        req, out := c.RestoreObjectRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opUploadPart = "UploadPart"
+
+// UploadPartRequest generates a "aws/request.Request" representing the
+// client's request for the UploadPart operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See UploadPart for usage and error information.
+//
+// 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 UploadPart method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the UploadPartRequest method.
+//    req, resp := client.UploadPartRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/UploadPart
+func (c *S3) UploadPartRequest(input *UploadPartInput) (req *request.Request, output *UploadPartOutput) {
+        op := &request.Operation{
+                Name:       opUploadPart,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}/{Key+}",
+        }
+
+        if input == nil {
+                input = &UploadPartInput{}
+        }
+
+        output = &UploadPartOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// UploadPart API operation for Amazon Simple Storage Service.
+//
+// Uploads a part in a multipart upload.
+//
+// Note: After you initiate multipart upload and upload one or more parts, you
+// must either complete or abort multipart upload in order to stop getting charged
+// for storage of the uploaded parts. Only after you either complete or abort
+// multipart upload, Amazon S3 frees up the parts storage and stops charging
+// you for the parts storage.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation UploadPart for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/UploadPart
+func (c *S3) UploadPart(input *UploadPartInput) (*UploadPartOutput, error) {
+        req, out := c.UploadPartRequest(input)
+        return out, req.Send()
+}
+
+// UploadPartWithContext is the same as UploadPart with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UploadPart for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) UploadPartWithContext(ctx aws.Context, input *UploadPartInput, opts ...request.Option) (*UploadPartOutput, error) {
+        req, out := c.UploadPartRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opUploadPartCopy = "UploadPartCopy"
+
+// UploadPartCopyRequest generates a "aws/request.Request" representing the
+// client's request for the UploadPartCopy operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See UploadPartCopy for usage and error information.
+//
+// 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 UploadPartCopy method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the UploadPartCopyRequest method.
+//    req, resp := client.UploadPartCopyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/UploadPartCopy
+func (c *S3) UploadPartCopyRequest(input *UploadPartCopyInput) (req *request.Request, output *UploadPartCopyOutput) {
+        op := &request.Operation{
+                Name:       opUploadPartCopy,
+                HTTPMethod: "PUT",
+                HTTPPath:   "/{Bucket}/{Key+}",
+        }
+
+        if input == nil {
+                input = &UploadPartCopyInput{}
+        }
+
+        output = &UploadPartCopyOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// UploadPartCopy API operation for Amazon Simple Storage Service.
+//
+// Uploads a part by copying data from an existing object as data source.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for Amazon Simple Storage Service's
+// API operation UploadPartCopy for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/UploadPartCopy
+func (c *S3) UploadPartCopy(input *UploadPartCopyInput) (*UploadPartCopyOutput, error) {
+        req, out := c.UploadPartCopyRequest(input)
+        return out, req.Send()
+}
+
+// UploadPartCopyWithContext is the same as UploadPartCopy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UploadPartCopy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) UploadPartCopyWithContext(ctx aws.Context, input *UploadPartCopyInput, opts ...request.Option) (*UploadPartCopyOutput, error) {
+        req, out := c.UploadPartCopyRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+// Specifies the days since the initiation of an Incomplete Multipart Upload
+// that Lifecycle will wait before permanently removing all parts of the upload.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AbortIncompleteMultipartUpload
+type AbortIncompleteMultipartUpload struct {
+        _ struct{} `type:"structure"`
+
+        // Indicates the number of days that must pass since initiation for Lifecycle
+        // to abort an Incomplete Multipart Upload.
+        DaysAfterInitiation *int64 `type:"integer"`
+}
+
+// String returns the string representation
+func (s AbortIncompleteMultipartUpload) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AbortIncompleteMultipartUpload) GoString() string {
+        return s.String()
+}
+
+// SetDaysAfterInitiation sets the DaysAfterInitiation field's value.
+func (s *AbortIncompleteMultipartUpload) SetDaysAfterInitiation(v int64) *AbortIncompleteMultipartUpload {
+        s.DaysAfterInitiation = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AbortMultipartUploadRequest
+type AbortMultipartUploadInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Key is a required field
+        Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`
+
+        // Confirms that the requester knows that she or he will be charged for the
+        // request. Bucket owners need not specify this parameter in their requests.
+        // Documentation on downloading objects from requester pays buckets can be found
+        // at http://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html
+        RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string" enum:"RequestPayer"`
+
+        // UploadId is a required field
+        UploadId *string `location:"querystring" locationName:"uploadId" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s AbortMultipartUploadInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AbortMultipartUploadInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *AbortMultipartUploadInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "AbortMultipartUploadInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+        if s.UploadId == nil {
+                invalidParams.Add(request.NewErrParamRequired("UploadId"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *AbortMultipartUploadInput) SetBucket(v string) *AbortMultipartUploadInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *AbortMultipartUploadInput) SetKey(v string) *AbortMultipartUploadInput {
+        s.Key = &v
+        return s
+}
+
+// SetRequestPayer sets the RequestPayer field's value.
+func (s *AbortMultipartUploadInput) SetRequestPayer(v string) *AbortMultipartUploadInput {
+        s.RequestPayer = &v
+        return s
+}
+
+// SetUploadId sets the UploadId field's value.
+func (s *AbortMultipartUploadInput) SetUploadId(v string) *AbortMultipartUploadInput {
+        s.UploadId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AbortMultipartUploadOutput
+type AbortMultipartUploadOutput struct {
+        _ struct{} `type:"structure"`
+
+        // If present, indicates that the requester was successfully charged for the
+        // request.
+        RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`
+}
+
+// String returns the string representation
+func (s AbortMultipartUploadOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AbortMultipartUploadOutput) GoString() string {
+        return s.String()
+}
+
+// SetRequestCharged sets the RequestCharged field's value.
+func (s *AbortMultipartUploadOutput) SetRequestCharged(v string) *AbortMultipartUploadOutput {
+        s.RequestCharged = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AccelerateConfiguration
+type AccelerateConfiguration struct {
+        _ struct{} `type:"structure"`
+
+        // The accelerate configuration of the bucket.
+        Status *string `type:"string" enum:"BucketAccelerateStatus"`
+}
+
+// String returns the string representation
+func (s AccelerateConfiguration) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AccelerateConfiguration) GoString() string {
+        return s.String()
+}
+
+// SetStatus sets the Status field's value.
+func (s *AccelerateConfiguration) SetStatus(v string) *AccelerateConfiguration {
+        s.Status = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AccessControlPolicy
+type AccessControlPolicy struct {
+        _ struct{} `type:"structure"`
+
+        // A list of grants.
+        Grants []*Grant `locationName:"AccessControlList" locationNameList:"Grant" type:"list"`
+
+        Owner *Owner `type:"structure"`
+}
+
+// String returns the string representation
+func (s AccessControlPolicy) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AccessControlPolicy) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *AccessControlPolicy) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "AccessControlPolicy"}
+        if s.Grants != nil {
+                for i, v := range s.Grants {
+                        if v == nil {
+                                continue
+                        }
+                        if err := v.Validate(); err != nil {
+                                invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Grants", i), err.(request.ErrInvalidParams))
+                        }
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetGrants sets the Grants field's value.
+func (s *AccessControlPolicy) SetGrants(v []*Grant) *AccessControlPolicy {
+        s.Grants = v
+        return s
+}
+
+// SetOwner sets the Owner field's value.
+func (s *AccessControlPolicy) SetOwner(v *Owner) *AccessControlPolicy {
+        s.Owner = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AnalyticsAndOperator
+type AnalyticsAndOperator struct {
+        _ struct{} `type:"structure"`
+
+        // The prefix to use when evaluating an AND predicate.
+        Prefix *string `type:"string"`
+
+        // The list of tags to use when evaluating an AND predicate.
+        Tags []*Tag `locationName:"Tag" locationNameList:"Tag" type:"list" flattened:"true"`
+}
+
+// String returns the string representation
+func (s AnalyticsAndOperator) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AnalyticsAndOperator) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *AnalyticsAndOperator) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "AnalyticsAndOperator"}
+        if s.Tags != nil {
+                for i, v := range s.Tags {
+                        if v == nil {
+                                continue
+                        }
+                        if err := v.Validate(); err != nil {
+                                invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams))
+                        }
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *AnalyticsAndOperator) SetPrefix(v string) *AnalyticsAndOperator {
+        s.Prefix = &v
+        return s
+}
+
+// SetTags sets the Tags field's value.
+func (s *AnalyticsAndOperator) SetTags(v []*Tag) *AnalyticsAndOperator {
+        s.Tags = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AnalyticsConfiguration
+type AnalyticsConfiguration struct {
+        _ struct{} `type:"structure"`
+
+        // The filter used to describe a set of objects for analyses. A filter must
+        // have exactly one prefix, one tag, or one conjunction (AnalyticsAndOperator).
+        // If no filter is provided, all objects will be considered in any analysis.
+        Filter *AnalyticsFilter `type:"structure"`
+
+        // The identifier used to represent an analytics configuration.
+        //
+        // Id is a required field
+        Id *string `type:"string" required:"true"`
+
+        // If present, it indicates that data related to access patterns will be collected
+        // and made available to analyze the tradeoffs between different storage classes.
+        //
+        // StorageClassAnalysis is a required field
+        StorageClassAnalysis *StorageClassAnalysis `type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s AnalyticsConfiguration) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AnalyticsConfiguration) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *AnalyticsConfiguration) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "AnalyticsConfiguration"}
+        if s.Id == nil {
+                invalidParams.Add(request.NewErrParamRequired("Id"))
+        }
+        if s.StorageClassAnalysis == nil {
+                invalidParams.Add(request.NewErrParamRequired("StorageClassAnalysis"))
+        }
+        if s.Filter != nil {
+                if err := s.Filter.Validate(); err != nil {
+                        invalidParams.AddNested("Filter", err.(request.ErrInvalidParams))
+                }
+        }
+        if s.StorageClassAnalysis != nil {
+                if err := s.StorageClassAnalysis.Validate(); err != nil {
+                        invalidParams.AddNested("StorageClassAnalysis", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetFilter sets the Filter field's value.
+func (s *AnalyticsConfiguration) SetFilter(v *AnalyticsFilter) *AnalyticsConfiguration {
+        s.Filter = v
+        return s
+}
+
+// SetId sets the Id field's value.
+func (s *AnalyticsConfiguration) SetId(v string) *AnalyticsConfiguration {
+        s.Id = &v
+        return s
+}
+
+// SetStorageClassAnalysis sets the StorageClassAnalysis field's value.
+func (s *AnalyticsConfiguration) SetStorageClassAnalysis(v *StorageClassAnalysis) *AnalyticsConfiguration {
+        s.StorageClassAnalysis = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AnalyticsExportDestination
+type AnalyticsExportDestination struct {
+        _ struct{} `type:"structure"`
+
+        // A destination signifying output to an S3 bucket.
+        //
+        // S3BucketDestination is a required field
+        S3BucketDestination *AnalyticsS3BucketDestination `type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s AnalyticsExportDestination) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AnalyticsExportDestination) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *AnalyticsExportDestination) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "AnalyticsExportDestination"}
+        if s.S3BucketDestination == nil {
+                invalidParams.Add(request.NewErrParamRequired("S3BucketDestination"))
+        }
+        if s.S3BucketDestination != nil {
+                if err := s.S3BucketDestination.Validate(); err != nil {
+                        invalidParams.AddNested("S3BucketDestination", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetS3BucketDestination sets the S3BucketDestination field's value.
+func (s *AnalyticsExportDestination) SetS3BucketDestination(v *AnalyticsS3BucketDestination) *AnalyticsExportDestination {
+        s.S3BucketDestination = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AnalyticsFilter
+type AnalyticsFilter struct {
+        _ struct{} `type:"structure"`
+
+        // A conjunction (logical AND) of predicates, which is used in evaluating an
+        // analytics filter. The operator must have at least two predicates.
+        And *AnalyticsAndOperator `type:"structure"`
+
+        // The prefix to use when evaluating an analytics filter.
+        Prefix *string `type:"string"`
+
+        // The tag to use when evaluating an analytics filter.
+        Tag *Tag `type:"structure"`
+}
+
+// String returns the string representation
+func (s AnalyticsFilter) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AnalyticsFilter) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *AnalyticsFilter) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "AnalyticsFilter"}
+        if s.And != nil {
+                if err := s.And.Validate(); err != nil {
+                        invalidParams.AddNested("And", err.(request.ErrInvalidParams))
+                }
+        }
+        if s.Tag != nil {
+                if err := s.Tag.Validate(); err != nil {
+                        invalidParams.AddNested("Tag", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetAnd sets the And field's value.
+func (s *AnalyticsFilter) SetAnd(v *AnalyticsAndOperator) *AnalyticsFilter {
+        s.And = v
+        return s
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *AnalyticsFilter) SetPrefix(v string) *AnalyticsFilter {
+        s.Prefix = &v
+        return s
+}
+
+// SetTag sets the Tag field's value.
+func (s *AnalyticsFilter) SetTag(v *Tag) *AnalyticsFilter {
+        s.Tag = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AnalyticsS3BucketDestination
+type AnalyticsS3BucketDestination struct {
+        _ struct{} `type:"structure"`
+
+        // The Amazon resource name (ARN) of the bucket to which data is exported.
+        //
+        // Bucket is a required field
+        Bucket *string `type:"string" required:"true"`
+
+        // The account ID that owns the destination bucket. If no account ID is provided,
+        // the owner will not be validated prior to exporting data.
+        BucketAccountId *string `type:"string"`
+
+        // The file format used when exporting data to Amazon S3.
+        //
+        // Format is a required field
+        Format *string `type:"string" required:"true" enum:"AnalyticsS3ExportFileFormat"`
+
+        // The prefix to use when exporting data. The exported data begins with this
+        // prefix.
+        Prefix *string `type:"string"`
+}
+
+// String returns the string representation
+func (s AnalyticsS3BucketDestination) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AnalyticsS3BucketDestination) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *AnalyticsS3BucketDestination) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "AnalyticsS3BucketDestination"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Format == nil {
+                invalidParams.Add(request.NewErrParamRequired("Format"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *AnalyticsS3BucketDestination) SetBucket(v string) *AnalyticsS3BucketDestination {
+        s.Bucket = &v
+        return s
+}
+
+// SetBucketAccountId sets the BucketAccountId field's value.
+func (s *AnalyticsS3BucketDestination) SetBucketAccountId(v string) *AnalyticsS3BucketDestination {
+        s.BucketAccountId = &v
+        return s
+}
+
+// SetFormat sets the Format field's value.
+func (s *AnalyticsS3BucketDestination) SetFormat(v string) *AnalyticsS3BucketDestination {
+        s.Format = &v
+        return s
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *AnalyticsS3BucketDestination) SetPrefix(v string) *AnalyticsS3BucketDestination {
+        s.Prefix = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Bucket
+type Bucket struct {
+        _ struct{} `type:"structure"`
+
+        // Date the bucket was created.
+        CreationDate *time.Time `type:"timestamp" timestampFormat:"iso8601"`
+
+        // The name of the bucket.
+        Name *string `type:"string"`
+}
+
+// String returns the string representation
+func (s Bucket) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Bucket) GoString() string {
+        return s.String()
+}
+
+// SetCreationDate sets the CreationDate field's value.
+func (s *Bucket) SetCreationDate(v time.Time) *Bucket {
+        s.CreationDate = &v
+        return s
+}
+
+// SetName sets the Name field's value.
+func (s *Bucket) SetName(v string) *Bucket {
+        s.Name = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/BucketLifecycleConfiguration
+type BucketLifecycleConfiguration struct {
+        _ struct{} `type:"structure"`
+
+        // Rules is a required field
+        Rules []*LifecycleRule `locationName:"Rule" type:"list" flattened:"true" required:"true"`
+}
+
+// String returns the string representation
+func (s BucketLifecycleConfiguration) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s BucketLifecycleConfiguration) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *BucketLifecycleConfiguration) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "BucketLifecycleConfiguration"}
+        if s.Rules == nil {
+                invalidParams.Add(request.NewErrParamRequired("Rules"))
+        }
+        if s.Rules != nil {
+                for i, v := range s.Rules {
+                        if v == nil {
+                                continue
+                        }
+                        if err := v.Validate(); err != nil {
+                                invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Rules", i), err.(request.ErrInvalidParams))
+                        }
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetRules sets the Rules field's value.
+func (s *BucketLifecycleConfiguration) SetRules(v []*LifecycleRule) *BucketLifecycleConfiguration {
+        s.Rules = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/BucketLoggingStatus
+type BucketLoggingStatus struct {
+        _ struct{} `type:"structure"`
+
+        LoggingEnabled *LoggingEnabled `type:"structure"`
+}
+
+// String returns the string representation
+func (s BucketLoggingStatus) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s BucketLoggingStatus) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *BucketLoggingStatus) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "BucketLoggingStatus"}
+        if s.LoggingEnabled != nil {
+                if err := s.LoggingEnabled.Validate(); err != nil {
+                        invalidParams.AddNested("LoggingEnabled", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetLoggingEnabled sets the LoggingEnabled field's value.
+func (s *BucketLoggingStatus) SetLoggingEnabled(v *LoggingEnabled) *BucketLoggingStatus {
+        s.LoggingEnabled = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CORSConfiguration
+type CORSConfiguration struct {
+        _ struct{} `type:"structure"`
+
+        // CORSRules is a required field
+        CORSRules []*CORSRule `locationName:"CORSRule" type:"list" flattened:"true" required:"true"`
+}
+
+// String returns the string representation
+func (s CORSConfiguration) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CORSConfiguration) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *CORSConfiguration) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "CORSConfiguration"}
+        if s.CORSRules == nil {
+                invalidParams.Add(request.NewErrParamRequired("CORSRules"))
+        }
+        if s.CORSRules != nil {
+                for i, v := range s.CORSRules {
+                        if v == nil {
+                                continue
+                        }
+                        if err := v.Validate(); err != nil {
+                                invalidParams.AddNested(fmt.Sprintf("%s[%v]", "CORSRules", i), err.(request.ErrInvalidParams))
+                        }
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetCORSRules sets the CORSRules field's value.
+func (s *CORSConfiguration) SetCORSRules(v []*CORSRule) *CORSConfiguration {
+        s.CORSRules = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CORSRule
+type CORSRule struct {
+        _ struct{} `type:"structure"`
+
+        // Specifies which headers are allowed in a pre-flight OPTIONS request.
+        AllowedHeaders []*string `locationName:"AllowedHeader" type:"list" flattened:"true"`
+
+        // Identifies HTTP methods that the domain/origin specified in the rule is allowed
+        // to execute.
+        //
+        // AllowedMethods is a required field
+        AllowedMethods []*string `locationName:"AllowedMethod" type:"list" flattened:"true" required:"true"`
+
+        // One or more origins you want customers to be able to access the bucket from.
+        //
+        // AllowedOrigins is a required field
+        AllowedOrigins []*string `locationName:"AllowedOrigin" type:"list" flattened:"true" required:"true"`
+
+        // One or more headers in the response that you want customers to be able to
+        // access from their applications (for example, from a JavaScript XMLHttpRequest
+        // object).
+        ExposeHeaders []*string `locationName:"ExposeHeader" type:"list" flattened:"true"`
+
+        // The time in seconds that your browser is to cache the preflight response
+        // for the specified resource.
+        MaxAgeSeconds *int64 `type:"integer"`
+}
+
+// String returns the string representation
+func (s CORSRule) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CORSRule) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *CORSRule) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "CORSRule"}
+        if s.AllowedMethods == nil {
+                invalidParams.Add(request.NewErrParamRequired("AllowedMethods"))
+        }
+        if s.AllowedOrigins == nil {
+                invalidParams.Add(request.NewErrParamRequired("AllowedOrigins"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetAllowedHeaders sets the AllowedHeaders field's value.
+func (s *CORSRule) SetAllowedHeaders(v []*string) *CORSRule {
+        s.AllowedHeaders = v
+        return s
+}
+
+// SetAllowedMethods sets the AllowedMethods field's value.
+func (s *CORSRule) SetAllowedMethods(v []*string) *CORSRule {
+        s.AllowedMethods = v
+        return s
+}
+
+// SetAllowedOrigins sets the AllowedOrigins field's value.
+func (s *CORSRule) SetAllowedOrigins(v []*string) *CORSRule {
+        s.AllowedOrigins = v
+        return s
+}
+
+// SetExposeHeaders sets the ExposeHeaders field's value.
+func (s *CORSRule) SetExposeHeaders(v []*string) *CORSRule {
+        s.ExposeHeaders = v
+        return s
+}
+
+// SetMaxAgeSeconds sets the MaxAgeSeconds field's value.
+func (s *CORSRule) SetMaxAgeSeconds(v int64) *CORSRule {
+        s.MaxAgeSeconds = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CloudFunctionConfiguration
+type CloudFunctionConfiguration struct {
+        _ struct{} `type:"structure"`
+
+        CloudFunction *string `type:"string"`
+
+        // Bucket event for which to send notifications.
+        Event *string `deprecated:"true" type:"string" enum:"Event"`
+
+        Events []*string `locationName:"Event" type:"list" flattened:"true"`
+
+        // Optional unique identifier for configurations in a notification configuration.
+        // If you don't provide one, Amazon S3 will assign an ID.
+        Id *string `type:"string"`
+
+        InvocationRole *string `type:"string"`
+}
+
+// String returns the string representation
+func (s CloudFunctionConfiguration) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CloudFunctionConfiguration) GoString() string {
+        return s.String()
+}
+
+// SetCloudFunction sets the CloudFunction field's value.
+func (s *CloudFunctionConfiguration) SetCloudFunction(v string) *CloudFunctionConfiguration {
+        s.CloudFunction = &v
+        return s
+}
+
+// SetEvent sets the Event field's value.
+func (s *CloudFunctionConfiguration) SetEvent(v string) *CloudFunctionConfiguration {
+        s.Event = &v
+        return s
+}
+
+// SetEvents sets the Events field's value.
+func (s *CloudFunctionConfiguration) SetEvents(v []*string) *CloudFunctionConfiguration {
+        s.Events = v
+        return s
+}
+
+// SetId sets the Id field's value.
+func (s *CloudFunctionConfiguration) SetId(v string) *CloudFunctionConfiguration {
+        s.Id = &v
+        return s
+}
+
+// SetInvocationRole sets the InvocationRole field's value.
+func (s *CloudFunctionConfiguration) SetInvocationRole(v string) *CloudFunctionConfiguration {
+        s.InvocationRole = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CommonPrefix
+type CommonPrefix struct {
+        _ struct{} `type:"structure"`
+
+        Prefix *string `type:"string"`
+}
+
+// String returns the string representation
+func (s CommonPrefix) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CommonPrefix) GoString() string {
+        return s.String()
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *CommonPrefix) SetPrefix(v string) *CommonPrefix {
+        s.Prefix = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CompleteMultipartUploadRequest
+type CompleteMultipartUploadInput struct {
+        _ struct{} `type:"structure" payload:"MultipartUpload"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Key is a required field
+        Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`
+
+        MultipartUpload *CompletedMultipartUpload `locationName:"CompleteMultipartUpload" type:"structure"`
+
+        // Confirms that the requester knows that she or he will be charged for the
+        // request. Bucket owners need not specify this parameter in their requests.
+        // Documentation on downloading objects from requester pays buckets can be found
+        // at http://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html
+        RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string" enum:"RequestPayer"`
+
+        // UploadId is a required field
+        UploadId *string `location:"querystring" locationName:"uploadId" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s CompleteMultipartUploadInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CompleteMultipartUploadInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *CompleteMultipartUploadInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "CompleteMultipartUploadInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+        if s.UploadId == nil {
+                invalidParams.Add(request.NewErrParamRequired("UploadId"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *CompleteMultipartUploadInput) SetBucket(v string) *CompleteMultipartUploadInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *CompleteMultipartUploadInput) SetKey(v string) *CompleteMultipartUploadInput {
+        s.Key = &v
+        return s
+}
+
+// SetMultipartUpload sets the MultipartUpload field's value.
+func (s *CompleteMultipartUploadInput) SetMultipartUpload(v *CompletedMultipartUpload) *CompleteMultipartUploadInput {
+        s.MultipartUpload = v
+        return s
+}
+
+// SetRequestPayer sets the RequestPayer field's value.
+func (s *CompleteMultipartUploadInput) SetRequestPayer(v string) *CompleteMultipartUploadInput {
+        s.RequestPayer = &v
+        return s
+}
+
+// SetUploadId sets the UploadId field's value.
+func (s *CompleteMultipartUploadInput) SetUploadId(v string) *CompleteMultipartUploadInput {
+        s.UploadId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CompleteMultipartUploadOutput
+type CompleteMultipartUploadOutput struct {
+        _ struct{} `type:"structure"`
+
+        Bucket *string `type:"string"`
+
+        // Entity tag of the object.
+        ETag *string `type:"string"`
+
+        // If the object expiration is configured, this will contain the expiration
+        // date (expiry-date) and rule ID (rule-id). The value of rule-id is URL encoded.
+        Expiration *string `location:"header" locationName:"x-amz-expiration" type:"string"`
+
+        Key *string `min:"1" type:"string"`
+
+        Location *string `type:"string"`
+
+        // If present, indicates that the requester was successfully charged for the
+        // request.
+        RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`
+
+        // If present, specifies the ID of the AWS Key Management Service (KMS) master
+        // encryption key that was used for the object.
+        SSEKMSKeyId *string `location:"header" locationName:"x-amz-server-side-encryption-aws-kms-key-id" type:"string"`
+
+        // The Server-side encryption algorithm used when storing this object in S3
+        // (e.g., AES256, aws:kms).
+        ServerSideEncryption *string `location:"header" locationName:"x-amz-server-side-encryption" type:"string" enum:"ServerSideEncryption"`
+
+        // Version of the object.
+        VersionId *string `location:"header" locationName:"x-amz-version-id" type:"string"`
+}
+
+// String returns the string representation
+func (s CompleteMultipartUploadOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CompleteMultipartUploadOutput) GoString() string {
+        return s.String()
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *CompleteMultipartUploadOutput) SetBucket(v string) *CompleteMultipartUploadOutput {
+        s.Bucket = &v
+        return s
+}
+
+// SetETag sets the ETag field's value.
+func (s *CompleteMultipartUploadOutput) SetETag(v string) *CompleteMultipartUploadOutput {
+        s.ETag = &v
+        return s
+}
+
+// SetExpiration sets the Expiration field's value.
+func (s *CompleteMultipartUploadOutput) SetExpiration(v string) *CompleteMultipartUploadOutput {
+        s.Expiration = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *CompleteMultipartUploadOutput) SetKey(v string) *CompleteMultipartUploadOutput {
+        s.Key = &v
+        return s
+}
+
+// SetLocation sets the Location field's value.
+func (s *CompleteMultipartUploadOutput) SetLocation(v string) *CompleteMultipartUploadOutput {
+        s.Location = &v
+        return s
+}
+
+// SetRequestCharged sets the RequestCharged field's value.
+func (s *CompleteMultipartUploadOutput) SetRequestCharged(v string) *CompleteMultipartUploadOutput {
+        s.RequestCharged = &v
+        return s
+}
+
+// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.
+func (s *CompleteMultipartUploadOutput) SetSSEKMSKeyId(v string) *CompleteMultipartUploadOutput {
+        s.SSEKMSKeyId = &v
+        return s
+}
+
+// SetServerSideEncryption sets the ServerSideEncryption field's value.
+func (s *CompleteMultipartUploadOutput) SetServerSideEncryption(v string) *CompleteMultipartUploadOutput {
+        s.ServerSideEncryption = &v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *CompleteMultipartUploadOutput) SetVersionId(v string) *CompleteMultipartUploadOutput {
+        s.VersionId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CompletedMultipartUpload
+type CompletedMultipartUpload struct {
+        _ struct{} `type:"structure"`
+
+        Parts []*CompletedPart `locationName:"Part" type:"list" flattened:"true"`
+}
+
+// String returns the string representation
+func (s CompletedMultipartUpload) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CompletedMultipartUpload) GoString() string {
+        return s.String()
+}
+
+// SetParts sets the Parts field's value.
+func (s *CompletedMultipartUpload) SetParts(v []*CompletedPart) *CompletedMultipartUpload {
+        s.Parts = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CompletedPart
+type CompletedPart struct {
+        _ struct{} `type:"structure"`
+
+        // Entity tag returned when the part was uploaded.
+        ETag *string `type:"string"`
+
+        // Part number that identifies the part. This is a positive integer between
+        // 1 and 10,000.
+        PartNumber *int64 `type:"integer"`
+}
+
+// String returns the string representation
+func (s CompletedPart) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CompletedPart) GoString() string {
+        return s.String()
+}
+
+// SetETag sets the ETag field's value.
+func (s *CompletedPart) SetETag(v string) *CompletedPart {
+        s.ETag = &v
+        return s
+}
+
+// SetPartNumber sets the PartNumber field's value.
+func (s *CompletedPart) SetPartNumber(v int64) *CompletedPart {
+        s.PartNumber = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Condition
+type Condition struct {
+        _ struct{} `type:"structure"`
+
+        // The HTTP error code when the redirect is applied. In the event of an error,
+        // if the error code equals this value, then the specified redirect is applied.
+        // Required when parent element Condition is specified and sibling KeyPrefixEquals
+        // is not specified. If both are specified, then both must be true for the redirect
+        // to be applied.
+        HttpErrorCodeReturnedEquals *string `type:"string"`
+
+        // The object key name prefix when the redirect is applied. For example, to
+        // redirect requests for ExamplePage.html, the key prefix will be ExamplePage.html.
+        // To redirect request for all pages with the prefix docs/, the key prefix will
+        // be /docs, which identifies all objects in the docs/ folder. Required when
+        // the parent element Condition is specified and sibling HttpErrorCodeReturnedEquals
+        // is not specified. If both conditions are specified, both must be true for
+        // the redirect to be applied.
+        KeyPrefixEquals *string `type:"string"`
+}
+
+// String returns the string representation
+func (s Condition) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Condition) GoString() string {
+        return s.String()
+}
+
+// SetHttpErrorCodeReturnedEquals sets the HttpErrorCodeReturnedEquals field's value.
+func (s *Condition) SetHttpErrorCodeReturnedEquals(v string) *Condition {
+        s.HttpErrorCodeReturnedEquals = &v
+        return s
+}
+
+// SetKeyPrefixEquals sets the KeyPrefixEquals field's value.
+func (s *Condition) SetKeyPrefixEquals(v string) *Condition {
+        s.KeyPrefixEquals = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CopyObjectRequest
+type CopyObjectInput struct {
+        _ struct{} `type:"structure"`
+
+        // The canned ACL to apply to the object.
+        ACL *string `location:"header" locationName:"x-amz-acl" type:"string" enum:"ObjectCannedACL"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Specifies caching behavior along the request/reply chain.
+        CacheControl *string `location:"header" locationName:"Cache-Control" type:"string"`
+
+        // Specifies presentational information for the object.
+        ContentDisposition *string `location:"header" locationName:"Content-Disposition" type:"string"`
+
+        // Specifies what content encodings have been applied to the object and thus
+        // what decoding mechanisms must be applied to obtain the media-type referenced
+        // by the Content-Type header field.
+        ContentEncoding *string `location:"header" locationName:"Content-Encoding" type:"string"`
+
+        // The language the content is in.
+        ContentLanguage *string `location:"header" locationName:"Content-Language" type:"string"`
+
+        // A standard MIME type describing the format of the object data.
+        ContentType *string `location:"header" locationName:"Content-Type" type:"string"`
+
+        // The name of the source bucket and key name of the source object, separated
+        // by a slash (/). Must be URL-encoded.
+        //
+        // CopySource is a required field
+        CopySource *string `location:"header" locationName:"x-amz-copy-source" type:"string" required:"true"`
+
+        // Copies the object if its entity tag (ETag) matches the specified tag.
+        CopySourceIfMatch *string `location:"header" locationName:"x-amz-copy-source-if-match" type:"string"`
+
+        // Copies the object if it has been modified since the specified time.
+        CopySourceIfModifiedSince *time.Time `location:"header" locationName:"x-amz-copy-source-if-modified-since" type:"timestamp" timestampFormat:"rfc822"`
+
+        // Copies the object if its entity tag (ETag) is different than the specified
+        // ETag.
+        CopySourceIfNoneMatch *string `location:"header" locationName:"x-amz-copy-source-if-none-match" type:"string"`
+
+        // Copies the object if it hasn't been modified since the specified time.
+        CopySourceIfUnmodifiedSince *time.Time `location:"header" locationName:"x-amz-copy-source-if-unmodified-since" type:"timestamp" timestampFormat:"rfc822"`
+
+        // Specifies the algorithm to use when decrypting the source object (e.g., AES256).
+        CopySourceSSECustomerAlgorithm *string `location:"header" locationName:"x-amz-copy-source-server-side-encryption-customer-algorithm" type:"string"`
+
+        // Specifies the customer-provided encryption key for Amazon S3 to use to decrypt
+        // the source object. The encryption key provided in this header must be one
+        // that was used when the source object was created.
+        CopySourceSSECustomerKey *string `location:"header" locationName:"x-amz-copy-source-server-side-encryption-customer-key" type:"string"`
+
+        // Specifies the 128-bit MD5 digest of the encryption key according to RFC 1321.
+        // Amazon S3 uses this header for a message integrity check to ensure the encryption
+        // key was transmitted without error.
+        CopySourceSSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-copy-source-server-side-encryption-customer-key-MD5" type:"string"`
+
+        // The date and time at which the object is no longer cacheable.
+        Expires *time.Time `location:"header" locationName:"Expires" type:"timestamp" timestampFormat:"rfc822"`
+
+        // Gives the grantee READ, READ_ACP, and WRITE_ACP permissions on the object.
+        GrantFullControl *string `location:"header" locationName:"x-amz-grant-full-control" type:"string"`
+
+        // Allows grantee to read the object data and its metadata.
+        GrantRead *string `location:"header" locationName:"x-amz-grant-read" type:"string"`
+
+        // Allows grantee to read the object ACL.
+        GrantReadACP *string `location:"header" locationName:"x-amz-grant-read-acp" type:"string"`
+
+        // Allows grantee to write the ACL for the applicable object.
+        GrantWriteACP *string `location:"header" locationName:"x-amz-grant-write-acp" type:"string"`
+
+        // Key is a required field
+        Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`
+
+        // A map of metadata to store with the object in S3.
+        Metadata map[string]*string `location:"headers" locationName:"x-amz-meta-" type:"map"`
+
+        // Specifies whether the metadata is copied from the source object or replaced
+        // with metadata provided in the request.
+        MetadataDirective *string `location:"header" locationName:"x-amz-metadata-directive" type:"string" enum:"MetadataDirective"`
+
+        // Confirms that the requester knows that she or he will be charged for the
+        // request. Bucket owners need not specify this parameter in their requests.
+        // Documentation on downloading objects from requester pays buckets can be found
+        // at http://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html
+        RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string" enum:"RequestPayer"`
+
+        // Specifies the algorithm to use to when encrypting the object (e.g., AES256).
+        SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`
+
+        // Specifies the customer-provided encryption key for Amazon S3 to use in encrypting
+        // data. This value is used to store the object and then it is discarded; Amazon
+        // does not store the encryption key. The key must be appropriate for use with
+        // the algorithm specified in the x-amz-server-side​-encryption​-customer-algorithm
+        // header.
+        SSECustomerKey *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key" type:"string"`
+
+        // Specifies the 128-bit MD5 digest of the encryption key according to RFC 1321.
+        // Amazon S3 uses this header for a message integrity check to ensure the encryption
+        // key was transmitted without error.
+        SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`
+
+        // Specifies the AWS KMS key ID to use for object encryption. All GET and PUT
+        // requests for an object protected by AWS KMS will fail if not made via SSL
+        // or using SigV4. Documentation on configuring any of the officially supported
+        // AWS SDKs and CLI can be found at http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingAWSSDK.html#specify-signature-version
+        SSEKMSKeyId *string `location:"header" locationName:"x-amz-server-side-encryption-aws-kms-key-id" type:"string"`
+
+        // The Server-side encryption algorithm used when storing this object in S3
+        // (e.g., AES256, aws:kms).
+        ServerSideEncryption *string `location:"header" locationName:"x-amz-server-side-encryption" type:"string" enum:"ServerSideEncryption"`
+
+        // The type of storage to use for the object. Defaults to 'STANDARD'.
+        StorageClass *string `location:"header" locationName:"x-amz-storage-class" type:"string" enum:"StorageClass"`
+
+        // The tag-set for the object destination object this value must be used in
+        // conjunction with the TaggingDirective. The tag-set must be encoded as URL
+        // Query parameters
+        Tagging *string `location:"header" locationName:"x-amz-tagging" type:"string"`
+
+        // Specifies whether the object tag-set are copied from the source object or
+        // replaced with tag-set provided in the request.
+        TaggingDirective *string `location:"header" locationName:"x-amz-tagging-directive" type:"string" enum:"TaggingDirective"`
+
+        // If the bucket is configured as a website, redirects requests for this object
+        // to another object in the same bucket or to an external URL. Amazon S3 stores
+        // the value of this header in the object metadata.
+        WebsiteRedirectLocation *string `location:"header" locationName:"x-amz-website-redirect-location" type:"string"`
+}
+
+// String returns the string representation
+func (s CopyObjectInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CopyObjectInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *CopyObjectInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "CopyObjectInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.CopySource == nil {
+                invalidParams.Add(request.NewErrParamRequired("CopySource"))
+        }
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetACL sets the ACL field's value.
+func (s *CopyObjectInput) SetACL(v string) *CopyObjectInput {
+        s.ACL = &v
+        return s
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *CopyObjectInput) SetBucket(v string) *CopyObjectInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetCacheControl sets the CacheControl field's value.
+func (s *CopyObjectInput) SetCacheControl(v string) *CopyObjectInput {
+        s.CacheControl = &v
+        return s
+}
+
+// SetContentDisposition sets the ContentDisposition field's value.
+func (s *CopyObjectInput) SetContentDisposition(v string) *CopyObjectInput {
+        s.ContentDisposition = &v
+        return s
+}
+
+// SetContentEncoding sets the ContentEncoding field's value.
+func (s *CopyObjectInput) SetContentEncoding(v string) *CopyObjectInput {
+        s.ContentEncoding = &v
+        return s
+}
+
+// SetContentLanguage sets the ContentLanguage field's value.
+func (s *CopyObjectInput) SetContentLanguage(v string) *CopyObjectInput {
+        s.ContentLanguage = &v
+        return s
+}
+
+// SetContentType sets the ContentType field's value.
+func (s *CopyObjectInput) SetContentType(v string) *CopyObjectInput {
+        s.ContentType = &v
+        return s
+}
+
+// SetCopySource sets the CopySource field's value.
+func (s *CopyObjectInput) SetCopySource(v string) *CopyObjectInput {
+        s.CopySource = &v
+        return s
+}
+
+// SetCopySourceIfMatch sets the CopySourceIfMatch field's value.
+func (s *CopyObjectInput) SetCopySourceIfMatch(v string) *CopyObjectInput {
+        s.CopySourceIfMatch = &v
+        return s
+}
+
+// SetCopySourceIfModifiedSince sets the CopySourceIfModifiedSince field's value.
+func (s *CopyObjectInput) SetCopySourceIfModifiedSince(v time.Time) *CopyObjectInput {
+        s.CopySourceIfModifiedSince = &v
+        return s
+}
+
+// SetCopySourceIfNoneMatch sets the CopySourceIfNoneMatch field's value.
+func (s *CopyObjectInput) SetCopySourceIfNoneMatch(v string) *CopyObjectInput {
+        s.CopySourceIfNoneMatch = &v
+        return s
+}
+
+// SetCopySourceIfUnmodifiedSince sets the CopySourceIfUnmodifiedSince field's value.
+func (s *CopyObjectInput) SetCopySourceIfUnmodifiedSince(v time.Time) *CopyObjectInput {
+        s.CopySourceIfUnmodifiedSince = &v
+        return s
+}
+
+// SetCopySourceSSECustomerAlgorithm sets the CopySourceSSECustomerAlgorithm field's value.
+func (s *CopyObjectInput) SetCopySourceSSECustomerAlgorithm(v string) *CopyObjectInput {
+        s.CopySourceSSECustomerAlgorithm = &v
+        return s
+}
+
+// SetCopySourceSSECustomerKey sets the CopySourceSSECustomerKey field's value.
+func (s *CopyObjectInput) SetCopySourceSSECustomerKey(v string) *CopyObjectInput {
+        s.CopySourceSSECustomerKey = &v
+        return s
+}
+
+// SetCopySourceSSECustomerKeyMD5 sets the CopySourceSSECustomerKeyMD5 field's value.
+func (s *CopyObjectInput) SetCopySourceSSECustomerKeyMD5(v string) *CopyObjectInput {
+        s.CopySourceSSECustomerKeyMD5 = &v
+        return s
+}
+
+// SetExpires sets the Expires field's value.
+func (s *CopyObjectInput) SetExpires(v time.Time) *CopyObjectInput {
+        s.Expires = &v
+        return s
+}
+
+// SetGrantFullControl sets the GrantFullControl field's value.
+func (s *CopyObjectInput) SetGrantFullControl(v string) *CopyObjectInput {
+        s.GrantFullControl = &v
+        return s
+}
+
+// SetGrantRead sets the GrantRead field's value.
+func (s *CopyObjectInput) SetGrantRead(v string) *CopyObjectInput {
+        s.GrantRead = &v
+        return s
+}
+
+// SetGrantReadACP sets the GrantReadACP field's value.
+func (s *CopyObjectInput) SetGrantReadACP(v string) *CopyObjectInput {
+        s.GrantReadACP = &v
+        return s
+}
+
+// SetGrantWriteACP sets the GrantWriteACP field's value.
+func (s *CopyObjectInput) SetGrantWriteACP(v string) *CopyObjectInput {
+        s.GrantWriteACP = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *CopyObjectInput) SetKey(v string) *CopyObjectInput {
+        s.Key = &v
+        return s
+}
+
+// SetMetadata sets the Metadata field's value.
+func (s *CopyObjectInput) SetMetadata(v map[string]*string) *CopyObjectInput {
+        s.Metadata = v
+        return s
+}
+
+// SetMetadataDirective sets the MetadataDirective field's value.
+func (s *CopyObjectInput) SetMetadataDirective(v string) *CopyObjectInput {
+        s.MetadataDirective = &v
+        return s
+}
+
+// SetRequestPayer sets the RequestPayer field's value.
+func (s *CopyObjectInput) SetRequestPayer(v string) *CopyObjectInput {
+        s.RequestPayer = &v
+        return s
+}
+
+// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.
+func (s *CopyObjectInput) SetSSECustomerAlgorithm(v string) *CopyObjectInput {
+        s.SSECustomerAlgorithm = &v
+        return s
+}
+
+// SetSSECustomerKey sets the SSECustomerKey field's value.
+func (s *CopyObjectInput) SetSSECustomerKey(v string) *CopyObjectInput {
+        s.SSECustomerKey = &v
+        return s
+}
+
+// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.
+func (s *CopyObjectInput) SetSSECustomerKeyMD5(v string) *CopyObjectInput {
+        s.SSECustomerKeyMD5 = &v
+        return s
+}
+
+// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.
+func (s *CopyObjectInput) SetSSEKMSKeyId(v string) *CopyObjectInput {
+        s.SSEKMSKeyId = &v
+        return s
+}
+
+// SetServerSideEncryption sets the ServerSideEncryption field's value.
+func (s *CopyObjectInput) SetServerSideEncryption(v string) *CopyObjectInput {
+        s.ServerSideEncryption = &v
+        return s
+}
+
+// SetStorageClass sets the StorageClass field's value.
+func (s *CopyObjectInput) SetStorageClass(v string) *CopyObjectInput {
+        s.StorageClass = &v
+        return s
+}
+
+// SetTagging sets the Tagging field's value.
+func (s *CopyObjectInput) SetTagging(v string) *CopyObjectInput {
+        s.Tagging = &v
+        return s
+}
+
+// SetTaggingDirective sets the TaggingDirective field's value.
+func (s *CopyObjectInput) SetTaggingDirective(v string) *CopyObjectInput {
+        s.TaggingDirective = &v
+        return s
+}
+
+// SetWebsiteRedirectLocation sets the WebsiteRedirectLocation field's value.
+func (s *CopyObjectInput) SetWebsiteRedirectLocation(v string) *CopyObjectInput {
+        s.WebsiteRedirectLocation = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CopyObjectOutput
+type CopyObjectOutput struct {
+        _ struct{} `type:"structure" payload:"CopyObjectResult"`
+
+        CopyObjectResult *CopyObjectResult `type:"structure"`
+
+        CopySourceVersionId *string `location:"header" locationName:"x-amz-copy-source-version-id" type:"string"`
+
+        // If the object expiration is configured, the response includes this header.
+        Expiration *string `location:"header" locationName:"x-amz-expiration" type:"string"`
+
+        // If present, indicates that the requester was successfully charged for the
+        // request.
+        RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`
+
+        // If server-side encryption with a customer-provided encryption key was requested,
+        // the response will include this header confirming the encryption algorithm
+        // used.
+        SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`
+
+        // If server-side encryption with a customer-provided encryption key was requested,
+        // the response will include this header to provide round trip message integrity
+        // verification of the customer-provided encryption key.
+        SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`
+
+        // If present, specifies the ID of the AWS Key Management Service (KMS) master
+        // encryption key that was used for the object.
+        SSEKMSKeyId *string `location:"header" locationName:"x-amz-server-side-encryption-aws-kms-key-id" type:"string"`
+
+        // The Server-side encryption algorithm used when storing this object in S3
+        // (e.g., AES256, aws:kms).
+        ServerSideEncryption *string `location:"header" locationName:"x-amz-server-side-encryption" type:"string" enum:"ServerSideEncryption"`
+
+        // Version ID of the newly created copy.
+        VersionId *string `location:"header" locationName:"x-amz-version-id" type:"string"`
+}
+
+// String returns the string representation
+func (s CopyObjectOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CopyObjectOutput) GoString() string {
+        return s.String()
+}
+
+// SetCopyObjectResult sets the CopyObjectResult field's value.
+func (s *CopyObjectOutput) SetCopyObjectResult(v *CopyObjectResult) *CopyObjectOutput {
+        s.CopyObjectResult = v
+        return s
+}
+
+// SetCopySourceVersionId sets the CopySourceVersionId field's value.
+func (s *CopyObjectOutput) SetCopySourceVersionId(v string) *CopyObjectOutput {
+        s.CopySourceVersionId = &v
+        return s
+}
+
+// SetExpiration sets the Expiration field's value.
+func (s *CopyObjectOutput) SetExpiration(v string) *CopyObjectOutput {
+        s.Expiration = &v
+        return s
+}
+
+// SetRequestCharged sets the RequestCharged field's value.
+func (s *CopyObjectOutput) SetRequestCharged(v string) *CopyObjectOutput {
+        s.RequestCharged = &v
+        return s
+}
+
+// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.
+func (s *CopyObjectOutput) SetSSECustomerAlgorithm(v string) *CopyObjectOutput {
+        s.SSECustomerAlgorithm = &v
+        return s
+}
+
+// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.
+func (s *CopyObjectOutput) SetSSECustomerKeyMD5(v string) *CopyObjectOutput {
+        s.SSECustomerKeyMD5 = &v
+        return s
+}
+
+// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.
+func (s *CopyObjectOutput) SetSSEKMSKeyId(v string) *CopyObjectOutput {
+        s.SSEKMSKeyId = &v
+        return s
+}
+
+// SetServerSideEncryption sets the ServerSideEncryption field's value.
+func (s *CopyObjectOutput) SetServerSideEncryption(v string) *CopyObjectOutput {
+        s.ServerSideEncryption = &v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *CopyObjectOutput) SetVersionId(v string) *CopyObjectOutput {
+        s.VersionId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CopyObjectResult
+type CopyObjectResult struct {
+        _ struct{} `type:"structure"`
+
+        ETag *string `type:"string"`
+
+        LastModified *time.Time `type:"timestamp" timestampFormat:"iso8601"`
+}
+
+// String returns the string representation
+func (s CopyObjectResult) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CopyObjectResult) GoString() string {
+        return s.String()
+}
+
+// SetETag sets the ETag field's value.
+func (s *CopyObjectResult) SetETag(v string) *CopyObjectResult {
+        s.ETag = &v
+        return s
+}
+
+// SetLastModified sets the LastModified field's value.
+func (s *CopyObjectResult) SetLastModified(v time.Time) *CopyObjectResult {
+        s.LastModified = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CopyPartResult
+type CopyPartResult struct {
+        _ struct{} `type:"structure"`
+
+        // Entity tag of the object.
+        ETag *string `type:"string"`
+
+        // Date and time at which the object was uploaded.
+        LastModified *time.Time `type:"timestamp" timestampFormat:"iso8601"`
+}
+
+// String returns the string representation
+func (s CopyPartResult) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CopyPartResult) GoString() string {
+        return s.String()
+}
+
+// SetETag sets the ETag field's value.
+func (s *CopyPartResult) SetETag(v string) *CopyPartResult {
+        s.ETag = &v
+        return s
+}
+
+// SetLastModified sets the LastModified field's value.
+func (s *CopyPartResult) SetLastModified(v time.Time) *CopyPartResult {
+        s.LastModified = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CreateBucketConfiguration
+type CreateBucketConfiguration struct {
+        _ struct{} `type:"structure"`
+
+        // Specifies the region where the bucket will be created. If you don't specify
+        // a region, the bucket will be created in US Standard.
+        LocationConstraint *string `type:"string" enum:"BucketLocationConstraint"`
+}
+
+// String returns the string representation
+func (s CreateBucketConfiguration) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateBucketConfiguration) GoString() string {
+        return s.String()
+}
+
+// SetLocationConstraint sets the LocationConstraint field's value.
+func (s *CreateBucketConfiguration) SetLocationConstraint(v string) *CreateBucketConfiguration {
+        s.LocationConstraint = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CreateBucketRequest
+type CreateBucketInput struct {
+        _ struct{} `type:"structure" payload:"CreateBucketConfiguration"`
+
+        // The canned ACL to apply to the bucket.
+        ACL *string `location:"header" locationName:"x-amz-acl" type:"string" enum:"BucketCannedACL"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        CreateBucketConfiguration *CreateBucketConfiguration `locationName:"CreateBucketConfiguration" type:"structure"`
+
+        // Allows grantee the read, write, read ACP, and write ACP permissions on the
+        // bucket.
+        GrantFullControl *string `location:"header" locationName:"x-amz-grant-full-control" type:"string"`
+
+        // Allows grantee to list the objects in the bucket.
+        GrantRead *string `location:"header" locationName:"x-amz-grant-read" type:"string"`
+
+        // Allows grantee to read the bucket ACL.
+        GrantReadACP *string `location:"header" locationName:"x-amz-grant-read-acp" type:"string"`
+
+        // Allows grantee to create, overwrite, and delete any object in the bucket.
+        GrantWrite *string `location:"header" locationName:"x-amz-grant-write" type:"string"`
+
+        // Allows grantee to write the ACL for the applicable bucket.
+        GrantWriteACP *string `location:"header" locationName:"x-amz-grant-write-acp" type:"string"`
+}
+
+// String returns the string representation
+func (s CreateBucketInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateBucketInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *CreateBucketInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "CreateBucketInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetACL sets the ACL field's value.
+func (s *CreateBucketInput) SetACL(v string) *CreateBucketInput {
+        s.ACL = &v
+        return s
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *CreateBucketInput) SetBucket(v string) *CreateBucketInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetCreateBucketConfiguration sets the CreateBucketConfiguration field's value.
+func (s *CreateBucketInput) SetCreateBucketConfiguration(v *CreateBucketConfiguration) *CreateBucketInput {
+        s.CreateBucketConfiguration = v
+        return s
+}
+
+// SetGrantFullControl sets the GrantFullControl field's value.
+func (s *CreateBucketInput) SetGrantFullControl(v string) *CreateBucketInput {
+        s.GrantFullControl = &v
+        return s
+}
+
+// SetGrantRead sets the GrantRead field's value.
+func (s *CreateBucketInput) SetGrantRead(v string) *CreateBucketInput {
+        s.GrantRead = &v
+        return s
+}
+
+// SetGrantReadACP sets the GrantReadACP field's value.
+func (s *CreateBucketInput) SetGrantReadACP(v string) *CreateBucketInput {
+        s.GrantReadACP = &v
+        return s
+}
+
+// SetGrantWrite sets the GrantWrite field's value.
+func (s *CreateBucketInput) SetGrantWrite(v string) *CreateBucketInput {
+        s.GrantWrite = &v
+        return s
+}
+
+// SetGrantWriteACP sets the GrantWriteACP field's value.
+func (s *CreateBucketInput) SetGrantWriteACP(v string) *CreateBucketInput {
+        s.GrantWriteACP = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CreateBucketOutput
+type CreateBucketOutput struct {
+        _ struct{} `type:"structure"`
+
+        Location *string `location:"header" locationName:"Location" type:"string"`
+}
+
+// String returns the string representation
+func (s CreateBucketOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateBucketOutput) GoString() string {
+        return s.String()
+}
+
+// SetLocation sets the Location field's value.
+func (s *CreateBucketOutput) SetLocation(v string) *CreateBucketOutput {
+        s.Location = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CreateMultipartUploadRequest
+type CreateMultipartUploadInput struct {
+        _ struct{} `type:"structure"`
+
+        // The canned ACL to apply to the object.
+        ACL *string `location:"header" locationName:"x-amz-acl" type:"string" enum:"ObjectCannedACL"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Specifies caching behavior along the request/reply chain.
+        CacheControl *string `location:"header" locationName:"Cache-Control" type:"string"`
+
+        // Specifies presentational information for the object.
+        ContentDisposition *string `location:"header" locationName:"Content-Disposition" type:"string"`
+
+        // Specifies what content encodings have been applied to the object and thus
+        // what decoding mechanisms must be applied to obtain the media-type referenced
+        // by the Content-Type header field.
+        ContentEncoding *string `location:"header" locationName:"Content-Encoding" type:"string"`
+
+        // The language the content is in.
+        ContentLanguage *string `location:"header" locationName:"Content-Language" type:"string"`
+
+        // A standard MIME type describing the format of the object data.
+        ContentType *string `location:"header" locationName:"Content-Type" type:"string"`
+
+        // The date and time at which the object is no longer cacheable.
+        Expires *time.Time `location:"header" locationName:"Expires" type:"timestamp" timestampFormat:"rfc822"`
+
+        // Gives the grantee READ, READ_ACP, and WRITE_ACP permissions on the object.
+        GrantFullControl *string `location:"header" locationName:"x-amz-grant-full-control" type:"string"`
+
+        // Allows grantee to read the object data and its metadata.
+        GrantRead *string `location:"header" locationName:"x-amz-grant-read" type:"string"`
+
+        // Allows grantee to read the object ACL.
+        GrantReadACP *string `location:"header" locationName:"x-amz-grant-read-acp" type:"string"`
+
+        // Allows grantee to write the ACL for the applicable object.
+        GrantWriteACP *string `location:"header" locationName:"x-amz-grant-write-acp" type:"string"`
+
+        // Key is a required field
+        Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`
+
+        // A map of metadata to store with the object in S3.
+        Metadata map[string]*string `location:"headers" locationName:"x-amz-meta-" type:"map"`
+
+        // Confirms that the requester knows that she or he will be charged for the
+        // request. Bucket owners need not specify this parameter in their requests.
+        // Documentation on downloading objects from requester pays buckets can be found
+        // at http://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html
+        RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string" enum:"RequestPayer"`
+
+        // Specifies the algorithm to use to when encrypting the object (e.g., AES256).
+        SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`
+
+        // Specifies the customer-provided encryption key for Amazon S3 to use in encrypting
+        // data. This value is used to store the object and then it is discarded; Amazon
+        // does not store the encryption key. The key must be appropriate for use with
+        // the algorithm specified in the x-amz-server-side​-encryption​-customer-algorithm
+        // header.
+        SSECustomerKey *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key" type:"string"`
+
+        // Specifies the 128-bit MD5 digest of the encryption key according to RFC 1321.
+        // Amazon S3 uses this header for a message integrity check to ensure the encryption
+        // key was transmitted without error.
+        SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`
+
+        // Specifies the AWS KMS key ID to use for object encryption. All GET and PUT
+        // requests for an object protected by AWS KMS will fail if not made via SSL
+        // or using SigV4. Documentation on configuring any of the officially supported
+        // AWS SDKs and CLI can be found at http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingAWSSDK.html#specify-signature-version
+        SSEKMSKeyId *string `location:"header" locationName:"x-amz-server-side-encryption-aws-kms-key-id" type:"string"`
+
+        // The Server-side encryption algorithm used when storing this object in S3
+        // (e.g., AES256, aws:kms).
+        ServerSideEncryption *string `location:"header" locationName:"x-amz-server-side-encryption" type:"string" enum:"ServerSideEncryption"`
+
+        // The type of storage to use for the object. Defaults to 'STANDARD'.
+        StorageClass *string `location:"header" locationName:"x-amz-storage-class" type:"string" enum:"StorageClass"`
+
+        // If the bucket is configured as a website, redirects requests for this object
+        // to another object in the same bucket or to an external URL. Amazon S3 stores
+        // the value of this header in the object metadata.
+        WebsiteRedirectLocation *string `location:"header" locationName:"x-amz-website-redirect-location" type:"string"`
+}
+
+// String returns the string representation
+func (s CreateMultipartUploadInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateMultipartUploadInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *CreateMultipartUploadInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "CreateMultipartUploadInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetACL sets the ACL field's value.
+func (s *CreateMultipartUploadInput) SetACL(v string) *CreateMultipartUploadInput {
+        s.ACL = &v
+        return s
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *CreateMultipartUploadInput) SetBucket(v string) *CreateMultipartUploadInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetCacheControl sets the CacheControl field's value.
+func (s *CreateMultipartUploadInput) SetCacheControl(v string) *CreateMultipartUploadInput {
+        s.CacheControl = &v
+        return s
+}
+
+// SetContentDisposition sets the ContentDisposition field's value.
+func (s *CreateMultipartUploadInput) SetContentDisposition(v string) *CreateMultipartUploadInput {
+        s.ContentDisposition = &v
+        return s
+}
+
+// SetContentEncoding sets the ContentEncoding field's value.
+func (s *CreateMultipartUploadInput) SetContentEncoding(v string) *CreateMultipartUploadInput {
+        s.ContentEncoding = &v
+        return s
+}
+
+// SetContentLanguage sets the ContentLanguage field's value.
+func (s *CreateMultipartUploadInput) SetContentLanguage(v string) *CreateMultipartUploadInput {
+        s.ContentLanguage = &v
+        return s
+}
+
+// SetContentType sets the ContentType field's value.
+func (s *CreateMultipartUploadInput) SetContentType(v string) *CreateMultipartUploadInput {
+        s.ContentType = &v
+        return s
+}
+
+// SetExpires sets the Expires field's value.
+func (s *CreateMultipartUploadInput) SetExpires(v time.Time) *CreateMultipartUploadInput {
+        s.Expires = &v
+        return s
+}
+
+// SetGrantFullControl sets the GrantFullControl field's value.
+func (s *CreateMultipartUploadInput) SetGrantFullControl(v string) *CreateMultipartUploadInput {
+        s.GrantFullControl = &v
+        return s
+}
+
+// SetGrantRead sets the GrantRead field's value.
+func (s *CreateMultipartUploadInput) SetGrantRead(v string) *CreateMultipartUploadInput {
+        s.GrantRead = &v
+        return s
+}
+
+// SetGrantReadACP sets the GrantReadACP field's value.
+func (s *CreateMultipartUploadInput) SetGrantReadACP(v string) *CreateMultipartUploadInput {
+        s.GrantReadACP = &v
+        return s
+}
+
+// SetGrantWriteACP sets the GrantWriteACP field's value.
+func (s *CreateMultipartUploadInput) SetGrantWriteACP(v string) *CreateMultipartUploadInput {
+        s.GrantWriteACP = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *CreateMultipartUploadInput) SetKey(v string) *CreateMultipartUploadInput {
+        s.Key = &v
+        return s
+}
+
+// SetMetadata sets the Metadata field's value.
+func (s *CreateMultipartUploadInput) SetMetadata(v map[string]*string) *CreateMultipartUploadInput {
+        s.Metadata = v
+        return s
+}
+
+// SetRequestPayer sets the RequestPayer field's value.
+func (s *CreateMultipartUploadInput) SetRequestPayer(v string) *CreateMultipartUploadInput {
+        s.RequestPayer = &v
+        return s
+}
+
+// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.
+func (s *CreateMultipartUploadInput) SetSSECustomerAlgorithm(v string) *CreateMultipartUploadInput {
+        s.SSECustomerAlgorithm = &v
+        return s
+}
+
+// SetSSECustomerKey sets the SSECustomerKey field's value.
+func (s *CreateMultipartUploadInput) SetSSECustomerKey(v string) *CreateMultipartUploadInput {
+        s.SSECustomerKey = &v
+        return s
+}
+
+// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.
+func (s *CreateMultipartUploadInput) SetSSECustomerKeyMD5(v string) *CreateMultipartUploadInput {
+        s.SSECustomerKeyMD5 = &v
+        return s
+}
+
+// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.
+func (s *CreateMultipartUploadInput) SetSSEKMSKeyId(v string) *CreateMultipartUploadInput {
+        s.SSEKMSKeyId = &v
+        return s
+}
+
+// SetServerSideEncryption sets the ServerSideEncryption field's value.
+func (s *CreateMultipartUploadInput) SetServerSideEncryption(v string) *CreateMultipartUploadInput {
+        s.ServerSideEncryption = &v
+        return s
+}
+
+// SetStorageClass sets the StorageClass field's value.
+func (s *CreateMultipartUploadInput) SetStorageClass(v string) *CreateMultipartUploadInput {
+        s.StorageClass = &v
+        return s
+}
+
+// SetWebsiteRedirectLocation sets the WebsiteRedirectLocation field's value.
+func (s *CreateMultipartUploadInput) SetWebsiteRedirectLocation(v string) *CreateMultipartUploadInput {
+        s.WebsiteRedirectLocation = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CreateMultipartUploadOutput
+type CreateMultipartUploadOutput struct {
+        _ struct{} `type:"structure"`
+
+        // Date when multipart upload will become eligible for abort operation by lifecycle.
+        AbortDate *time.Time `location:"header" locationName:"x-amz-abort-date" type:"timestamp" timestampFormat:"rfc822"`
+
+        // Id of the lifecycle rule that makes a multipart upload eligible for abort
+        // operation.
+        AbortRuleId *string `location:"header" locationName:"x-amz-abort-rule-id" type:"string"`
+
+        // Name of the bucket to which the multipart upload was initiated.
+        Bucket *string `locationName:"Bucket" type:"string"`
+
+        // Object key for which the multipart upload was initiated.
+        Key *string `min:"1" type:"string"`
+
+        // If present, indicates that the requester was successfully charged for the
+        // request.
+        RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`
+
+        // If server-side encryption with a customer-provided encryption key was requested,
+        // the response will include this header confirming the encryption algorithm
+        // used.
+        SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`
+
+        // If server-side encryption with a customer-provided encryption key was requested,
+        // the response will include this header to provide round trip message integrity
+        // verification of the customer-provided encryption key.
+        SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`
+
+        // If present, specifies the ID of the AWS Key Management Service (KMS) master
+        // encryption key that was used for the object.
+        SSEKMSKeyId *string `location:"header" locationName:"x-amz-server-side-encryption-aws-kms-key-id" type:"string"`
+
+        // The Server-side encryption algorithm used when storing this object in S3
+        // (e.g., AES256, aws:kms).
+        ServerSideEncryption *string `location:"header" locationName:"x-amz-server-side-encryption" type:"string" enum:"ServerSideEncryption"`
+
+        // ID for the initiated multipart upload.
+        UploadId *string `type:"string"`
+}
+
+// String returns the string representation
+func (s CreateMultipartUploadOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateMultipartUploadOutput) GoString() string {
+        return s.String()
+}
+
+// SetAbortDate sets the AbortDate field's value.
+func (s *CreateMultipartUploadOutput) SetAbortDate(v time.Time) *CreateMultipartUploadOutput {
+        s.AbortDate = &v
+        return s
+}
+
+// SetAbortRuleId sets the AbortRuleId field's value.
+func (s *CreateMultipartUploadOutput) SetAbortRuleId(v string) *CreateMultipartUploadOutput {
+        s.AbortRuleId = &v
+        return s
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *CreateMultipartUploadOutput) SetBucket(v string) *CreateMultipartUploadOutput {
+        s.Bucket = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *CreateMultipartUploadOutput) SetKey(v string) *CreateMultipartUploadOutput {
+        s.Key = &v
+        return s
+}
+
+// SetRequestCharged sets the RequestCharged field's value.
+func (s *CreateMultipartUploadOutput) SetRequestCharged(v string) *CreateMultipartUploadOutput {
+        s.RequestCharged = &v
+        return s
+}
+
+// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.
+func (s *CreateMultipartUploadOutput) SetSSECustomerAlgorithm(v string) *CreateMultipartUploadOutput {
+        s.SSECustomerAlgorithm = &v
+        return s
+}
+
+// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.
+func (s *CreateMultipartUploadOutput) SetSSECustomerKeyMD5(v string) *CreateMultipartUploadOutput {
+        s.SSECustomerKeyMD5 = &v
+        return s
+}
+
+// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.
+func (s *CreateMultipartUploadOutput) SetSSEKMSKeyId(v string) *CreateMultipartUploadOutput {
+        s.SSEKMSKeyId = &v
+        return s
+}
+
+// SetServerSideEncryption sets the ServerSideEncryption field's value.
+func (s *CreateMultipartUploadOutput) SetServerSideEncryption(v string) *CreateMultipartUploadOutput {
+        s.ServerSideEncryption = &v
+        return s
+}
+
+// SetUploadId sets the UploadId field's value.
+func (s *CreateMultipartUploadOutput) SetUploadId(v string) *CreateMultipartUploadOutput {
+        s.UploadId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Delete
+type Delete struct {
+        _ struct{} `type:"structure"`
+
+        // Objects is a required field
+        Objects []*ObjectIdentifier `locationName:"Object" type:"list" flattened:"true" required:"true"`
+
+        // Element to enable quiet mode for the request. When you add this element,
+        // you must set its value to true.
+        Quiet *bool `type:"boolean"`
+}
+
+// String returns the string representation
+func (s Delete) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Delete) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *Delete) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "Delete"}
+        if s.Objects == nil {
+                invalidParams.Add(request.NewErrParamRequired("Objects"))
+        }
+        if s.Objects != nil {
+                for i, v := range s.Objects {
+                        if v == nil {
+                                continue
+                        }
+                        if err := v.Validate(); err != nil {
+                                invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Objects", i), err.(request.ErrInvalidParams))
+                        }
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetObjects sets the Objects field's value.
+func (s *Delete) SetObjects(v []*ObjectIdentifier) *Delete {
+        s.Objects = v
+        return s
+}
+
+// SetQuiet sets the Quiet field's value.
+func (s *Delete) SetQuiet(v bool) *Delete {
+        s.Quiet = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketAnalyticsConfigurationRequest
+type DeleteBucketAnalyticsConfigurationInput struct {
+        _ struct{} `type:"structure"`
+
+        // The name of the bucket from which an analytics configuration is deleted.
+        //
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // The identifier used to represent an analytics configuration.
+        //
+        // Id is a required field
+        Id *string `location:"querystring" locationName:"id" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteBucketAnalyticsConfigurationInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteBucketAnalyticsConfigurationInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteBucketAnalyticsConfigurationInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "DeleteBucketAnalyticsConfigurationInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Id == nil {
+                invalidParams.Add(request.NewErrParamRequired("Id"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *DeleteBucketAnalyticsConfigurationInput) SetBucket(v string) *DeleteBucketAnalyticsConfigurationInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetId sets the Id field's value.
+func (s *DeleteBucketAnalyticsConfigurationInput) SetId(v string) *DeleteBucketAnalyticsConfigurationInput {
+        s.Id = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketAnalyticsConfigurationOutput
+type DeleteBucketAnalyticsConfigurationOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteBucketAnalyticsConfigurationOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteBucketAnalyticsConfigurationOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketCorsRequest
+type DeleteBucketCorsInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteBucketCorsInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteBucketCorsInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteBucketCorsInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "DeleteBucketCorsInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *DeleteBucketCorsInput) SetBucket(v string) *DeleteBucketCorsInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketCorsOutput
+type DeleteBucketCorsOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteBucketCorsOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteBucketCorsOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketRequest
+type DeleteBucketInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteBucketInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteBucketInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteBucketInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "DeleteBucketInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *DeleteBucketInput) SetBucket(v string) *DeleteBucketInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketInventoryConfigurationRequest
+type DeleteBucketInventoryConfigurationInput struct {
+        _ struct{} `type:"structure"`
+
+        // The name of the bucket containing the inventory configuration to delete.
+        //
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // The ID used to identify the inventory configuration.
+        //
+        // Id is a required field
+        Id *string `location:"querystring" locationName:"id" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteBucketInventoryConfigurationInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteBucketInventoryConfigurationInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteBucketInventoryConfigurationInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "DeleteBucketInventoryConfigurationInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Id == nil {
+                invalidParams.Add(request.NewErrParamRequired("Id"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *DeleteBucketInventoryConfigurationInput) SetBucket(v string) *DeleteBucketInventoryConfigurationInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetId sets the Id field's value.
+func (s *DeleteBucketInventoryConfigurationInput) SetId(v string) *DeleteBucketInventoryConfigurationInput {
+        s.Id = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketInventoryConfigurationOutput
+type DeleteBucketInventoryConfigurationOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteBucketInventoryConfigurationOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteBucketInventoryConfigurationOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketLifecycleRequest
+type DeleteBucketLifecycleInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteBucketLifecycleInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteBucketLifecycleInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteBucketLifecycleInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "DeleteBucketLifecycleInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *DeleteBucketLifecycleInput) SetBucket(v string) *DeleteBucketLifecycleInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketLifecycleOutput
+type DeleteBucketLifecycleOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteBucketLifecycleOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteBucketLifecycleOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketMetricsConfigurationRequest
+type DeleteBucketMetricsConfigurationInput struct {
+        _ struct{} `type:"structure"`
+
+        // The name of the bucket containing the metrics configuration to delete.
+        //
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // The ID used to identify the metrics configuration.
+        //
+        // Id is a required field
+        Id *string `location:"querystring" locationName:"id" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteBucketMetricsConfigurationInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteBucketMetricsConfigurationInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteBucketMetricsConfigurationInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "DeleteBucketMetricsConfigurationInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Id == nil {
+                invalidParams.Add(request.NewErrParamRequired("Id"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *DeleteBucketMetricsConfigurationInput) SetBucket(v string) *DeleteBucketMetricsConfigurationInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetId sets the Id field's value.
+func (s *DeleteBucketMetricsConfigurationInput) SetId(v string) *DeleteBucketMetricsConfigurationInput {
+        s.Id = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketMetricsConfigurationOutput
+type DeleteBucketMetricsConfigurationOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteBucketMetricsConfigurationOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteBucketMetricsConfigurationOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketOutput
+type DeleteBucketOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteBucketOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteBucketOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketPolicyRequest
+type DeleteBucketPolicyInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteBucketPolicyInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteBucketPolicyInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteBucketPolicyInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "DeleteBucketPolicyInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *DeleteBucketPolicyInput) SetBucket(v string) *DeleteBucketPolicyInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketPolicyOutput
+type DeleteBucketPolicyOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteBucketPolicyOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteBucketPolicyOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketReplicationRequest
+type DeleteBucketReplicationInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteBucketReplicationInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteBucketReplicationInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteBucketReplicationInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "DeleteBucketReplicationInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *DeleteBucketReplicationInput) SetBucket(v string) *DeleteBucketReplicationInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketReplicationOutput
+type DeleteBucketReplicationOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteBucketReplicationOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteBucketReplicationOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketTaggingRequest
+type DeleteBucketTaggingInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteBucketTaggingInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteBucketTaggingInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteBucketTaggingInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "DeleteBucketTaggingInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *DeleteBucketTaggingInput) SetBucket(v string) *DeleteBucketTaggingInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketTaggingOutput
+type DeleteBucketTaggingOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteBucketTaggingOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteBucketTaggingOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketWebsiteRequest
+type DeleteBucketWebsiteInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteBucketWebsiteInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteBucketWebsiteInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteBucketWebsiteInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "DeleteBucketWebsiteInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *DeleteBucketWebsiteInput) SetBucket(v string) *DeleteBucketWebsiteInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketWebsiteOutput
+type DeleteBucketWebsiteOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteBucketWebsiteOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteBucketWebsiteOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteMarkerEntry
+type DeleteMarkerEntry struct {
+        _ struct{} `type:"structure"`
+
+        // Specifies whether the object is (true) or is not (false) the latest version
+        // of an object.
+        IsLatest *bool `type:"boolean"`
+
+        // The object key.
+        Key *string `min:"1" type:"string"`
+
+        // Date and time the object was last modified.
+        LastModified *time.Time `type:"timestamp" timestampFormat:"iso8601"`
+
+        Owner *Owner `type:"structure"`
+
+        // Version ID of an object.
+        VersionId *string `type:"string"`
+}
+
+// String returns the string representation
+func (s DeleteMarkerEntry) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteMarkerEntry) GoString() string {
+        return s.String()
+}
+
+// SetIsLatest sets the IsLatest field's value.
+func (s *DeleteMarkerEntry) SetIsLatest(v bool) *DeleteMarkerEntry {
+        s.IsLatest = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *DeleteMarkerEntry) SetKey(v string) *DeleteMarkerEntry {
+        s.Key = &v
+        return s
+}
+
+// SetLastModified sets the LastModified field's value.
+func (s *DeleteMarkerEntry) SetLastModified(v time.Time) *DeleteMarkerEntry {
+        s.LastModified = &v
+        return s
+}
+
+// SetOwner sets the Owner field's value.
+func (s *DeleteMarkerEntry) SetOwner(v *Owner) *DeleteMarkerEntry {
+        s.Owner = v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *DeleteMarkerEntry) SetVersionId(v string) *DeleteMarkerEntry {
+        s.VersionId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteObjectRequest
+type DeleteObjectInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Key is a required field
+        Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`
+
+        // The concatenation of the authentication device's serial number, a space,
+        // and the value that is displayed on your authentication device.
+        MFA *string `location:"header" locationName:"x-amz-mfa" type:"string"`
+
+        // Confirms that the requester knows that she or he will be charged for the
+        // request. Bucket owners need not specify this parameter in their requests.
+        // Documentation on downloading objects from requester pays buckets can be found
+        // at http://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html
+        RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string" enum:"RequestPayer"`
+
+        // VersionId used to reference a specific version of the object.
+        VersionId *string `location:"querystring" locationName:"versionId" type:"string"`
+}
+
+// String returns the string representation
+func (s DeleteObjectInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteObjectInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteObjectInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "DeleteObjectInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *DeleteObjectInput) SetBucket(v string) *DeleteObjectInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *DeleteObjectInput) SetKey(v string) *DeleteObjectInput {
+        s.Key = &v
+        return s
+}
+
+// SetMFA sets the MFA field's value.
+func (s *DeleteObjectInput) SetMFA(v string) *DeleteObjectInput {
+        s.MFA = &v
+        return s
+}
+
+// SetRequestPayer sets the RequestPayer field's value.
+func (s *DeleteObjectInput) SetRequestPayer(v string) *DeleteObjectInput {
+        s.RequestPayer = &v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *DeleteObjectInput) SetVersionId(v string) *DeleteObjectInput {
+        s.VersionId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteObjectOutput
+type DeleteObjectOutput struct {
+        _ struct{} `type:"structure"`
+
+        // Specifies whether the versioned object that was permanently deleted was (true)
+        // or was not (false) a delete marker.
+        DeleteMarker *bool `location:"header" locationName:"x-amz-delete-marker" type:"boolean"`
+
+        // If present, indicates that the requester was successfully charged for the
+        // request.
+        RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`
+
+        // Returns the version ID of the delete marker created as a result of the DELETE
+        // operation.
+        VersionId *string `location:"header" locationName:"x-amz-version-id" type:"string"`
+}
+
+// String returns the string representation
+func (s DeleteObjectOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteObjectOutput) GoString() string {
+        return s.String()
+}
+
+// SetDeleteMarker sets the DeleteMarker field's value.
+func (s *DeleteObjectOutput) SetDeleteMarker(v bool) *DeleteObjectOutput {
+        s.DeleteMarker = &v
+        return s
+}
+
+// SetRequestCharged sets the RequestCharged field's value.
+func (s *DeleteObjectOutput) SetRequestCharged(v string) *DeleteObjectOutput {
+        s.RequestCharged = &v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *DeleteObjectOutput) SetVersionId(v string) *DeleteObjectOutput {
+        s.VersionId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteObjectTaggingRequest
+type DeleteObjectTaggingInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Key is a required field
+        Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`
+
+        // The versionId of the object that the tag-set will be removed from.
+        VersionId *string `location:"querystring" locationName:"versionId" type:"string"`
+}
+
+// String returns the string representation
+func (s DeleteObjectTaggingInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteObjectTaggingInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteObjectTaggingInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "DeleteObjectTaggingInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *DeleteObjectTaggingInput) SetBucket(v string) *DeleteObjectTaggingInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *DeleteObjectTaggingInput) SetKey(v string) *DeleteObjectTaggingInput {
+        s.Key = &v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *DeleteObjectTaggingInput) SetVersionId(v string) *DeleteObjectTaggingInput {
+        s.VersionId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteObjectTaggingOutput
+type DeleteObjectTaggingOutput struct {
+        _ struct{} `type:"structure"`
+
+        // The versionId of the object the tag-set was removed from.
+        VersionId *string `location:"header" locationName:"x-amz-version-id" type:"string"`
+}
+
+// String returns the string representation
+func (s DeleteObjectTaggingOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteObjectTaggingOutput) GoString() string {
+        return s.String()
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *DeleteObjectTaggingOutput) SetVersionId(v string) *DeleteObjectTaggingOutput {
+        s.VersionId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteObjectsRequest
+type DeleteObjectsInput struct {
+        _ struct{} `type:"structure" payload:"Delete"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Delete is a required field
+        Delete *Delete `locationName:"Delete" type:"structure" required:"true"`
+
+        // The concatenation of the authentication device's serial number, a space,
+        // and the value that is displayed on your authentication device.
+        MFA *string `location:"header" locationName:"x-amz-mfa" type:"string"`
+
+        // Confirms that the requester knows that she or he will be charged for the
+        // request. Bucket owners need not specify this parameter in their requests.
+        // Documentation on downloading objects from requester pays buckets can be found
+        // at http://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html
+        RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string" enum:"RequestPayer"`
+}
+
+// String returns the string representation
+func (s DeleteObjectsInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteObjectsInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteObjectsInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "DeleteObjectsInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Delete == nil {
+                invalidParams.Add(request.NewErrParamRequired("Delete"))
+        }
+        if s.Delete != nil {
+                if err := s.Delete.Validate(); err != nil {
+                        invalidParams.AddNested("Delete", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *DeleteObjectsInput) SetBucket(v string) *DeleteObjectsInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetDelete sets the Delete field's value.
+func (s *DeleteObjectsInput) SetDelete(v *Delete) *DeleteObjectsInput {
+        s.Delete = v
+        return s
+}
+
+// SetMFA sets the MFA field's value.
+func (s *DeleteObjectsInput) SetMFA(v string) *DeleteObjectsInput {
+        s.MFA = &v
+        return s
+}
+
+// SetRequestPayer sets the RequestPayer field's value.
+func (s *DeleteObjectsInput) SetRequestPayer(v string) *DeleteObjectsInput {
+        s.RequestPayer = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteObjectsOutput
+type DeleteObjectsOutput struct {
+        _ struct{} `type:"structure"`
+
+        Deleted []*DeletedObject `type:"list" flattened:"true"`
+
+        Errors []*Error `locationName:"Error" type:"list" flattened:"true"`
+
+        // If present, indicates that the requester was successfully charged for the
+        // request.
+        RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`
+}
+
+// String returns the string representation
+func (s DeleteObjectsOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteObjectsOutput) GoString() string {
+        return s.String()
+}
+
+// SetDeleted sets the Deleted field's value.
+func (s *DeleteObjectsOutput) SetDeleted(v []*DeletedObject) *DeleteObjectsOutput {
+        s.Deleted = v
+        return s
+}
+
+// SetErrors sets the Errors field's value.
+func (s *DeleteObjectsOutput) SetErrors(v []*Error) *DeleteObjectsOutput {
+        s.Errors = v
+        return s
+}
+
+// SetRequestCharged sets the RequestCharged field's value.
+func (s *DeleteObjectsOutput) SetRequestCharged(v string) *DeleteObjectsOutput {
+        s.RequestCharged = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeletedObject
+type DeletedObject struct {
+        _ struct{} `type:"structure"`
+
+        DeleteMarker *bool `type:"boolean"`
+
+        DeleteMarkerVersionId *string `type:"string"`
+
+        Key *string `min:"1" type:"string"`
+
+        VersionId *string `type:"string"`
+}
+
+// String returns the string representation
+func (s DeletedObject) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeletedObject) GoString() string {
+        return s.String()
+}
+
+// SetDeleteMarker sets the DeleteMarker field's value.
+func (s *DeletedObject) SetDeleteMarker(v bool) *DeletedObject {
+        s.DeleteMarker = &v
+        return s
+}
+
+// SetDeleteMarkerVersionId sets the DeleteMarkerVersionId field's value.
+func (s *DeletedObject) SetDeleteMarkerVersionId(v string) *DeletedObject {
+        s.DeleteMarkerVersionId = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *DeletedObject) SetKey(v string) *DeletedObject {
+        s.Key = &v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *DeletedObject) SetVersionId(v string) *DeletedObject {
+        s.VersionId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Destination
+type Destination struct {
+        _ struct{} `type:"structure"`
+
+        // Amazon resource name (ARN) of the bucket where you want Amazon S3 to store
+        // replicas of the object identified by the rule.
+        //
+        // Bucket is a required field
+        Bucket *string `type:"string" required:"true"`
+
+        // The class of storage used to store the object.
+        StorageClass *string `type:"string" enum:"StorageClass"`
+}
+
+// String returns the string representation
+func (s Destination) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Destination) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *Destination) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "Destination"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *Destination) SetBucket(v string) *Destination {
+        s.Bucket = &v
+        return s
+}
+
+// SetStorageClass sets the StorageClass field's value.
+func (s *Destination) SetStorageClass(v string) *Destination {
+        s.StorageClass = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Error
+type Error struct {
+        _ struct{} `type:"structure"`
+
+        Code *string `type:"string"`
+
+        Key *string `min:"1" type:"string"`
+
+        Message *string `type:"string"`
+
+        VersionId *string `type:"string"`
+}
+
+// String returns the string representation
+func (s Error) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Error) GoString() string {
+        return s.String()
+}
+
+// SetCode sets the Code field's value.
+func (s *Error) SetCode(v string) *Error {
+        s.Code = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *Error) SetKey(v string) *Error {
+        s.Key = &v
+        return s
+}
+
+// SetMessage sets the Message field's value.
+func (s *Error) SetMessage(v string) *Error {
+        s.Message = &v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *Error) SetVersionId(v string) *Error {
+        s.VersionId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ErrorDocument
+type ErrorDocument struct {
+        _ struct{} `type:"structure"`
+
+        // The object key name to use when a 4XX class error occurs.
+        //
+        // Key is a required field
+        Key *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s ErrorDocument) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ErrorDocument) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ErrorDocument) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "ErrorDocument"}
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetKey sets the Key field's value.
+func (s *ErrorDocument) SetKey(v string) *ErrorDocument {
+        s.Key = &v
+        return s
+}
+
+// Container for key value pair that defines the criteria for the filter rule.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/FilterRule
+type FilterRule struct {
+        _ struct{} `type:"structure"`
+
+        // Object key name prefix or suffix identifying one or more objects to which
+        // the filtering rule applies. Maximum prefix length can be up to 1,024 characters.
+        // Overlapping prefixes and suffixes are not supported. For more information,
+        // go to Configuring Event Notifications (http://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html)
+        Name *string `type:"string" enum:"FilterRuleName"`
+
+        Value *string `type:"string"`
+}
+
+// String returns the string representation
+func (s FilterRule) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s FilterRule) GoString() string {
+        return s.String()
+}
+
+// SetName sets the Name field's value.
+func (s *FilterRule) SetName(v string) *FilterRule {
+        s.Name = &v
+        return s
+}
+
+// SetValue sets the Value field's value.
+func (s *FilterRule) SetValue(v string) *FilterRule {
+        s.Value = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketAccelerateConfigurationRequest
+type GetBucketAccelerateConfigurationInput struct {
+        _ struct{} `type:"structure"`
+
+        // Name of the bucket for which the accelerate configuration is retrieved.
+        //
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketAccelerateConfigurationInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketAccelerateConfigurationInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetBucketAccelerateConfigurationInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetBucketAccelerateConfigurationInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetBucketAccelerateConfigurationInput) SetBucket(v string) *GetBucketAccelerateConfigurationInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketAccelerateConfigurationOutput
+type GetBucketAccelerateConfigurationOutput struct {
+        _ struct{} `type:"structure"`
+
+        // The accelerate configuration of the bucket.
+        Status *string `type:"string" enum:"BucketAccelerateStatus"`
+}
+
+// String returns the string representation
+func (s GetBucketAccelerateConfigurationOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketAccelerateConfigurationOutput) GoString() string {
+        return s.String()
+}
+
+// SetStatus sets the Status field's value.
+func (s *GetBucketAccelerateConfigurationOutput) SetStatus(v string) *GetBucketAccelerateConfigurationOutput {
+        s.Status = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketAclRequest
+type GetBucketAclInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketAclInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketAclInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetBucketAclInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetBucketAclInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetBucketAclInput) SetBucket(v string) *GetBucketAclInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketAclOutput
+type GetBucketAclOutput struct {
+        _ struct{} `type:"structure"`
+
+        // A list of grants.
+        Grants []*Grant `locationName:"AccessControlList" locationNameList:"Grant" type:"list"`
+
+        Owner *Owner `type:"structure"`
+}
+
+// String returns the string representation
+func (s GetBucketAclOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketAclOutput) GoString() string {
+        return s.String()
+}
+
+// SetGrants sets the Grants field's value.
+func (s *GetBucketAclOutput) SetGrants(v []*Grant) *GetBucketAclOutput {
+        s.Grants = v
+        return s
+}
+
+// SetOwner sets the Owner field's value.
+func (s *GetBucketAclOutput) SetOwner(v *Owner) *GetBucketAclOutput {
+        s.Owner = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketAnalyticsConfigurationRequest
+type GetBucketAnalyticsConfigurationInput struct {
+        _ struct{} `type:"structure"`
+
+        // The name of the bucket from which an analytics configuration is retrieved.
+        //
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // The identifier used to represent an analytics configuration.
+        //
+        // Id is a required field
+        Id *string `location:"querystring" locationName:"id" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketAnalyticsConfigurationInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketAnalyticsConfigurationInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetBucketAnalyticsConfigurationInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetBucketAnalyticsConfigurationInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Id == nil {
+                invalidParams.Add(request.NewErrParamRequired("Id"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetBucketAnalyticsConfigurationInput) SetBucket(v string) *GetBucketAnalyticsConfigurationInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetId sets the Id field's value.
+func (s *GetBucketAnalyticsConfigurationInput) SetId(v string) *GetBucketAnalyticsConfigurationInput {
+        s.Id = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketAnalyticsConfigurationOutput
+type GetBucketAnalyticsConfigurationOutput struct {
+        _ struct{} `type:"structure" payload:"AnalyticsConfiguration"`
+
+        // The configuration and any analyses for the analytics filter.
+        AnalyticsConfiguration *AnalyticsConfiguration `type:"structure"`
+}
+
+// String returns the string representation
+func (s GetBucketAnalyticsConfigurationOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketAnalyticsConfigurationOutput) GoString() string {
+        return s.String()
+}
+
+// SetAnalyticsConfiguration sets the AnalyticsConfiguration field's value.
+func (s *GetBucketAnalyticsConfigurationOutput) SetAnalyticsConfiguration(v *AnalyticsConfiguration) *GetBucketAnalyticsConfigurationOutput {
+        s.AnalyticsConfiguration = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketCorsRequest
+type GetBucketCorsInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketCorsInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketCorsInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetBucketCorsInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetBucketCorsInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetBucketCorsInput) SetBucket(v string) *GetBucketCorsInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketCorsOutput
+type GetBucketCorsOutput struct {
+        _ struct{} `type:"structure"`
+
+        CORSRules []*CORSRule `locationName:"CORSRule" type:"list" flattened:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketCorsOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketCorsOutput) GoString() string {
+        return s.String()
+}
+
+// SetCORSRules sets the CORSRules field's value.
+func (s *GetBucketCorsOutput) SetCORSRules(v []*CORSRule) *GetBucketCorsOutput {
+        s.CORSRules = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketInventoryConfigurationRequest
+type GetBucketInventoryConfigurationInput struct {
+        _ struct{} `type:"structure"`
+
+        // The name of the bucket containing the inventory configuration to retrieve.
+        //
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // The ID used to identify the inventory configuration.
+        //
+        // Id is a required field
+        Id *string `location:"querystring" locationName:"id" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketInventoryConfigurationInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketInventoryConfigurationInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetBucketInventoryConfigurationInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetBucketInventoryConfigurationInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Id == nil {
+                invalidParams.Add(request.NewErrParamRequired("Id"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetBucketInventoryConfigurationInput) SetBucket(v string) *GetBucketInventoryConfigurationInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetId sets the Id field's value.
+func (s *GetBucketInventoryConfigurationInput) SetId(v string) *GetBucketInventoryConfigurationInput {
+        s.Id = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketInventoryConfigurationOutput
+type GetBucketInventoryConfigurationOutput struct {
+        _ struct{} `type:"structure" payload:"InventoryConfiguration"`
+
+        // Specifies the inventory configuration.
+        InventoryConfiguration *InventoryConfiguration `type:"structure"`
+}
+
+// String returns the string representation
+func (s GetBucketInventoryConfigurationOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketInventoryConfigurationOutput) GoString() string {
+        return s.String()
+}
+
+// SetInventoryConfiguration sets the InventoryConfiguration field's value.
+func (s *GetBucketInventoryConfigurationOutput) SetInventoryConfiguration(v *InventoryConfiguration) *GetBucketInventoryConfigurationOutput {
+        s.InventoryConfiguration = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLifecycleConfigurationRequest
+type GetBucketLifecycleConfigurationInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketLifecycleConfigurationInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketLifecycleConfigurationInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetBucketLifecycleConfigurationInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetBucketLifecycleConfigurationInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetBucketLifecycleConfigurationInput) SetBucket(v string) *GetBucketLifecycleConfigurationInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLifecycleConfigurationOutput
+type GetBucketLifecycleConfigurationOutput struct {
+        _ struct{} `type:"structure"`
+
+        Rules []*LifecycleRule `locationName:"Rule" type:"list" flattened:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketLifecycleConfigurationOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketLifecycleConfigurationOutput) GoString() string {
+        return s.String()
+}
+
+// SetRules sets the Rules field's value.
+func (s *GetBucketLifecycleConfigurationOutput) SetRules(v []*LifecycleRule) *GetBucketLifecycleConfigurationOutput {
+        s.Rules = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLifecycleRequest
+type GetBucketLifecycleInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketLifecycleInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketLifecycleInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetBucketLifecycleInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetBucketLifecycleInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetBucketLifecycleInput) SetBucket(v string) *GetBucketLifecycleInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLifecycleOutput
+type GetBucketLifecycleOutput struct {
+        _ struct{} `type:"structure"`
+
+        Rules []*Rule `locationName:"Rule" type:"list" flattened:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketLifecycleOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketLifecycleOutput) GoString() string {
+        return s.String()
+}
+
+// SetRules sets the Rules field's value.
+func (s *GetBucketLifecycleOutput) SetRules(v []*Rule) *GetBucketLifecycleOutput {
+        s.Rules = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLocationRequest
+type GetBucketLocationInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketLocationInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketLocationInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetBucketLocationInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetBucketLocationInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetBucketLocationInput) SetBucket(v string) *GetBucketLocationInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLocationOutput
+type GetBucketLocationOutput struct {
+        _ struct{} `type:"structure"`
+
+        LocationConstraint *string `type:"string" enum:"BucketLocationConstraint"`
+}
+
+// String returns the string representation
+func (s GetBucketLocationOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketLocationOutput) GoString() string {
+        return s.String()
+}
+
+// SetLocationConstraint sets the LocationConstraint field's value.
+func (s *GetBucketLocationOutput) SetLocationConstraint(v string) *GetBucketLocationOutput {
+        s.LocationConstraint = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLoggingRequest
+type GetBucketLoggingInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketLoggingInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketLoggingInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetBucketLoggingInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetBucketLoggingInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetBucketLoggingInput) SetBucket(v string) *GetBucketLoggingInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLoggingOutput
+type GetBucketLoggingOutput struct {
+        _ struct{} `type:"structure"`
+
+        LoggingEnabled *LoggingEnabled `type:"structure"`
+}
+
+// String returns the string representation
+func (s GetBucketLoggingOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketLoggingOutput) GoString() string {
+        return s.String()
+}
+
+// SetLoggingEnabled sets the LoggingEnabled field's value.
+func (s *GetBucketLoggingOutput) SetLoggingEnabled(v *LoggingEnabled) *GetBucketLoggingOutput {
+        s.LoggingEnabled = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketMetricsConfigurationRequest
+type GetBucketMetricsConfigurationInput struct {
+        _ struct{} `type:"structure"`
+
+        // The name of the bucket containing the metrics configuration to retrieve.
+        //
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // The ID used to identify the metrics configuration.
+        //
+        // Id is a required field
+        Id *string `location:"querystring" locationName:"id" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketMetricsConfigurationInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketMetricsConfigurationInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetBucketMetricsConfigurationInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetBucketMetricsConfigurationInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Id == nil {
+                invalidParams.Add(request.NewErrParamRequired("Id"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetBucketMetricsConfigurationInput) SetBucket(v string) *GetBucketMetricsConfigurationInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetId sets the Id field's value.
+func (s *GetBucketMetricsConfigurationInput) SetId(v string) *GetBucketMetricsConfigurationInput {
+        s.Id = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketMetricsConfigurationOutput
+type GetBucketMetricsConfigurationOutput struct {
+        _ struct{} `type:"structure" payload:"MetricsConfiguration"`
+
+        // Specifies the metrics configuration.
+        MetricsConfiguration *MetricsConfiguration `type:"structure"`
+}
+
+// String returns the string representation
+func (s GetBucketMetricsConfigurationOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketMetricsConfigurationOutput) GoString() string {
+        return s.String()
+}
+
+// SetMetricsConfiguration sets the MetricsConfiguration field's value.
+func (s *GetBucketMetricsConfigurationOutput) SetMetricsConfiguration(v *MetricsConfiguration) *GetBucketMetricsConfigurationOutput {
+        s.MetricsConfiguration = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketNotificationConfigurationRequest
+type GetBucketNotificationConfigurationRequest struct {
+        _ struct{} `type:"structure"`
+
+        // Name of the bucket to get the notification configuration for.
+        //
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketNotificationConfigurationRequest) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketNotificationConfigurationRequest) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetBucketNotificationConfigurationRequest) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetBucketNotificationConfigurationRequest"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetBucketNotificationConfigurationRequest) SetBucket(v string) *GetBucketNotificationConfigurationRequest {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketPolicyRequest
+type GetBucketPolicyInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketPolicyInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketPolicyInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetBucketPolicyInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetBucketPolicyInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetBucketPolicyInput) SetBucket(v string) *GetBucketPolicyInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketPolicyOutput
+type GetBucketPolicyOutput struct {
+        _ struct{} `type:"structure" payload:"Policy"`
+
+        // The bucket policy as a JSON document.
+        Policy *string `type:"string"`
+}
+
+// String returns the string representation
+func (s GetBucketPolicyOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketPolicyOutput) GoString() string {
+        return s.String()
+}
+
+// SetPolicy sets the Policy field's value.
+func (s *GetBucketPolicyOutput) SetPolicy(v string) *GetBucketPolicyOutput {
+        s.Policy = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketReplicationRequest
+type GetBucketReplicationInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketReplicationInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketReplicationInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetBucketReplicationInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetBucketReplicationInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetBucketReplicationInput) SetBucket(v string) *GetBucketReplicationInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketReplicationOutput
+type GetBucketReplicationOutput struct {
+        _ struct{} `type:"structure" payload:"ReplicationConfiguration"`
+
+        // Container for replication rules. You can add as many as 1,000 rules. Total
+        // replication configuration size can be up to 2 MB.
+        ReplicationConfiguration *ReplicationConfiguration `type:"structure"`
+}
+
+// String returns the string representation
+func (s GetBucketReplicationOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketReplicationOutput) GoString() string {
+        return s.String()
+}
+
+// SetReplicationConfiguration sets the ReplicationConfiguration field's value.
+func (s *GetBucketReplicationOutput) SetReplicationConfiguration(v *ReplicationConfiguration) *GetBucketReplicationOutput {
+        s.ReplicationConfiguration = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketRequestPaymentRequest
+type GetBucketRequestPaymentInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketRequestPaymentInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketRequestPaymentInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetBucketRequestPaymentInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetBucketRequestPaymentInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetBucketRequestPaymentInput) SetBucket(v string) *GetBucketRequestPaymentInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketRequestPaymentOutput
+type GetBucketRequestPaymentOutput struct {
+        _ struct{} `type:"structure"`
+
+        // Specifies who pays for the download and request fees.
+        Payer *string `type:"string" enum:"Payer"`
+}
+
+// String returns the string representation
+func (s GetBucketRequestPaymentOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketRequestPaymentOutput) GoString() string {
+        return s.String()
+}
+
+// SetPayer sets the Payer field's value.
+func (s *GetBucketRequestPaymentOutput) SetPayer(v string) *GetBucketRequestPaymentOutput {
+        s.Payer = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketTaggingRequest
+type GetBucketTaggingInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketTaggingInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketTaggingInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetBucketTaggingInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetBucketTaggingInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetBucketTaggingInput) SetBucket(v string) *GetBucketTaggingInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketTaggingOutput
+type GetBucketTaggingOutput struct {
+        _ struct{} `type:"structure"`
+
+        // TagSet is a required field
+        TagSet []*Tag `locationNameList:"Tag" type:"list" required:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketTaggingOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketTaggingOutput) GoString() string {
+        return s.String()
+}
+
+// SetTagSet sets the TagSet field's value.
+func (s *GetBucketTaggingOutput) SetTagSet(v []*Tag) *GetBucketTaggingOutput {
+        s.TagSet = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketVersioningRequest
+type GetBucketVersioningInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketVersioningInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketVersioningInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetBucketVersioningInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetBucketVersioningInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetBucketVersioningInput) SetBucket(v string) *GetBucketVersioningInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketVersioningOutput
+type GetBucketVersioningOutput struct {
+        _ struct{} `type:"structure"`
+
+        // Specifies whether MFA delete is enabled in the bucket versioning configuration.
+        // This element is only returned if the bucket has been configured with MFA
+        // delete. If the bucket has never been so configured, this element is not returned.
+        MFADelete *string `locationName:"MfaDelete" type:"string" enum:"MFADeleteStatus"`
+
+        // The versioning state of the bucket.
+        Status *string `type:"string" enum:"BucketVersioningStatus"`
+}
+
+// String returns the string representation
+func (s GetBucketVersioningOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketVersioningOutput) GoString() string {
+        return s.String()
+}
+
+// SetMFADelete sets the MFADelete field's value.
+func (s *GetBucketVersioningOutput) SetMFADelete(v string) *GetBucketVersioningOutput {
+        s.MFADelete = &v
+        return s
+}
+
+// SetStatus sets the Status field's value.
+func (s *GetBucketVersioningOutput) SetStatus(v string) *GetBucketVersioningOutput {
+        s.Status = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketWebsiteRequest
+type GetBucketWebsiteInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetBucketWebsiteInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketWebsiteInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetBucketWebsiteInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetBucketWebsiteInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetBucketWebsiteInput) SetBucket(v string) *GetBucketWebsiteInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketWebsiteOutput
+type GetBucketWebsiteOutput struct {
+        _ struct{} `type:"structure"`
+
+        ErrorDocument *ErrorDocument `type:"structure"`
+
+        IndexDocument *IndexDocument `type:"structure"`
+
+        RedirectAllRequestsTo *RedirectAllRequestsTo `type:"structure"`
+
+        RoutingRules []*RoutingRule `locationNameList:"RoutingRule" type:"list"`
+}
+
+// String returns the string representation
+func (s GetBucketWebsiteOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetBucketWebsiteOutput) GoString() string {
+        return s.String()
+}
+
+// SetErrorDocument sets the ErrorDocument field's value.
+func (s *GetBucketWebsiteOutput) SetErrorDocument(v *ErrorDocument) *GetBucketWebsiteOutput {
+        s.ErrorDocument = v
+        return s
+}
+
+// SetIndexDocument sets the IndexDocument field's value.
+func (s *GetBucketWebsiteOutput) SetIndexDocument(v *IndexDocument) *GetBucketWebsiteOutput {
+        s.IndexDocument = v
+        return s
+}
+
+// SetRedirectAllRequestsTo sets the RedirectAllRequestsTo field's value.
+func (s *GetBucketWebsiteOutput) SetRedirectAllRequestsTo(v *RedirectAllRequestsTo) *GetBucketWebsiteOutput {
+        s.RedirectAllRequestsTo = v
+        return s
+}
+
+// SetRoutingRules sets the RoutingRules field's value.
+func (s *GetBucketWebsiteOutput) SetRoutingRules(v []*RoutingRule) *GetBucketWebsiteOutput {
+        s.RoutingRules = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectAclRequest
+type GetObjectAclInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Key is a required field
+        Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`
+
+        // Confirms that the requester knows that she or he will be charged for the
+        // request. Bucket owners need not specify this parameter in their requests.
+        // Documentation on downloading objects from requester pays buckets can be found
+        // at http://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html
+        RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string" enum:"RequestPayer"`
+
+        // VersionId used to reference a specific version of the object.
+        VersionId *string `location:"querystring" locationName:"versionId" type:"string"`
+}
+
+// String returns the string representation
+func (s GetObjectAclInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetObjectAclInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetObjectAclInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetObjectAclInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetObjectAclInput) SetBucket(v string) *GetObjectAclInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *GetObjectAclInput) SetKey(v string) *GetObjectAclInput {
+        s.Key = &v
+        return s
+}
+
+// SetRequestPayer sets the RequestPayer field's value.
+func (s *GetObjectAclInput) SetRequestPayer(v string) *GetObjectAclInput {
+        s.RequestPayer = &v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *GetObjectAclInput) SetVersionId(v string) *GetObjectAclInput {
+        s.VersionId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectAclOutput
+type GetObjectAclOutput struct {
+        _ struct{} `type:"structure"`
+
+        // A list of grants.
+        Grants []*Grant `locationName:"AccessControlList" locationNameList:"Grant" type:"list"`
+
+        Owner *Owner `type:"structure"`
+
+        // If present, indicates that the requester was successfully charged for the
+        // request.
+        RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`
+}
+
+// String returns the string representation
+func (s GetObjectAclOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetObjectAclOutput) GoString() string {
+        return s.String()
+}
+
+// SetGrants sets the Grants field's value.
+func (s *GetObjectAclOutput) SetGrants(v []*Grant) *GetObjectAclOutput {
+        s.Grants = v
+        return s
+}
+
+// SetOwner sets the Owner field's value.
+func (s *GetObjectAclOutput) SetOwner(v *Owner) *GetObjectAclOutput {
+        s.Owner = v
+        return s
+}
+
+// SetRequestCharged sets the RequestCharged field's value.
+func (s *GetObjectAclOutput) SetRequestCharged(v string) *GetObjectAclOutput {
+        s.RequestCharged = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectRequest
+type GetObjectInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Return the object only if its entity tag (ETag) is the same as the one specified,
+        // otherwise return a 412 (precondition failed).
+        IfMatch *string `location:"header" locationName:"If-Match" type:"string"`
+
+        // Return the object only if it has been modified since the specified time,
+        // otherwise return a 304 (not modified).
+        IfModifiedSince *time.Time `location:"header" locationName:"If-Modified-Since" type:"timestamp" timestampFormat:"rfc822"`
+
+        // Return the object only if its entity tag (ETag) is different from the one
+        // specified, otherwise return a 304 (not modified).
+        IfNoneMatch *string `location:"header" locationName:"If-None-Match" type:"string"`
+
+        // Return the object only if it has not been modified since the specified time,
+        // otherwise return a 412 (precondition failed).
+        IfUnmodifiedSince *time.Time `location:"header" locationName:"If-Unmodified-Since" type:"timestamp" timestampFormat:"rfc822"`
+
+        // Key is a required field
+        Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`
+
+        // Part number of the object being read. This is a positive integer between
+        // 1 and 10,000. Effectively performs a 'ranged' GET request for the part specified.
+        // Useful for downloading just a part of an object.
+        PartNumber *int64 `location:"querystring" locationName:"partNumber" type:"integer"`
+
+        // Downloads the specified range bytes of an object. For more information about
+        // the HTTP Range header, go to http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.
+        Range *string `location:"header" locationName:"Range" type:"string"`
+
+        // Confirms that the requester knows that she or he will be charged for the
+        // request. Bucket owners need not specify this parameter in their requests.
+        // Documentation on downloading objects from requester pays buckets can be found
+        // at http://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html
+        RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string" enum:"RequestPayer"`
+
+        // Sets the Cache-Control header of the response.
+        ResponseCacheControl *string `location:"querystring" locationName:"response-cache-control" type:"string"`
+
+        // Sets the Content-Disposition header of the response
+        ResponseContentDisposition *string `location:"querystring" locationName:"response-content-disposition" type:"string"`
+
+        // Sets the Content-Encoding header of the response.
+        ResponseContentEncoding *string `location:"querystring" locationName:"response-content-encoding" type:"string"`
+
+        // Sets the Content-Language header of the response.
+        ResponseContentLanguage *string `location:"querystring" locationName:"response-content-language" type:"string"`
+
+        // Sets the Content-Type header of the response.
+        ResponseContentType *string `location:"querystring" locationName:"response-content-type" type:"string"`
+
+        // Sets the Expires header of the response.
+        ResponseExpires *time.Time `location:"querystring" locationName:"response-expires" type:"timestamp" timestampFormat:"iso8601"`
+
+        // Specifies the algorithm to use to when encrypting the object (e.g., AES256).
+        SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`
+
+        // Specifies the customer-provided encryption key for Amazon S3 to use in encrypting
+        // data. This value is used to store the object and then it is discarded; Amazon
+        // does not store the encryption key. The key must be appropriate for use with
+        // the algorithm specified in the x-amz-server-side​-encryption​-customer-algorithm
+        // header.
+        SSECustomerKey *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key" type:"string"`
+
+        // Specifies the 128-bit MD5 digest of the encryption key according to RFC 1321.
+        // Amazon S3 uses this header for a message integrity check to ensure the encryption
+        // key was transmitted without error.
+        SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`
+
+        // VersionId used to reference a specific version of the object.
+        VersionId *string `location:"querystring" locationName:"versionId" type:"string"`
+}
+
+// String returns the string representation
+func (s GetObjectInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetObjectInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetObjectInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetObjectInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetObjectInput) SetBucket(v string) *GetObjectInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetIfMatch sets the IfMatch field's value.
+func (s *GetObjectInput) SetIfMatch(v string) *GetObjectInput {
+        s.IfMatch = &v
+        return s
+}
+
+// SetIfModifiedSince sets the IfModifiedSince field's value.
+func (s *GetObjectInput) SetIfModifiedSince(v time.Time) *GetObjectInput {
+        s.IfModifiedSince = &v
+        return s
+}
+
+// SetIfNoneMatch sets the IfNoneMatch field's value.
+func (s *GetObjectInput) SetIfNoneMatch(v string) *GetObjectInput {
+        s.IfNoneMatch = &v
+        return s
+}
+
+// SetIfUnmodifiedSince sets the IfUnmodifiedSince field's value.
+func (s *GetObjectInput) SetIfUnmodifiedSince(v time.Time) *GetObjectInput {
+        s.IfUnmodifiedSince = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *GetObjectInput) SetKey(v string) *GetObjectInput {
+        s.Key = &v
+        return s
+}
+
+// SetPartNumber sets the PartNumber field's value.
+func (s *GetObjectInput) SetPartNumber(v int64) *GetObjectInput {
+        s.PartNumber = &v
+        return s
+}
+
+// SetRange sets the Range field's value.
+func (s *GetObjectInput) SetRange(v string) *GetObjectInput {
+        s.Range = &v
+        return s
+}
+
+// SetRequestPayer sets the RequestPayer field's value.
+func (s *GetObjectInput) SetRequestPayer(v string) *GetObjectInput {
+        s.RequestPayer = &v
+        return s
+}
+
+// SetResponseCacheControl sets the ResponseCacheControl field's value.
+func (s *GetObjectInput) SetResponseCacheControl(v string) *GetObjectInput {
+        s.ResponseCacheControl = &v
+        return s
+}
+
+// SetResponseContentDisposition sets the ResponseContentDisposition field's value.
+func (s *GetObjectInput) SetResponseContentDisposition(v string) *GetObjectInput {
+        s.ResponseContentDisposition = &v
+        return s
+}
+
+// SetResponseContentEncoding sets the ResponseContentEncoding field's value.
+func (s *GetObjectInput) SetResponseContentEncoding(v string) *GetObjectInput {
+        s.ResponseContentEncoding = &v
+        return s
+}
+
+// SetResponseContentLanguage sets the ResponseContentLanguage field's value.
+func (s *GetObjectInput) SetResponseContentLanguage(v string) *GetObjectInput {
+        s.ResponseContentLanguage = &v
+        return s
+}
+
+// SetResponseContentType sets the ResponseContentType field's value.
+func (s *GetObjectInput) SetResponseContentType(v string) *GetObjectInput {
+        s.ResponseContentType = &v
+        return s
+}
+
+// SetResponseExpires sets the ResponseExpires field's value.
+func (s *GetObjectInput) SetResponseExpires(v time.Time) *GetObjectInput {
+        s.ResponseExpires = &v
+        return s
+}
+
+// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.
+func (s *GetObjectInput) SetSSECustomerAlgorithm(v string) *GetObjectInput {
+        s.SSECustomerAlgorithm = &v
+        return s
+}
+
+// SetSSECustomerKey sets the SSECustomerKey field's value.
+func (s *GetObjectInput) SetSSECustomerKey(v string) *GetObjectInput {
+        s.SSECustomerKey = &v
+        return s
+}
+
+// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.
+func (s *GetObjectInput) SetSSECustomerKeyMD5(v string) *GetObjectInput {
+        s.SSECustomerKeyMD5 = &v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *GetObjectInput) SetVersionId(v string) *GetObjectInput {
+        s.VersionId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectOutput
+type GetObjectOutput struct {
+        _ struct{} `type:"structure" payload:"Body"`
+
+        AcceptRanges *string `location:"header" locationName:"accept-ranges" type:"string"`
+
+        // Object data.
+        Body io.ReadCloser `type:"blob"`
+
+        // Specifies caching behavior along the request/reply chain.
+        CacheControl *string `location:"header" locationName:"Cache-Control" type:"string"`
+
+        // Specifies presentational information for the object.
+        ContentDisposition *string `location:"header" locationName:"Content-Disposition" type:"string"`
+
+        // Specifies what content encodings have been applied to the object and thus
+        // what decoding mechanisms must be applied to obtain the media-type referenced
+        // by the Content-Type header field.
+        ContentEncoding *string `location:"header" locationName:"Content-Encoding" type:"string"`
+
+        // The language the content is in.
+        ContentLanguage *string `location:"header" locationName:"Content-Language" type:"string"`
+
+        // Size of the body in bytes.
+        ContentLength *int64 `location:"header" locationName:"Content-Length" type:"long"`
+
+        // The portion of the object returned in the response.
+        ContentRange *string `location:"header" locationName:"Content-Range" type:"string"`
+
+        // A standard MIME type describing the format of the object data.
+        ContentType *string `location:"header" locationName:"Content-Type" type:"string"`
+
+        // Specifies whether the object retrieved was (true) or was not (false) a Delete
+        // Marker. If false, this response header does not appear in the response.
+        DeleteMarker *bool `location:"header" locationName:"x-amz-delete-marker" type:"boolean"`
+
+        // An ETag is an opaque identifier assigned by a web server to a specific version
+        // of a resource found at a URL
+        ETag *string `location:"header" locationName:"ETag" type:"string"`
+
+        // If the object expiration is configured (see PUT Bucket lifecycle), the response
+        // includes this header. It includes the expiry-date and rule-id key value pairs
+        // providing object expiration information. The value of the rule-id is URL
+        // encoded.
+        Expiration *string `location:"header" locationName:"x-amz-expiration" type:"string"`
+
+        // The date and time at which the object is no longer cacheable.
+        Expires *string `location:"header" locationName:"Expires" type:"string"`
+
+        // Last modified date of the object
+        LastModified *time.Time `location:"header" locationName:"Last-Modified" type:"timestamp" timestampFormat:"rfc822"`
+
+        // A map of metadata to store with the object in S3.
+        Metadata map[string]*string `location:"headers" locationName:"x-amz-meta-" type:"map"`
+
+        // This is set to the number of metadata entries not returned in x-amz-meta
+        // headers. This can happen if you create metadata using an API like SOAP that
+        // supports more flexible metadata than the REST API. For example, using SOAP,
+        // you can create metadata whose values are not legal HTTP headers.
+        MissingMeta *int64 `location:"header" locationName:"x-amz-missing-meta" type:"integer"`
+
+        // The count of parts this object has.
+        PartsCount *int64 `location:"header" locationName:"x-amz-mp-parts-count" type:"integer"`
+
+        ReplicationStatus *string `location:"header" locationName:"x-amz-replication-status" type:"string" enum:"ReplicationStatus"`
+
+        // If present, indicates that the requester was successfully charged for the
+        // request.
+        RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`
+
+        // Provides information about object restoration operation and expiration time
+        // of the restored object copy.
+        Restore *string `location:"header" locationName:"x-amz-restore" type:"string"`
+
+        // If server-side encryption with a customer-provided encryption key was requested,
+        // the response will include this header confirming the encryption algorithm
+        // used.
+        SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`
+
+        // If server-side encryption with a customer-provided encryption key was requested,
+        // the response will include this header to provide round trip message integrity
+        // verification of the customer-provided encryption key.
+        SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`
+
+        // If present, specifies the ID of the AWS Key Management Service (KMS) master
+        // encryption key that was used for the object.
+        SSEKMSKeyId *string `location:"header" locationName:"x-amz-server-side-encryption-aws-kms-key-id" type:"string"`
+
+        // The Server-side encryption algorithm used when storing this object in S3
+        // (e.g., AES256, aws:kms).
+        ServerSideEncryption *string `location:"header" locationName:"x-amz-server-side-encryption" type:"string" enum:"ServerSideEncryption"`
+
+        StorageClass *string `location:"header" locationName:"x-amz-storage-class" type:"string" enum:"StorageClass"`
+
+        // The number of tags, if any, on the object.
+        TagCount *int64 `location:"header" locationName:"x-amz-tagging-count" type:"integer"`
+
+        // Version of the object.
+        VersionId *string `location:"header" locationName:"x-amz-version-id" type:"string"`
+
+        // If the bucket is configured as a website, redirects requests for this object
+        // to another object in the same bucket or to an external URL. Amazon S3 stores
+        // the value of this header in the object metadata.
+        WebsiteRedirectLocation *string `location:"header" locationName:"x-amz-website-redirect-location" type:"string"`
+}
+
+// String returns the string representation
+func (s GetObjectOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetObjectOutput) GoString() string {
+        return s.String()
+}
+
+// SetAcceptRanges sets the AcceptRanges field's value.
+func (s *GetObjectOutput) SetAcceptRanges(v string) *GetObjectOutput {
+        s.AcceptRanges = &v
+        return s
+}
+
+// SetBody sets the Body field's value.
+func (s *GetObjectOutput) SetBody(v io.ReadCloser) *GetObjectOutput {
+        s.Body = v
+        return s
+}
+
+// SetCacheControl sets the CacheControl field's value.
+func (s *GetObjectOutput) SetCacheControl(v string) *GetObjectOutput {
+        s.CacheControl = &v
+        return s
+}
+
+// SetContentDisposition sets the ContentDisposition field's value.
+func (s *GetObjectOutput) SetContentDisposition(v string) *GetObjectOutput {
+        s.ContentDisposition = &v
+        return s
+}
+
+// SetContentEncoding sets the ContentEncoding field's value.
+func (s *GetObjectOutput) SetContentEncoding(v string) *GetObjectOutput {
+        s.ContentEncoding = &v
+        return s
+}
+
+// SetContentLanguage sets the ContentLanguage field's value.
+func (s *GetObjectOutput) SetContentLanguage(v string) *GetObjectOutput {
+        s.ContentLanguage = &v
+        return s
+}
+
+// SetContentLength sets the ContentLength field's value.
+func (s *GetObjectOutput) SetContentLength(v int64) *GetObjectOutput {
+        s.ContentLength = &v
+        return s
+}
+
+// SetContentRange sets the ContentRange field's value.
+func (s *GetObjectOutput) SetContentRange(v string) *GetObjectOutput {
+        s.ContentRange = &v
+        return s
+}
+
+// SetContentType sets the ContentType field's value.
+func (s *GetObjectOutput) SetContentType(v string) *GetObjectOutput {
+        s.ContentType = &v
+        return s
+}
+
+// SetDeleteMarker sets the DeleteMarker field's value.
+func (s *GetObjectOutput) SetDeleteMarker(v bool) *GetObjectOutput {
+        s.DeleteMarker = &v
+        return s
+}
+
+// SetETag sets the ETag field's value.
+func (s *GetObjectOutput) SetETag(v string) *GetObjectOutput {
+        s.ETag = &v
+        return s
+}
+
+// SetExpiration sets the Expiration field's value.
+func (s *GetObjectOutput) SetExpiration(v string) *GetObjectOutput {
+        s.Expiration = &v
+        return s
+}
+
+// SetExpires sets the Expires field's value.
+func (s *GetObjectOutput) SetExpires(v string) *GetObjectOutput {
+        s.Expires = &v
+        return s
+}
+
+// SetLastModified sets the LastModified field's value.
+func (s *GetObjectOutput) SetLastModified(v time.Time) *GetObjectOutput {
+        s.LastModified = &v
+        return s
+}
+
+// SetMetadata sets the Metadata field's value.
+func (s *GetObjectOutput) SetMetadata(v map[string]*string) *GetObjectOutput {
+        s.Metadata = v
+        return s
+}
+
+// SetMissingMeta sets the MissingMeta field's value.
+func (s *GetObjectOutput) SetMissingMeta(v int64) *GetObjectOutput {
+        s.MissingMeta = &v
+        return s
+}
+
+// SetPartsCount sets the PartsCount field's value.
+func (s *GetObjectOutput) SetPartsCount(v int64) *GetObjectOutput {
+        s.PartsCount = &v
+        return s
+}
+
+// SetReplicationStatus sets the ReplicationStatus field's value.
+func (s *GetObjectOutput) SetReplicationStatus(v string) *GetObjectOutput {
+        s.ReplicationStatus = &v
+        return s
+}
+
+// SetRequestCharged sets the RequestCharged field's value.
+func (s *GetObjectOutput) SetRequestCharged(v string) *GetObjectOutput {
+        s.RequestCharged = &v
+        return s
+}
+
+// SetRestore sets the Restore field's value.
+func (s *GetObjectOutput) SetRestore(v string) *GetObjectOutput {
+        s.Restore = &v
+        return s
+}
+
+// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.
+func (s *GetObjectOutput) SetSSECustomerAlgorithm(v string) *GetObjectOutput {
+        s.SSECustomerAlgorithm = &v
+        return s
+}
+
+// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.
+func (s *GetObjectOutput) SetSSECustomerKeyMD5(v string) *GetObjectOutput {
+        s.SSECustomerKeyMD5 = &v
+        return s
+}
+
+// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.
+func (s *GetObjectOutput) SetSSEKMSKeyId(v string) *GetObjectOutput {
+        s.SSEKMSKeyId = &v
+        return s
+}
+
+// SetServerSideEncryption sets the ServerSideEncryption field's value.
+func (s *GetObjectOutput) SetServerSideEncryption(v string) *GetObjectOutput {
+        s.ServerSideEncryption = &v
+        return s
+}
+
+// SetStorageClass sets the StorageClass field's value.
+func (s *GetObjectOutput) SetStorageClass(v string) *GetObjectOutput {
+        s.StorageClass = &v
+        return s
+}
+
+// SetTagCount sets the TagCount field's value.
+func (s *GetObjectOutput) SetTagCount(v int64) *GetObjectOutput {
+        s.TagCount = &v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *GetObjectOutput) SetVersionId(v string) *GetObjectOutput {
+        s.VersionId = &v
+        return s
+}
+
+// SetWebsiteRedirectLocation sets the WebsiteRedirectLocation field's value.
+func (s *GetObjectOutput) SetWebsiteRedirectLocation(v string) *GetObjectOutput {
+        s.WebsiteRedirectLocation = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectTaggingRequest
+type GetObjectTaggingInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Key is a required field
+        Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`
+
+        VersionId *string `location:"querystring" locationName:"versionId" type:"string"`
+}
+
+// String returns the string representation
+func (s GetObjectTaggingInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetObjectTaggingInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetObjectTaggingInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetObjectTaggingInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetObjectTaggingInput) SetBucket(v string) *GetObjectTaggingInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *GetObjectTaggingInput) SetKey(v string) *GetObjectTaggingInput {
+        s.Key = &v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *GetObjectTaggingInput) SetVersionId(v string) *GetObjectTaggingInput {
+        s.VersionId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectTaggingOutput
+type GetObjectTaggingOutput struct {
+        _ struct{} `type:"structure"`
+
+        // TagSet is a required field
+        TagSet []*Tag `locationNameList:"Tag" type:"list" required:"true"`
+
+        VersionId *string `location:"header" locationName:"x-amz-version-id" type:"string"`
+}
+
+// String returns the string representation
+func (s GetObjectTaggingOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetObjectTaggingOutput) GoString() string {
+        return s.String()
+}
+
+// SetTagSet sets the TagSet field's value.
+func (s *GetObjectTaggingOutput) SetTagSet(v []*Tag) *GetObjectTaggingOutput {
+        s.TagSet = v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *GetObjectTaggingOutput) SetVersionId(v string) *GetObjectTaggingOutput {
+        s.VersionId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectTorrentRequest
+type GetObjectTorrentInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Key is a required field
+        Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`
+
+        // Confirms that the requester knows that she or he will be charged for the
+        // request. Bucket owners need not specify this parameter in their requests.
+        // Documentation on downloading objects from requester pays buckets can be found
+        // at http://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html
+        RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string" enum:"RequestPayer"`
+}
+
+// String returns the string representation
+func (s GetObjectTorrentInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetObjectTorrentInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetObjectTorrentInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetObjectTorrentInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *GetObjectTorrentInput) SetBucket(v string) *GetObjectTorrentInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *GetObjectTorrentInput) SetKey(v string) *GetObjectTorrentInput {
+        s.Key = &v
+        return s
+}
+
+// SetRequestPayer sets the RequestPayer field's value.
+func (s *GetObjectTorrentInput) SetRequestPayer(v string) *GetObjectTorrentInput {
+        s.RequestPayer = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectTorrentOutput
+type GetObjectTorrentOutput struct {
+        _ struct{} `type:"structure" payload:"Body"`
+
+        Body io.ReadCloser `type:"blob"`
+
+        // If present, indicates that the requester was successfully charged for the
+        // request.
+        RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`
+}
+
+// String returns the string representation
+func (s GetObjectTorrentOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetObjectTorrentOutput) GoString() string {
+        return s.String()
+}
+
+// SetBody sets the Body field's value.
+func (s *GetObjectTorrentOutput) SetBody(v io.ReadCloser) *GetObjectTorrentOutput {
+        s.Body = v
+        return s
+}
+
+// SetRequestCharged sets the RequestCharged field's value.
+func (s *GetObjectTorrentOutput) SetRequestCharged(v string) *GetObjectTorrentOutput {
+        s.RequestCharged = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GlacierJobParameters
+type GlacierJobParameters struct {
+        _ struct{} `type:"structure"`
+
+        // Glacier retrieval tier at which the restore will be processed.
+        //
+        // Tier is a required field
+        Tier *string `type:"string" required:"true" enum:"Tier"`
+}
+
+// String returns the string representation
+func (s GlacierJobParameters) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GlacierJobParameters) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GlacierJobParameters) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GlacierJobParameters"}
+        if s.Tier == nil {
+                invalidParams.Add(request.NewErrParamRequired("Tier"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetTier sets the Tier field's value.
+func (s *GlacierJobParameters) SetTier(v string) *GlacierJobParameters {
+        s.Tier = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Grant
+type Grant struct {
+        _ struct{} `type:"structure"`
+
+        Grantee *Grantee `type:"structure"`
+
+        // Specifies the permission given to the grantee.
+        Permission *string `type:"string" enum:"Permission"`
+}
+
+// String returns the string representation
+func (s Grant) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Grant) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *Grant) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "Grant"}
+        if s.Grantee != nil {
+                if err := s.Grantee.Validate(); err != nil {
+                        invalidParams.AddNested("Grantee", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetGrantee sets the Grantee field's value.
+func (s *Grant) SetGrantee(v *Grantee) *Grant {
+        s.Grantee = v
+        return s
+}
+
+// SetPermission sets the Permission field's value.
+func (s *Grant) SetPermission(v string) *Grant {
+        s.Permission = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Grantee
+type Grantee struct {
+        _ struct{} `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"`
+
+        // Screen name of the grantee.
+        DisplayName *string `type:"string"`
+
+        // Email address of the grantee.
+        EmailAddress *string `type:"string"`
+
+        // The canonical user ID of the grantee.
+        ID *string `type:"string"`
+
+        // Type of grantee
+        //
+        // Type is a required field
+        Type *string `locationName:"xsi:type" type:"string" xmlAttribute:"true" required:"true" enum:"Type"`
+
+        // URI of the grantee group.
+        URI *string `type:"string"`
+}
+
+// String returns the string representation
+func (s Grantee) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Grantee) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *Grantee) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "Grantee"}
+        if s.Type == nil {
+                invalidParams.Add(request.NewErrParamRequired("Type"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetDisplayName sets the DisplayName field's value.
+func (s *Grantee) SetDisplayName(v string) *Grantee {
+        s.DisplayName = &v
+        return s
+}
+
+// SetEmailAddress sets the EmailAddress field's value.
+func (s *Grantee) SetEmailAddress(v string) *Grantee {
+        s.EmailAddress = &v
+        return s
+}
+
+// SetID sets the ID field's value.
+func (s *Grantee) SetID(v string) *Grantee {
+        s.ID = &v
+        return s
+}
+
+// SetType sets the Type field's value.
+func (s *Grantee) SetType(v string) *Grantee {
+        s.Type = &v
+        return s
+}
+
+// SetURI sets the URI field's value.
+func (s *Grantee) SetURI(v string) *Grantee {
+        s.URI = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/HeadBucketRequest
+type HeadBucketInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s HeadBucketInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s HeadBucketInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *HeadBucketInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "HeadBucketInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *HeadBucketInput) SetBucket(v string) *HeadBucketInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/HeadBucketOutput
+type HeadBucketOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s HeadBucketOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s HeadBucketOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/HeadObjectRequest
+type HeadObjectInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Return the object only if its entity tag (ETag) is the same as the one specified,
+        // otherwise return a 412 (precondition failed).
+        IfMatch *string `location:"header" locationName:"If-Match" type:"string"`
+
+        // Return the object only if it has been modified since the specified time,
+        // otherwise return a 304 (not modified).
+        IfModifiedSince *time.Time `location:"header" locationName:"If-Modified-Since" type:"timestamp" timestampFormat:"rfc822"`
+
+        // Return the object only if its entity tag (ETag) is different from the one
+        // specified, otherwise return a 304 (not modified).
+        IfNoneMatch *string `location:"header" locationName:"If-None-Match" type:"string"`
+
+        // Return the object only if it has not been modified since the specified time,
+        // otherwise return a 412 (precondition failed).
+        IfUnmodifiedSince *time.Time `location:"header" locationName:"If-Unmodified-Since" type:"timestamp" timestampFormat:"rfc822"`
+
+        // Key is a required field
+        Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`
+
+        // Part number of the object being read. This is a positive integer between
+        // 1 and 10,000. Effectively performs a 'ranged' HEAD request for the part specified.
+        // Useful querying about the size of the part and the number of parts in this
+        // object.
+        PartNumber *int64 `location:"querystring" locationName:"partNumber" type:"integer"`
+
+        // Downloads the specified range bytes of an object. For more information about
+        // the HTTP Range header, go to http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.
+        Range *string `location:"header" locationName:"Range" type:"string"`
+
+        // Confirms that the requester knows that she or he will be charged for the
+        // request. Bucket owners need not specify this parameter in their requests.
+        // Documentation on downloading objects from requester pays buckets can be found
+        // at http://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html
+        RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string" enum:"RequestPayer"`
+
+        // Specifies the algorithm to use to when encrypting the object (e.g., AES256).
+        SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`
+
+        // Specifies the customer-provided encryption key for Amazon S3 to use in encrypting
+        // data. This value is used to store the object and then it is discarded; Amazon
+        // does not store the encryption key. The key must be appropriate for use with
+        // the algorithm specified in the x-amz-server-side​-encryption​-customer-algorithm
+        // header.
+        SSECustomerKey *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key" type:"string"`
+
+        // Specifies the 128-bit MD5 digest of the encryption key according to RFC 1321.
+        // Amazon S3 uses this header for a message integrity check to ensure the encryption
+        // key was transmitted without error.
+        SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`
+
+        // VersionId used to reference a specific version of the object.
+        VersionId *string `location:"querystring" locationName:"versionId" type:"string"`
+}
+
+// String returns the string representation
+func (s HeadObjectInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s HeadObjectInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *HeadObjectInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "HeadObjectInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *HeadObjectInput) SetBucket(v string) *HeadObjectInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetIfMatch sets the IfMatch field's value.
+func (s *HeadObjectInput) SetIfMatch(v string) *HeadObjectInput {
+        s.IfMatch = &v
+        return s
+}
+
+// SetIfModifiedSince sets the IfModifiedSince field's value.
+func (s *HeadObjectInput) SetIfModifiedSince(v time.Time) *HeadObjectInput {
+        s.IfModifiedSince = &v
+        return s
+}
+
+// SetIfNoneMatch sets the IfNoneMatch field's value.
+func (s *HeadObjectInput) SetIfNoneMatch(v string) *HeadObjectInput {
+        s.IfNoneMatch = &v
+        return s
+}
+
+// SetIfUnmodifiedSince sets the IfUnmodifiedSince field's value.
+func (s *HeadObjectInput) SetIfUnmodifiedSince(v time.Time) *HeadObjectInput {
+        s.IfUnmodifiedSince = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *HeadObjectInput) SetKey(v string) *HeadObjectInput {
+        s.Key = &v
+        return s
+}
+
+// SetPartNumber sets the PartNumber field's value.
+func (s *HeadObjectInput) SetPartNumber(v int64) *HeadObjectInput {
+        s.PartNumber = &v
+        return s
+}
+
+// SetRange sets the Range field's value.
+func (s *HeadObjectInput) SetRange(v string) *HeadObjectInput {
+        s.Range = &v
+        return s
+}
+
+// SetRequestPayer sets the RequestPayer field's value.
+func (s *HeadObjectInput) SetRequestPayer(v string) *HeadObjectInput {
+        s.RequestPayer = &v
+        return s
+}
+
+// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.
+func (s *HeadObjectInput) SetSSECustomerAlgorithm(v string) *HeadObjectInput {
+        s.SSECustomerAlgorithm = &v
+        return s
+}
+
+// SetSSECustomerKey sets the SSECustomerKey field's value.
+func (s *HeadObjectInput) SetSSECustomerKey(v string) *HeadObjectInput {
+        s.SSECustomerKey = &v
+        return s
+}
+
+// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.
+func (s *HeadObjectInput) SetSSECustomerKeyMD5(v string) *HeadObjectInput {
+        s.SSECustomerKeyMD5 = &v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *HeadObjectInput) SetVersionId(v string) *HeadObjectInput {
+        s.VersionId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/HeadObjectOutput
+type HeadObjectOutput struct {
+        _ struct{} `type:"structure"`
+
+        AcceptRanges *string `location:"header" locationName:"accept-ranges" type:"string"`
+
+        // Specifies caching behavior along the request/reply chain.
+        CacheControl *string `location:"header" locationName:"Cache-Control" type:"string"`
+
+        // Specifies presentational information for the object.
+        ContentDisposition *string `location:"header" locationName:"Content-Disposition" type:"string"`
+
+        // Specifies what content encodings have been applied to the object and thus
+        // what decoding mechanisms must be applied to obtain the media-type referenced
+        // by the Content-Type header field.
+        ContentEncoding *string `location:"header" locationName:"Content-Encoding" type:"string"`
+
+        // The language the content is in.
+        ContentLanguage *string `location:"header" locationName:"Content-Language" type:"string"`
+
+        // Size of the body in bytes.
+        ContentLength *int64 `location:"header" locationName:"Content-Length" type:"long"`
+
+        // A standard MIME type describing the format of the object data.
+        ContentType *string `location:"header" locationName:"Content-Type" type:"string"`
+
+        // Specifies whether the object retrieved was (true) or was not (false) a Delete
+        // Marker. If false, this response header does not appear in the response.
+        DeleteMarker *bool `location:"header" locationName:"x-amz-delete-marker" type:"boolean"`
+
+        // An ETag is an opaque identifier assigned by a web server to a specific version
+        // of a resource found at a URL
+        ETag *string `location:"header" locationName:"ETag" type:"string"`
+
+        // If the object expiration is configured (see PUT Bucket lifecycle), the response
+        // includes this header. It includes the expiry-date and rule-id key value pairs
+        // providing object expiration information. The value of the rule-id is URL
+        // encoded.
+        Expiration *string `location:"header" locationName:"x-amz-expiration" type:"string"`
+
+        // The date and time at which the object is no longer cacheable.
+        Expires *string `location:"header" locationName:"Expires" type:"string"`
+
+        // Last modified date of the object
+        LastModified *time.Time `location:"header" locationName:"Last-Modified" type:"timestamp" timestampFormat:"rfc822"`
+
+        // A map of metadata to store with the object in S3.
+        Metadata map[string]*string `location:"headers" locationName:"x-amz-meta-" type:"map"`
+
+        // This is set to the number of metadata entries not returned in x-amz-meta
+        // headers. This can happen if you create metadata using an API like SOAP that
+        // supports more flexible metadata than the REST API. For example, using SOAP,
+        // you can create metadata whose values are not legal HTTP headers.
+        MissingMeta *int64 `location:"header" locationName:"x-amz-missing-meta" type:"integer"`
+
+        // The count of parts this object has.
+        PartsCount *int64 `location:"header" locationName:"x-amz-mp-parts-count" type:"integer"`
+
+        ReplicationStatus *string `location:"header" locationName:"x-amz-replication-status" type:"string" enum:"ReplicationStatus"`
+
+        // If present, indicates that the requester was successfully charged for the
+        // request.
+        RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`
+
+        // Provides information about object restoration operation and expiration time
+        // of the restored object copy.
+        Restore *string `location:"header" locationName:"x-amz-restore" type:"string"`
+
+        // If server-side encryption with a customer-provided encryption key was requested,
+        // the response will include this header confirming the encryption algorithm
+        // used.
+        SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`
+
+        // If server-side encryption with a customer-provided encryption key was requested,
+        // the response will include this header to provide round trip message integrity
+        // verification of the customer-provided encryption key.
+        SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`
+
+        // If present, specifies the ID of the AWS Key Management Service (KMS) master
+        // encryption key that was used for the object.
+        SSEKMSKeyId *string `location:"header" locationName:"x-amz-server-side-encryption-aws-kms-key-id" type:"string"`
+
+        // The Server-side encryption algorithm used when storing this object in S3
+        // (e.g., AES256, aws:kms).
+        ServerSideEncryption *string `location:"header" locationName:"x-amz-server-side-encryption" type:"string" enum:"ServerSideEncryption"`
+
+        StorageClass *string `location:"header" locationName:"x-amz-storage-class" type:"string" enum:"StorageClass"`
+
+        // Version of the object.
+        VersionId *string `location:"header" locationName:"x-amz-version-id" type:"string"`
+
+        // If the bucket is configured as a website, redirects requests for this object
+        // to another object in the same bucket or to an external URL. Amazon S3 stores
+        // the value of this header in the object metadata.
+        WebsiteRedirectLocation *string `location:"header" locationName:"x-amz-website-redirect-location" type:"string"`
+}
+
+// String returns the string representation
+func (s HeadObjectOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s HeadObjectOutput) GoString() string {
+        return s.String()
+}
+
+// SetAcceptRanges sets the AcceptRanges field's value.
+func (s *HeadObjectOutput) SetAcceptRanges(v string) *HeadObjectOutput {
+        s.AcceptRanges = &v
+        return s
+}
+
+// SetCacheControl sets the CacheControl field's value.
+func (s *HeadObjectOutput) SetCacheControl(v string) *HeadObjectOutput {
+        s.CacheControl = &v
+        return s
+}
+
+// SetContentDisposition sets the ContentDisposition field's value.
+func (s *HeadObjectOutput) SetContentDisposition(v string) *HeadObjectOutput {
+        s.ContentDisposition = &v
+        return s
+}
+
+// SetContentEncoding sets the ContentEncoding field's value.
+func (s *HeadObjectOutput) SetContentEncoding(v string) *HeadObjectOutput {
+        s.ContentEncoding = &v
+        return s
+}
+
+// SetContentLanguage sets the ContentLanguage field's value.
+func (s *HeadObjectOutput) SetContentLanguage(v string) *HeadObjectOutput {
+        s.ContentLanguage = &v
+        return s
+}
+
+// SetContentLength sets the ContentLength field's value.
+func (s *HeadObjectOutput) SetContentLength(v int64) *HeadObjectOutput {
+        s.ContentLength = &v
+        return s
+}
+
+// SetContentType sets the ContentType field's value.
+func (s *HeadObjectOutput) SetContentType(v string) *HeadObjectOutput {
+        s.ContentType = &v
+        return s
+}
+
+// SetDeleteMarker sets the DeleteMarker field's value.
+func (s *HeadObjectOutput) SetDeleteMarker(v bool) *HeadObjectOutput {
+        s.DeleteMarker = &v
+        return s
+}
+
+// SetETag sets the ETag field's value.
+func (s *HeadObjectOutput) SetETag(v string) *HeadObjectOutput {
+        s.ETag = &v
+        return s
+}
+
+// SetExpiration sets the Expiration field's value.
+func (s *HeadObjectOutput) SetExpiration(v string) *HeadObjectOutput {
+        s.Expiration = &v
+        return s
+}
+
+// SetExpires sets the Expires field's value.
+func (s *HeadObjectOutput) SetExpires(v string) *HeadObjectOutput {
+        s.Expires = &v
+        return s
+}
+
+// SetLastModified sets the LastModified field's value.
+func (s *HeadObjectOutput) SetLastModified(v time.Time) *HeadObjectOutput {
+        s.LastModified = &v
+        return s
+}
+
+// SetMetadata sets the Metadata field's value.
+func (s *HeadObjectOutput) SetMetadata(v map[string]*string) *HeadObjectOutput {
+        s.Metadata = v
+        return s
+}
+
+// SetMissingMeta sets the MissingMeta field's value.
+func (s *HeadObjectOutput) SetMissingMeta(v int64) *HeadObjectOutput {
+        s.MissingMeta = &v
+        return s
+}
+
+// SetPartsCount sets the PartsCount field's value.
+func (s *HeadObjectOutput) SetPartsCount(v int64) *HeadObjectOutput {
+        s.PartsCount = &v
+        return s
+}
+
+// SetReplicationStatus sets the ReplicationStatus field's value.
+func (s *HeadObjectOutput) SetReplicationStatus(v string) *HeadObjectOutput {
+        s.ReplicationStatus = &v
+        return s
+}
+
+// SetRequestCharged sets the RequestCharged field's value.
+func (s *HeadObjectOutput) SetRequestCharged(v string) *HeadObjectOutput {
+        s.RequestCharged = &v
+        return s
+}
+
+// SetRestore sets the Restore field's value.
+func (s *HeadObjectOutput) SetRestore(v string) *HeadObjectOutput {
+        s.Restore = &v
+        return s
+}
+
+// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.
+func (s *HeadObjectOutput) SetSSECustomerAlgorithm(v string) *HeadObjectOutput {
+        s.SSECustomerAlgorithm = &v
+        return s
+}
+
+// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.
+func (s *HeadObjectOutput) SetSSECustomerKeyMD5(v string) *HeadObjectOutput {
+        s.SSECustomerKeyMD5 = &v
+        return s
+}
+
+// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.
+func (s *HeadObjectOutput) SetSSEKMSKeyId(v string) *HeadObjectOutput {
+        s.SSEKMSKeyId = &v
+        return s
+}
+
+// SetServerSideEncryption sets the ServerSideEncryption field's value.
+func (s *HeadObjectOutput) SetServerSideEncryption(v string) *HeadObjectOutput {
+        s.ServerSideEncryption = &v
+        return s
+}
+
+// SetStorageClass sets the StorageClass field's value.
+func (s *HeadObjectOutput) SetStorageClass(v string) *HeadObjectOutput {
+        s.StorageClass = &v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *HeadObjectOutput) SetVersionId(v string) *HeadObjectOutput {
+        s.VersionId = &v
+        return s
+}
+
+// SetWebsiteRedirectLocation sets the WebsiteRedirectLocation field's value.
+func (s *HeadObjectOutput) SetWebsiteRedirectLocation(v string) *HeadObjectOutput {
+        s.WebsiteRedirectLocation = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/IndexDocument
+type IndexDocument struct {
+        _ struct{} `type:"structure"`
+
+        // A suffix that is appended to a request that is for a directory on the website
+        // endpoint (e.g. if the suffix is index.html and you make a request to samplebucket/images/
+        // the data that is returned will be for the object with the key name images/index.html)
+        // The suffix must not be empty and must not include a slash character.
+        //
+        // Suffix is a required field
+        Suffix *string `type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s IndexDocument) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s IndexDocument) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *IndexDocument) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "IndexDocument"}
+        if s.Suffix == nil {
+                invalidParams.Add(request.NewErrParamRequired("Suffix"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetSuffix sets the Suffix field's value.
+func (s *IndexDocument) SetSuffix(v string) *IndexDocument {
+        s.Suffix = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Initiator
+type Initiator struct {
+        _ struct{} `type:"structure"`
+
+        // Name of the Principal.
+        DisplayName *string `type:"string"`
+
+        // If the principal is an AWS account, it provides the Canonical User ID. If
+        // the principal is an IAM User, it provides a user ARN value.
+        ID *string `type:"string"`
+}
+
+// String returns the string representation
+func (s Initiator) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Initiator) GoString() string {
+        return s.String()
+}
+
+// SetDisplayName sets the DisplayName field's value.
+func (s *Initiator) SetDisplayName(v string) *Initiator {
+        s.DisplayName = &v
+        return s
+}
+
+// SetID sets the ID field's value.
+func (s *Initiator) SetID(v string) *Initiator {
+        s.ID = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/InventoryConfiguration
+type InventoryConfiguration struct {
+        _ struct{} `type:"structure"`
+
+        // Contains information about where to publish the inventory results.
+        //
+        // Destination is a required field
+        Destination *InventoryDestination `type:"structure" required:"true"`
+
+        // Specifies an inventory filter. The inventory only includes objects that meet
+        // the filter's criteria.
+        Filter *InventoryFilter `type:"structure"`
+
+        // The ID used to identify the inventory configuration.
+        //
+        // Id is a required field
+        Id *string `type:"string" required:"true"`
+
+        // Specifies which object version(s) to included in the inventory results.
+        //
+        // IncludedObjectVersions is a required field
+        IncludedObjectVersions *string `type:"string" required:"true" enum:"InventoryIncludedObjectVersions"`
+
+        // Specifies whether the inventory is enabled or disabled.
+        //
+        // IsEnabled is a required field
+        IsEnabled *bool `type:"boolean" required:"true"`
+
+        // Contains the optional fields that are included in the inventory results.
+        OptionalFields []*string `locationNameList:"Field" type:"list"`
+
+        // Specifies the schedule for generating inventory results.
+        //
+        // Schedule is a required field
+        Schedule *InventorySchedule `type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s InventoryConfiguration) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InventoryConfiguration) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *InventoryConfiguration) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "InventoryConfiguration"}
+        if s.Destination == nil {
+                invalidParams.Add(request.NewErrParamRequired("Destination"))
+        }
+        if s.Id == nil {
+                invalidParams.Add(request.NewErrParamRequired("Id"))
+        }
+        if s.IncludedObjectVersions == nil {
+                invalidParams.Add(request.NewErrParamRequired("IncludedObjectVersions"))
+        }
+        if s.IsEnabled == nil {
+                invalidParams.Add(request.NewErrParamRequired("IsEnabled"))
+        }
+        if s.Schedule == nil {
+                invalidParams.Add(request.NewErrParamRequired("Schedule"))
+        }
+        if s.Destination != nil {
+                if err := s.Destination.Validate(); err != nil {
+                        invalidParams.AddNested("Destination", err.(request.ErrInvalidParams))
+                }
+        }
+        if s.Filter != nil {
+                if err := s.Filter.Validate(); err != nil {
+                        invalidParams.AddNested("Filter", err.(request.ErrInvalidParams))
+                }
+        }
+        if s.Schedule != nil {
+                if err := s.Schedule.Validate(); err != nil {
+                        invalidParams.AddNested("Schedule", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetDestination sets the Destination field's value.
+func (s *InventoryConfiguration) SetDestination(v *InventoryDestination) *InventoryConfiguration {
+        s.Destination = v
+        return s
+}
+
+// SetFilter sets the Filter field's value.
+func (s *InventoryConfiguration) SetFilter(v *InventoryFilter) *InventoryConfiguration {
+        s.Filter = v
+        return s
+}
+
+// SetId sets the Id field's value.
+func (s *InventoryConfiguration) SetId(v string) *InventoryConfiguration {
+        s.Id = &v
+        return s
+}
+
+// SetIncludedObjectVersions sets the IncludedObjectVersions field's value.
+func (s *InventoryConfiguration) SetIncludedObjectVersions(v string) *InventoryConfiguration {
+        s.IncludedObjectVersions = &v
+        return s
+}
+
+// SetIsEnabled sets the IsEnabled field's value.
+func (s *InventoryConfiguration) SetIsEnabled(v bool) *InventoryConfiguration {
+        s.IsEnabled = &v
+        return s
+}
+
+// SetOptionalFields sets the OptionalFields field's value.
+func (s *InventoryConfiguration) SetOptionalFields(v []*string) *InventoryConfiguration {
+        s.OptionalFields = v
+        return s
+}
+
+// SetSchedule sets the Schedule field's value.
+func (s *InventoryConfiguration) SetSchedule(v *InventorySchedule) *InventoryConfiguration {
+        s.Schedule = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/InventoryDestination
+type InventoryDestination struct {
+        _ struct{} `type:"structure"`
+
+        // Contains the bucket name, file format, bucket owner (optional), and prefix
+        // (optional) where inventory results are published.
+        //
+        // S3BucketDestination is a required field
+        S3BucketDestination *InventoryS3BucketDestination `type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s InventoryDestination) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InventoryDestination) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *InventoryDestination) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "InventoryDestination"}
+        if s.S3BucketDestination == nil {
+                invalidParams.Add(request.NewErrParamRequired("S3BucketDestination"))
+        }
+        if s.S3BucketDestination != nil {
+                if err := s.S3BucketDestination.Validate(); err != nil {
+                        invalidParams.AddNested("S3BucketDestination", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetS3BucketDestination sets the S3BucketDestination field's value.
+func (s *InventoryDestination) SetS3BucketDestination(v *InventoryS3BucketDestination) *InventoryDestination {
+        s.S3BucketDestination = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/InventoryFilter
+type InventoryFilter struct {
+        _ struct{} `type:"structure"`
+
+        // The prefix that an object must have to be included in the inventory results.
+        //
+        // Prefix is a required field
+        Prefix *string `type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s InventoryFilter) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InventoryFilter) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *InventoryFilter) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "InventoryFilter"}
+        if s.Prefix == nil {
+                invalidParams.Add(request.NewErrParamRequired("Prefix"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *InventoryFilter) SetPrefix(v string) *InventoryFilter {
+        s.Prefix = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/InventoryS3BucketDestination
+type InventoryS3BucketDestination struct {
+        _ struct{} `type:"structure"`
+
+        // The ID of the account that owns the destination bucket.
+        AccountId *string `type:"string"`
+
+        // The Amazon resource name (ARN) of the bucket where inventory results will
+        // be published.
+        //
+        // Bucket is a required field
+        Bucket *string `type:"string" required:"true"`
+
+        // Specifies the output format of the inventory results.
+        //
+        // Format is a required field
+        Format *string `type:"string" required:"true" enum:"InventoryFormat"`
+
+        // The prefix that is prepended to all inventory results.
+        Prefix *string `type:"string"`
+}
+
+// String returns the string representation
+func (s InventoryS3BucketDestination) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InventoryS3BucketDestination) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *InventoryS3BucketDestination) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "InventoryS3BucketDestination"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Format == nil {
+                invalidParams.Add(request.NewErrParamRequired("Format"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetAccountId sets the AccountId field's value.
+func (s *InventoryS3BucketDestination) SetAccountId(v string) *InventoryS3BucketDestination {
+        s.AccountId = &v
+        return s
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *InventoryS3BucketDestination) SetBucket(v string) *InventoryS3BucketDestination {
+        s.Bucket = &v
+        return s
+}
+
+// SetFormat sets the Format field's value.
+func (s *InventoryS3BucketDestination) SetFormat(v string) *InventoryS3BucketDestination {
+        s.Format = &v
+        return s
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *InventoryS3BucketDestination) SetPrefix(v string) *InventoryS3BucketDestination {
+        s.Prefix = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/InventorySchedule
+type InventorySchedule struct {
+        _ struct{} `type:"structure"`
+
+        // Specifies how frequently inventory results are produced.
+        //
+        // Frequency is a required field
+        Frequency *string `type:"string" required:"true" enum:"InventoryFrequency"`
+}
+
+// String returns the string representation
+func (s InventorySchedule) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InventorySchedule) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *InventorySchedule) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "InventorySchedule"}
+        if s.Frequency == nil {
+                invalidParams.Add(request.NewErrParamRequired("Frequency"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetFrequency sets the Frequency field's value.
+func (s *InventorySchedule) SetFrequency(v string) *InventorySchedule {
+        s.Frequency = &v
+        return s
+}
+
+// Container for object key name prefix and suffix filtering rules.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/S3KeyFilter
+type KeyFilter struct {
+        _ struct{} `type:"structure"`
+
+        // A list of containers for key value pair that defines the criteria for the
+        // filter rule.
+        FilterRules []*FilterRule `locationName:"FilterRule" type:"list" flattened:"true"`
+}
+
+// String returns the string representation
+func (s KeyFilter) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s KeyFilter) GoString() string {
+        return s.String()
+}
+
+// SetFilterRules sets the FilterRules field's value.
+func (s *KeyFilter) SetFilterRules(v []*FilterRule) *KeyFilter {
+        s.FilterRules = v
+        return s
+}
+
+// Container for specifying the AWS Lambda notification configuration.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/LambdaFunctionConfiguration
+type LambdaFunctionConfiguration struct {
+        _ struct{} `type:"structure"`
+
+        // Events is a required field
+        Events []*string `locationName:"Event" type:"list" flattened:"true" required:"true"`
+
+        // Container for object key name filtering rules. For information about key
+        // name filtering, go to Configuring Event Notifications (http://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html)
+        Filter *NotificationConfigurationFilter `type:"structure"`
+
+        // Optional unique identifier for configurations in a notification configuration.
+        // If you don't provide one, Amazon S3 will assign an ID.
+        Id *string `type:"string"`
+
+        // Lambda cloud function ARN that Amazon S3 can invoke when it detects events
+        // of the specified type.
+        //
+        // LambdaFunctionArn is a required field
+        LambdaFunctionArn *string `locationName:"CloudFunction" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s LambdaFunctionConfiguration) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s LambdaFunctionConfiguration) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *LambdaFunctionConfiguration) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "LambdaFunctionConfiguration"}
+        if s.Events == nil {
+                invalidParams.Add(request.NewErrParamRequired("Events"))
+        }
+        if s.LambdaFunctionArn == nil {
+                invalidParams.Add(request.NewErrParamRequired("LambdaFunctionArn"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetEvents sets the Events field's value.
+func (s *LambdaFunctionConfiguration) SetEvents(v []*string) *LambdaFunctionConfiguration {
+        s.Events = v
+        return s
+}
+
+// SetFilter sets the Filter field's value.
+func (s *LambdaFunctionConfiguration) SetFilter(v *NotificationConfigurationFilter) *LambdaFunctionConfiguration {
+        s.Filter = v
+        return s
+}
+
+// SetId sets the Id field's value.
+func (s *LambdaFunctionConfiguration) SetId(v string) *LambdaFunctionConfiguration {
+        s.Id = &v
+        return s
+}
+
+// SetLambdaFunctionArn sets the LambdaFunctionArn field's value.
+func (s *LambdaFunctionConfiguration) SetLambdaFunctionArn(v string) *LambdaFunctionConfiguration {
+        s.LambdaFunctionArn = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/LifecycleConfiguration
+type LifecycleConfiguration struct {
+        _ struct{} `type:"structure"`
+
+        // Rules is a required field
+        Rules []*Rule `locationName:"Rule" type:"list" flattened:"true" required:"true"`
+}
+
+// String returns the string representation
+func (s LifecycleConfiguration) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s LifecycleConfiguration) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *LifecycleConfiguration) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "LifecycleConfiguration"}
+        if s.Rules == nil {
+                invalidParams.Add(request.NewErrParamRequired("Rules"))
+        }
+        if s.Rules != nil {
+                for i, v := range s.Rules {
+                        if v == nil {
+                                continue
+                        }
+                        if err := v.Validate(); err != nil {
+                                invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Rules", i), err.(request.ErrInvalidParams))
+                        }
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetRules sets the Rules field's value.
+func (s *LifecycleConfiguration) SetRules(v []*Rule) *LifecycleConfiguration {
+        s.Rules = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/LifecycleExpiration
+type LifecycleExpiration struct {
+        _ struct{} `type:"structure"`
+
+        // Indicates at what date the object is to be moved or deleted. Should be in
+        // GMT ISO 8601 Format.
+        Date *time.Time `type:"timestamp" timestampFormat:"iso8601"`
+
+        // Indicates the lifetime, in days, of the objects that are subject to the rule.
+        // The value must be a non-zero positive integer.
+        Days *int64 `type:"integer"`
+
+        // Indicates whether Amazon S3 will remove a delete marker with no noncurrent
+        // versions. If set to true, the delete marker will be expired; if set to false
+        // the policy takes no action. This cannot be specified with Days or Date in
+        // a Lifecycle Expiration Policy.
+        ExpiredObjectDeleteMarker *bool `type:"boolean"`
+}
+
+// String returns the string representation
+func (s LifecycleExpiration) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s LifecycleExpiration) GoString() string {
+        return s.String()
+}
+
+// SetDate sets the Date field's value.
+func (s *LifecycleExpiration) SetDate(v time.Time) *LifecycleExpiration {
+        s.Date = &v
+        return s
+}
+
+// SetDays sets the Days field's value.
+func (s *LifecycleExpiration) SetDays(v int64) *LifecycleExpiration {
+        s.Days = &v
+        return s
+}
+
+// SetExpiredObjectDeleteMarker sets the ExpiredObjectDeleteMarker field's value.
+func (s *LifecycleExpiration) SetExpiredObjectDeleteMarker(v bool) *LifecycleExpiration {
+        s.ExpiredObjectDeleteMarker = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/LifecycleRule
+type LifecycleRule struct {
+        _ struct{} `type:"structure"`
+
+        // Specifies the days since the initiation of an Incomplete Multipart Upload
+        // that Lifecycle will wait before permanently removing all parts of the upload.
+        AbortIncompleteMultipartUpload *AbortIncompleteMultipartUpload `type:"structure"`
+
+        Expiration *LifecycleExpiration `type:"structure"`
+
+        // The Filter is used to identify objects that a Lifecycle Rule applies to.
+        // A Filter must have exactly one of Prefix, Tag, or And specified.
+        Filter *LifecycleRuleFilter `type:"structure"`
+
+        // Unique identifier for the rule. The value cannot be longer than 255 characters.
+        ID *string `type:"string"`
+
+        // Specifies when noncurrent object versions expire. Upon expiration, Amazon
+        // S3 permanently deletes the noncurrent object versions. You set this lifecycle
+        // configuration action on a bucket that has versioning enabled (or suspended)
+        // to request that Amazon S3 delete noncurrent object versions at a specific
+        // period in the object's lifetime.
+        NoncurrentVersionExpiration *NoncurrentVersionExpiration `type:"structure"`
+
+        NoncurrentVersionTransitions []*NoncurrentVersionTransition `locationName:"NoncurrentVersionTransition" type:"list" flattened:"true"`
+
+        // Prefix identifying one or more objects to which the rule applies. This is
+        // deprecated; use Filter instead.
+        Prefix *string `deprecated:"true" type:"string"`
+
+        // If 'Enabled', the rule is currently being applied. If 'Disabled', the rule
+        // is not currently being applied.
+        //
+        // Status is a required field
+        Status *string `type:"string" required:"true" enum:"ExpirationStatus"`
+
+        Transitions []*Transition `locationName:"Transition" type:"list" flattened:"true"`
+}
+
+// String returns the string representation
+func (s LifecycleRule) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s LifecycleRule) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *LifecycleRule) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "LifecycleRule"}
+        if s.Status == nil {
+                invalidParams.Add(request.NewErrParamRequired("Status"))
+        }
+        if s.Filter != nil {
+                if err := s.Filter.Validate(); err != nil {
+                        invalidParams.AddNested("Filter", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetAbortIncompleteMultipartUpload sets the AbortIncompleteMultipartUpload field's value.
+func (s *LifecycleRule) SetAbortIncompleteMultipartUpload(v *AbortIncompleteMultipartUpload) *LifecycleRule {
+        s.AbortIncompleteMultipartUpload = v
+        return s
+}
+
+// SetExpiration sets the Expiration field's value.
+func (s *LifecycleRule) SetExpiration(v *LifecycleExpiration) *LifecycleRule {
+        s.Expiration = v
+        return s
+}
+
+// SetFilter sets the Filter field's value.
+func (s *LifecycleRule) SetFilter(v *LifecycleRuleFilter) *LifecycleRule {
+        s.Filter = v
+        return s
+}
+
+// SetID sets the ID field's value.
+func (s *LifecycleRule) SetID(v string) *LifecycleRule {
+        s.ID = &v
+        return s
+}
+
+// SetNoncurrentVersionExpiration sets the NoncurrentVersionExpiration field's value.
+func (s *LifecycleRule) SetNoncurrentVersionExpiration(v *NoncurrentVersionExpiration) *LifecycleRule {
+        s.NoncurrentVersionExpiration = v
+        return s
+}
+
+// SetNoncurrentVersionTransitions sets the NoncurrentVersionTransitions field's value.
+func (s *LifecycleRule) SetNoncurrentVersionTransitions(v []*NoncurrentVersionTransition) *LifecycleRule {
+        s.NoncurrentVersionTransitions = v
+        return s
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *LifecycleRule) SetPrefix(v string) *LifecycleRule {
+        s.Prefix = &v
+        return s
+}
+
+// SetStatus sets the Status field's value.
+func (s *LifecycleRule) SetStatus(v string) *LifecycleRule {
+        s.Status = &v
+        return s
+}
+
+// SetTransitions sets the Transitions field's value.
+func (s *LifecycleRule) SetTransitions(v []*Transition) *LifecycleRule {
+        s.Transitions = v
+        return s
+}
+
+// This is used in a Lifecycle Rule Filter to apply a logical AND to two or
+// more predicates. The Lifecycle Rule will apply to any object matching all
+// of the predicates configured inside the And operator.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/LifecycleRuleAndOperator
+type LifecycleRuleAndOperator struct {
+        _ struct{} `type:"structure"`
+
+        Prefix *string `type:"string"`
+
+        // All of these tags must exist in the object's tag set in order for the rule
+        // to apply.
+        Tags []*Tag `locationName:"Tag" locationNameList:"Tag" type:"list" flattened:"true"`
+}
+
+// String returns the string representation
+func (s LifecycleRuleAndOperator) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s LifecycleRuleAndOperator) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *LifecycleRuleAndOperator) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "LifecycleRuleAndOperator"}
+        if s.Tags != nil {
+                for i, v := range s.Tags {
+                        if v == nil {
+                                continue
+                        }
+                        if err := v.Validate(); err != nil {
+                                invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams))
+                        }
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *LifecycleRuleAndOperator) SetPrefix(v string) *LifecycleRuleAndOperator {
+        s.Prefix = &v
+        return s
+}
+
+// SetTags sets the Tags field's value.
+func (s *LifecycleRuleAndOperator) SetTags(v []*Tag) *LifecycleRuleAndOperator {
+        s.Tags = v
+        return s
+}
+
+// The Filter is used to identify objects that a Lifecycle Rule applies to.
+// A Filter must have exactly one of Prefix, Tag, or And specified.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/LifecycleRuleFilter
+type LifecycleRuleFilter struct {
+        _ struct{} `type:"structure"`
+
+        // This is used in a Lifecycle Rule Filter to apply a logical AND to two or
+        // more predicates. The Lifecycle Rule will apply to any object matching all
+        // of the predicates configured inside the And operator.
+        And *LifecycleRuleAndOperator `type:"structure"`
+
+        // Prefix identifying one or more objects to which the rule applies.
+        Prefix *string `type:"string"`
+
+        // This tag must exist in the object's tag set in order for the rule to apply.
+        Tag *Tag `type:"structure"`
+}
+
+// String returns the string representation
+func (s LifecycleRuleFilter) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s LifecycleRuleFilter) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *LifecycleRuleFilter) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "LifecycleRuleFilter"}
+        if s.And != nil {
+                if err := s.And.Validate(); err != nil {
+                        invalidParams.AddNested("And", err.(request.ErrInvalidParams))
+                }
+        }
+        if s.Tag != nil {
+                if err := s.Tag.Validate(); err != nil {
+                        invalidParams.AddNested("Tag", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetAnd sets the And field's value.
+func (s *LifecycleRuleFilter) SetAnd(v *LifecycleRuleAndOperator) *LifecycleRuleFilter {
+        s.And = v
+        return s
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *LifecycleRuleFilter) SetPrefix(v string) *LifecycleRuleFilter {
+        s.Prefix = &v
+        return s
+}
+
+// SetTag sets the Tag field's value.
+func (s *LifecycleRuleFilter) SetTag(v *Tag) *LifecycleRuleFilter {
+        s.Tag = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBucketAnalyticsConfigurationsRequest
+type ListBucketAnalyticsConfigurationsInput struct {
+        _ struct{} `type:"structure"`
+
+        // The name of the bucket from which analytics configurations are retrieved.
+        //
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // The ContinuationToken that represents a placeholder from where this request
+        // should begin.
+        ContinuationToken *string `location:"querystring" locationName:"continuation-token" type:"string"`
+}
+
+// String returns the string representation
+func (s ListBucketAnalyticsConfigurationsInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListBucketAnalyticsConfigurationsInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListBucketAnalyticsConfigurationsInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "ListBucketAnalyticsConfigurationsInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *ListBucketAnalyticsConfigurationsInput) SetBucket(v string) *ListBucketAnalyticsConfigurationsInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetContinuationToken sets the ContinuationToken field's value.
+func (s *ListBucketAnalyticsConfigurationsInput) SetContinuationToken(v string) *ListBucketAnalyticsConfigurationsInput {
+        s.ContinuationToken = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBucketAnalyticsConfigurationsOutput
+type ListBucketAnalyticsConfigurationsOutput struct {
+        _ struct{} `type:"structure"`
+
+        // The list of analytics configurations for a bucket.
+        AnalyticsConfigurationList []*AnalyticsConfiguration `locationName:"AnalyticsConfiguration" type:"list" flattened:"true"`
+
+        // The ContinuationToken that represents where this request began.
+        ContinuationToken *string `type:"string"`
+
+        // Indicates whether the returned list of analytics configurations is complete.
+        // A value of true indicates that the list is not complete and the NextContinuationToken
+        // will be provided for a subsequent request.
+        IsTruncated *bool `type:"boolean"`
+
+        // NextContinuationToken is sent when isTruncated is true, which indicates that
+        // there are more analytics configurations to list. The next request must include
+        // this NextContinuationToken. The token is obfuscated and is not a usable value.
+        NextContinuationToken *string `type:"string"`
+}
+
+// String returns the string representation
+func (s ListBucketAnalyticsConfigurationsOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListBucketAnalyticsConfigurationsOutput) GoString() string {
+        return s.String()
+}
+
+// SetAnalyticsConfigurationList sets the AnalyticsConfigurationList field's value.
+func (s *ListBucketAnalyticsConfigurationsOutput) SetAnalyticsConfigurationList(v []*AnalyticsConfiguration) *ListBucketAnalyticsConfigurationsOutput {
+        s.AnalyticsConfigurationList = v
+        return s
+}
+
+// SetContinuationToken sets the ContinuationToken field's value.
+func (s *ListBucketAnalyticsConfigurationsOutput) SetContinuationToken(v string) *ListBucketAnalyticsConfigurationsOutput {
+        s.ContinuationToken = &v
+        return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListBucketAnalyticsConfigurationsOutput) SetIsTruncated(v bool) *ListBucketAnalyticsConfigurationsOutput {
+        s.IsTruncated = &v
+        return s
+}
+
+// SetNextContinuationToken sets the NextContinuationToken field's value.
+func (s *ListBucketAnalyticsConfigurationsOutput) SetNextContinuationToken(v string) *ListBucketAnalyticsConfigurationsOutput {
+        s.NextContinuationToken = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBucketInventoryConfigurationsRequest
+type ListBucketInventoryConfigurationsInput struct {
+        _ struct{} `type:"structure"`
+
+        // The name of the bucket containing the inventory configurations to retrieve.
+        //
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // The marker used to continue an inventory configuration listing that has been
+        // truncated. Use the NextContinuationToken from a previously truncated list
+        // response to continue the listing. The continuation token is an opaque value
+        // that Amazon S3 understands.
+        ContinuationToken *string `location:"querystring" locationName:"continuation-token" type:"string"`
+}
+
+// String returns the string representation
+func (s ListBucketInventoryConfigurationsInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListBucketInventoryConfigurationsInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListBucketInventoryConfigurationsInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "ListBucketInventoryConfigurationsInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *ListBucketInventoryConfigurationsInput) SetBucket(v string) *ListBucketInventoryConfigurationsInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetContinuationToken sets the ContinuationToken field's value.
+func (s *ListBucketInventoryConfigurationsInput) SetContinuationToken(v string) *ListBucketInventoryConfigurationsInput {
+        s.ContinuationToken = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBucketInventoryConfigurationsOutput
+type ListBucketInventoryConfigurationsOutput struct {
+        _ struct{} `type:"structure"`
+
+        // If sent in the request, the marker that is used as a starting point for this
+        // inventory configuration list response.
+        ContinuationToken *string `type:"string"`
+
+        // The list of inventory configurations for a bucket.
+        InventoryConfigurationList []*InventoryConfiguration `locationName:"InventoryConfiguration" type:"list" flattened:"true"`
+
+        // Indicates whether the returned list of inventory configurations is truncated
+        // in this response. A value of true indicates that the list is truncated.
+        IsTruncated *bool `type:"boolean"`
+
+        // The marker used to continue this inventory configuration listing. Use the
+        // NextContinuationToken from this response to continue the listing in a subsequent
+        // request. The continuation token is an opaque value that Amazon S3 understands.
+        NextContinuationToken *string `type:"string"`
+}
+
+// String returns the string representation
+func (s ListBucketInventoryConfigurationsOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListBucketInventoryConfigurationsOutput) GoString() string {
+        return s.String()
+}
+
+// SetContinuationToken sets the ContinuationToken field's value.
+func (s *ListBucketInventoryConfigurationsOutput) SetContinuationToken(v string) *ListBucketInventoryConfigurationsOutput {
+        s.ContinuationToken = &v
+        return s
+}
+
+// SetInventoryConfigurationList sets the InventoryConfigurationList field's value.
+func (s *ListBucketInventoryConfigurationsOutput) SetInventoryConfigurationList(v []*InventoryConfiguration) *ListBucketInventoryConfigurationsOutput {
+        s.InventoryConfigurationList = v
+        return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListBucketInventoryConfigurationsOutput) SetIsTruncated(v bool) *ListBucketInventoryConfigurationsOutput {
+        s.IsTruncated = &v
+        return s
+}
+
+// SetNextContinuationToken sets the NextContinuationToken field's value.
+func (s *ListBucketInventoryConfigurationsOutput) SetNextContinuationToken(v string) *ListBucketInventoryConfigurationsOutput {
+        s.NextContinuationToken = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBucketMetricsConfigurationsRequest
+type ListBucketMetricsConfigurationsInput struct {
+        _ struct{} `type:"structure"`
+
+        // The name of the bucket containing the metrics configurations to retrieve.
+        //
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // The marker that is used to continue a metrics configuration listing that
+        // has been truncated. Use the NextContinuationToken from a previously truncated
+        // list response to continue the listing. The continuation token is an opaque
+        // value that Amazon S3 understands.
+        ContinuationToken *string `location:"querystring" locationName:"continuation-token" type:"string"`
+}
+
+// String returns the string representation
+func (s ListBucketMetricsConfigurationsInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListBucketMetricsConfigurationsInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListBucketMetricsConfigurationsInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "ListBucketMetricsConfigurationsInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *ListBucketMetricsConfigurationsInput) SetBucket(v string) *ListBucketMetricsConfigurationsInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetContinuationToken sets the ContinuationToken field's value.
+func (s *ListBucketMetricsConfigurationsInput) SetContinuationToken(v string) *ListBucketMetricsConfigurationsInput {
+        s.ContinuationToken = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBucketMetricsConfigurationsOutput
+type ListBucketMetricsConfigurationsOutput struct {
+        _ struct{} `type:"structure"`
+
+        // The marker that is used as a starting point for this metrics configuration
+        // list response. This value is present if it was sent in the request.
+        ContinuationToken *string `type:"string"`
+
+        // Indicates whether the returned list of metrics configurations is complete.
+        // A value of true indicates that the list is not complete and the NextContinuationToken
+        // will be provided for a subsequent request.
+        IsTruncated *bool `type:"boolean"`
+
+        // The list of metrics configurations for a bucket.
+        MetricsConfigurationList []*MetricsConfiguration `locationName:"MetricsConfiguration" type:"list" flattened:"true"`
+
+        // The marker used to continue a metrics configuration listing that has been
+        // truncated. Use the NextContinuationToken from a previously truncated list
+        // response to continue the listing. The continuation token is an opaque value
+        // that Amazon S3 understands.
+        NextContinuationToken *string `type:"string"`
+}
+
+// String returns the string representation
+func (s ListBucketMetricsConfigurationsOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListBucketMetricsConfigurationsOutput) GoString() string {
+        return s.String()
+}
+
+// SetContinuationToken sets the ContinuationToken field's value.
+func (s *ListBucketMetricsConfigurationsOutput) SetContinuationToken(v string) *ListBucketMetricsConfigurationsOutput {
+        s.ContinuationToken = &v
+        return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListBucketMetricsConfigurationsOutput) SetIsTruncated(v bool) *ListBucketMetricsConfigurationsOutput {
+        s.IsTruncated = &v
+        return s
+}
+
+// SetMetricsConfigurationList sets the MetricsConfigurationList field's value.
+func (s *ListBucketMetricsConfigurationsOutput) SetMetricsConfigurationList(v []*MetricsConfiguration) *ListBucketMetricsConfigurationsOutput {
+        s.MetricsConfigurationList = v
+        return s
+}
+
+// SetNextContinuationToken sets the NextContinuationToken field's value.
+func (s *ListBucketMetricsConfigurationsOutput) SetNextContinuationToken(v string) *ListBucketMetricsConfigurationsOutput {
+        s.NextContinuationToken = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBucketsInput
+type ListBucketsInput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s ListBucketsInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListBucketsInput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBucketsOutput
+type ListBucketsOutput struct {
+        _ struct{} `type:"structure"`
+
+        Buckets []*Bucket `locationNameList:"Bucket" type:"list"`
+
+        Owner *Owner `type:"structure"`
+}
+
+// String returns the string representation
+func (s ListBucketsOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListBucketsOutput) GoString() string {
+        return s.String()
+}
+
+// SetBuckets sets the Buckets field's value.
+func (s *ListBucketsOutput) SetBuckets(v []*Bucket) *ListBucketsOutput {
+        s.Buckets = v
+        return s
+}
+
+// SetOwner sets the Owner field's value.
+func (s *ListBucketsOutput) SetOwner(v *Owner) *ListBucketsOutput {
+        s.Owner = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListMultipartUploadsRequest
+type ListMultipartUploadsInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Character you use to group keys.
+        Delimiter *string `location:"querystring" locationName:"delimiter" type:"string"`
+
+        // Requests Amazon S3 to encode the object keys in the response and specifies
+        // the encoding method to use. An object key may contain any Unicode character;
+        // however, XML 1.0 parser cannot parse some characters, such as characters
+        // with an ASCII value from 0 to 10. For characters that are not supported in
+        // XML 1.0, you can add this parameter to request that Amazon S3 encode the
+        // keys in the response.
+        EncodingType *string `location:"querystring" locationName:"encoding-type" type:"string" enum:"EncodingType"`
+
+        // Together with upload-id-marker, this parameter specifies the multipart upload
+        // after which listing should begin.
+        KeyMarker *string `location:"querystring" locationName:"key-marker" type:"string"`
+
+        // Sets the maximum number of multipart uploads, from 1 to 1,000, to return
+        // in the response body. 1,000 is the maximum number of uploads that can be
+        // returned in a response.
+        MaxUploads *int64 `location:"querystring" locationName:"max-uploads" type:"integer"`
+
+        // Lists in-progress uploads only for those keys that begin with the specified
+        // prefix.
+        Prefix *string `location:"querystring" locationName:"prefix" type:"string"`
+
+        // Together with key-marker, specifies the multipart upload after which listing
+        // should begin. If key-marker is not specified, the upload-id-marker parameter
+        // is ignored.
+        UploadIdMarker *string `location:"querystring" locationName:"upload-id-marker" type:"string"`
+}
+
+// String returns the string representation
+func (s ListMultipartUploadsInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListMultipartUploadsInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListMultipartUploadsInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "ListMultipartUploadsInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *ListMultipartUploadsInput) SetBucket(v string) *ListMultipartUploadsInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetDelimiter sets the Delimiter field's value.
+func (s *ListMultipartUploadsInput) SetDelimiter(v string) *ListMultipartUploadsInput {
+        s.Delimiter = &v
+        return s
+}
+
+// SetEncodingType sets the EncodingType field's value.
+func (s *ListMultipartUploadsInput) SetEncodingType(v string) *ListMultipartUploadsInput {
+        s.EncodingType = &v
+        return s
+}
+
+// SetKeyMarker sets the KeyMarker field's value.
+func (s *ListMultipartUploadsInput) SetKeyMarker(v string) *ListMultipartUploadsInput {
+        s.KeyMarker = &v
+        return s
+}
+
+// SetMaxUploads sets the MaxUploads field's value.
+func (s *ListMultipartUploadsInput) SetMaxUploads(v int64) *ListMultipartUploadsInput {
+        s.MaxUploads = &v
+        return s
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *ListMultipartUploadsInput) SetPrefix(v string) *ListMultipartUploadsInput {
+        s.Prefix = &v
+        return s
+}
+
+// SetUploadIdMarker sets the UploadIdMarker field's value.
+func (s *ListMultipartUploadsInput) SetUploadIdMarker(v string) *ListMultipartUploadsInput {
+        s.UploadIdMarker = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListMultipartUploadsOutput
+type ListMultipartUploadsOutput struct {
+        _ struct{} `type:"structure"`
+
+        // Name of the bucket to which the multipart upload was initiated.
+        Bucket *string `type:"string"`
+
+        CommonPrefixes []*CommonPrefix `type:"list" flattened:"true"`
+
+        Delimiter *string `type:"string"`
+
+        // Encoding type used by Amazon S3 to encode object keys in the response.
+        EncodingType *string `type:"string" enum:"EncodingType"`
+
+        // Indicates whether the returned list of multipart uploads is truncated. A
+        // value of true indicates that the list was truncated. The list can be truncated
+        // if the number of multipart uploads exceeds the limit allowed or specified
+        // by max uploads.
+        IsTruncated *bool `type:"boolean"`
+
+        // The key at or after which the listing began.
+        KeyMarker *string `type:"string"`
+
+        // Maximum number of multipart uploads that could have been included in the
+        // response.
+        MaxUploads *int64 `type:"integer"`
+
+        // When a list is truncated, this element specifies the value that should be
+        // used for the key-marker request parameter in a subsequent request.
+        NextKeyMarker *string `type:"string"`
+
+        // When a list is truncated, this element specifies the value that should be
+        // used for the upload-id-marker request parameter in a subsequent request.
+        NextUploadIdMarker *string `type:"string"`
+
+        // When a prefix is provided in the request, this field contains the specified
+        // prefix. The result contains only keys starting with the specified prefix.
+        Prefix *string `type:"string"`
+
+        // Upload ID after which listing began.
+        UploadIdMarker *string `type:"string"`
+
+        Uploads []*MultipartUpload `locationName:"Upload" type:"list" flattened:"true"`
+}
+
+// String returns the string representation
+func (s ListMultipartUploadsOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListMultipartUploadsOutput) GoString() string {
+        return s.String()
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *ListMultipartUploadsOutput) SetBucket(v string) *ListMultipartUploadsOutput {
+        s.Bucket = &v
+        return s
+}
+
+// SetCommonPrefixes sets the CommonPrefixes field's value.
+func (s *ListMultipartUploadsOutput) SetCommonPrefixes(v []*CommonPrefix) *ListMultipartUploadsOutput {
+        s.CommonPrefixes = v
+        return s
+}
+
+// SetDelimiter sets the Delimiter field's value.
+func (s *ListMultipartUploadsOutput) SetDelimiter(v string) *ListMultipartUploadsOutput {
+        s.Delimiter = &v
+        return s
+}
+
+// SetEncodingType sets the EncodingType field's value.
+func (s *ListMultipartUploadsOutput) SetEncodingType(v string) *ListMultipartUploadsOutput {
+        s.EncodingType = &v
+        return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListMultipartUploadsOutput) SetIsTruncated(v bool) *ListMultipartUploadsOutput {
+        s.IsTruncated = &v
+        return s
+}
+
+// SetKeyMarker sets the KeyMarker field's value.
+func (s *ListMultipartUploadsOutput) SetKeyMarker(v string) *ListMultipartUploadsOutput {
+        s.KeyMarker = &v
+        return s
+}
+
+// SetMaxUploads sets the MaxUploads field's value.
+func (s *ListMultipartUploadsOutput) SetMaxUploads(v int64) *ListMultipartUploadsOutput {
+        s.MaxUploads = &v
+        return s
+}
+
+// SetNextKeyMarker sets the NextKeyMarker field's value.
+func (s *ListMultipartUploadsOutput) SetNextKeyMarker(v string) *ListMultipartUploadsOutput {
+        s.NextKeyMarker = &v
+        return s
+}
+
+// SetNextUploadIdMarker sets the NextUploadIdMarker field's value.
+func (s *ListMultipartUploadsOutput) SetNextUploadIdMarker(v string) *ListMultipartUploadsOutput {
+        s.NextUploadIdMarker = &v
+        return s
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *ListMultipartUploadsOutput) SetPrefix(v string) *ListMultipartUploadsOutput {
+        s.Prefix = &v
+        return s
+}
+
+// SetUploadIdMarker sets the UploadIdMarker field's value.
+func (s *ListMultipartUploadsOutput) SetUploadIdMarker(v string) *ListMultipartUploadsOutput {
+        s.UploadIdMarker = &v
+        return s
+}
+
+// SetUploads sets the Uploads field's value.
+func (s *ListMultipartUploadsOutput) SetUploads(v []*MultipartUpload) *ListMultipartUploadsOutput {
+        s.Uploads = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListObjectVersionsRequest
+type ListObjectVersionsInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // A delimiter is a character you use to group keys.
+        Delimiter *string `location:"querystring" locationName:"delimiter" type:"string"`
+
+        // Requests Amazon S3 to encode the object keys in the response and specifies
+        // the encoding method to use. An object key may contain any Unicode character;
+        // however, XML 1.0 parser cannot parse some characters, such as characters
+        // with an ASCII value from 0 to 10. For characters that are not supported in
+        // XML 1.0, you can add this parameter to request that Amazon S3 encode the
+        // keys in the response.
+        EncodingType *string `location:"querystring" locationName:"encoding-type" type:"string" enum:"EncodingType"`
+
+        // Specifies the key to start with when listing objects in a bucket.
+        KeyMarker *string `location:"querystring" locationName:"key-marker" type:"string"`
+
+        // Sets the maximum number of keys returned in the response. The response might
+        // contain fewer keys but will never contain more.
+        MaxKeys *int64 `location:"querystring" locationName:"max-keys" type:"integer"`
+
+        // Limits the response to keys that begin with the specified prefix.
+        Prefix *string `location:"querystring" locationName:"prefix" type:"string"`
+
+        // Specifies the object version you want to start listing from.
+        VersionIdMarker *string `location:"querystring" locationName:"version-id-marker" type:"string"`
+}
+
+// String returns the string representation
+func (s ListObjectVersionsInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListObjectVersionsInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListObjectVersionsInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "ListObjectVersionsInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *ListObjectVersionsInput) SetBucket(v string) *ListObjectVersionsInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetDelimiter sets the Delimiter field's value.
+func (s *ListObjectVersionsInput) SetDelimiter(v string) *ListObjectVersionsInput {
+        s.Delimiter = &v
+        return s
+}
+
+// SetEncodingType sets the EncodingType field's value.
+func (s *ListObjectVersionsInput) SetEncodingType(v string) *ListObjectVersionsInput {
+        s.EncodingType = &v
+        return s
+}
+
+// SetKeyMarker sets the KeyMarker field's value.
+func (s *ListObjectVersionsInput) SetKeyMarker(v string) *ListObjectVersionsInput {
+        s.KeyMarker = &v
+        return s
+}
+
+// SetMaxKeys sets the MaxKeys field's value.
+func (s *ListObjectVersionsInput) SetMaxKeys(v int64) *ListObjectVersionsInput {
+        s.MaxKeys = &v
+        return s
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *ListObjectVersionsInput) SetPrefix(v string) *ListObjectVersionsInput {
+        s.Prefix = &v
+        return s
+}
+
+// SetVersionIdMarker sets the VersionIdMarker field's value.
+func (s *ListObjectVersionsInput) SetVersionIdMarker(v string) *ListObjectVersionsInput {
+        s.VersionIdMarker = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListObjectVersionsOutput
+type ListObjectVersionsOutput struct {
+        _ struct{} `type:"structure"`
+
+        CommonPrefixes []*CommonPrefix `type:"list" flattened:"true"`
+
+        DeleteMarkers []*DeleteMarkerEntry `locationName:"DeleteMarker" type:"list" flattened:"true"`
+
+        Delimiter *string `type:"string"`
+
+        // Encoding type used by Amazon S3 to encode object keys in the response.
+        EncodingType *string `type:"string" enum:"EncodingType"`
+
+        // A flag that indicates whether or not Amazon S3 returned all of the results
+        // that satisfied the search criteria. If your results were truncated, you can
+        // make a follow-up paginated request using the NextKeyMarker and NextVersionIdMarker
+        // response parameters as a starting place in another request to return the
+        // rest of the results.
+        IsTruncated *bool `type:"boolean"`
+
+        // Marks the last Key returned in a truncated response.
+        KeyMarker *string `type:"string"`
+
+        MaxKeys *int64 `type:"integer"`
+
+        Name *string `type:"string"`
+
+        // Use this value for the key marker request parameter in a subsequent request.
+        NextKeyMarker *string `type:"string"`
+
+        // Use this value for the next version id marker parameter in a subsequent request.
+        NextVersionIdMarker *string `type:"string"`
+
+        Prefix *string `type:"string"`
+
+        VersionIdMarker *string `type:"string"`
+
+        Versions []*ObjectVersion `locationName:"Version" type:"list" flattened:"true"`
+}
+
+// String returns the string representation
+func (s ListObjectVersionsOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListObjectVersionsOutput) GoString() string {
+        return s.String()
+}
+
+// SetCommonPrefixes sets the CommonPrefixes field's value.
+func (s *ListObjectVersionsOutput) SetCommonPrefixes(v []*CommonPrefix) *ListObjectVersionsOutput {
+        s.CommonPrefixes = v
+        return s
+}
+
+// SetDeleteMarkers sets the DeleteMarkers field's value.
+func (s *ListObjectVersionsOutput) SetDeleteMarkers(v []*DeleteMarkerEntry) *ListObjectVersionsOutput {
+        s.DeleteMarkers = v
+        return s
+}
+
+// SetDelimiter sets the Delimiter field's value.
+func (s *ListObjectVersionsOutput) SetDelimiter(v string) *ListObjectVersionsOutput {
+        s.Delimiter = &v
+        return s
+}
+
+// SetEncodingType sets the EncodingType field's value.
+func (s *ListObjectVersionsOutput) SetEncodingType(v string) *ListObjectVersionsOutput {
+        s.EncodingType = &v
+        return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListObjectVersionsOutput) SetIsTruncated(v bool) *ListObjectVersionsOutput {
+        s.IsTruncated = &v
+        return s
+}
+
+// SetKeyMarker sets the KeyMarker field's value.
+func (s *ListObjectVersionsOutput) SetKeyMarker(v string) *ListObjectVersionsOutput {
+        s.KeyMarker = &v
+        return s
+}
+
+// SetMaxKeys sets the MaxKeys field's value.
+func (s *ListObjectVersionsOutput) SetMaxKeys(v int64) *ListObjectVersionsOutput {
+        s.MaxKeys = &v
+        return s
+}
+
+// SetName sets the Name field's value.
+func (s *ListObjectVersionsOutput) SetName(v string) *ListObjectVersionsOutput {
+        s.Name = &v
+        return s
+}
+
+// SetNextKeyMarker sets the NextKeyMarker field's value.
+func (s *ListObjectVersionsOutput) SetNextKeyMarker(v string) *ListObjectVersionsOutput {
+        s.NextKeyMarker = &v
+        return s
+}
+
+// SetNextVersionIdMarker sets the NextVersionIdMarker field's value.
+func (s *ListObjectVersionsOutput) SetNextVersionIdMarker(v string) *ListObjectVersionsOutput {
+        s.NextVersionIdMarker = &v
+        return s
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *ListObjectVersionsOutput) SetPrefix(v string) *ListObjectVersionsOutput {
+        s.Prefix = &v
+        return s
+}
+
+// SetVersionIdMarker sets the VersionIdMarker field's value.
+func (s *ListObjectVersionsOutput) SetVersionIdMarker(v string) *ListObjectVersionsOutput {
+        s.VersionIdMarker = &v
+        return s
+}
+
+// SetVersions sets the Versions field's value.
+func (s *ListObjectVersionsOutput) SetVersions(v []*ObjectVersion) *ListObjectVersionsOutput {
+        s.Versions = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListObjectsRequest
+type ListObjectsInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // A delimiter is a character you use to group keys.
+        Delimiter *string `location:"querystring" locationName:"delimiter" type:"string"`
+
+        // Requests Amazon S3 to encode the object keys in the response and specifies
+        // the encoding method to use. An object key may contain any Unicode character;
+        // however, XML 1.0 parser cannot parse some characters, such as characters
+        // with an ASCII value from 0 to 10. For characters that are not supported in
+        // XML 1.0, you can add this parameter to request that Amazon S3 encode the
+        // keys in the response.
+        EncodingType *string `location:"querystring" locationName:"encoding-type" type:"string" enum:"EncodingType"`
+
+        // Specifies the key to start with when listing objects in a bucket.
+        Marker *string `location:"querystring" locationName:"marker" type:"string"`
+
+        // Sets the maximum number of keys returned in the response. The response might
+        // contain fewer keys but will never contain more.
+        MaxKeys *int64 `location:"querystring" locationName:"max-keys" type:"integer"`
+
+        // Limits the response to keys that begin with the specified prefix.
+        Prefix *string `location:"querystring" locationName:"prefix" type:"string"`
+
+        // Confirms that the requester knows that she or he will be charged for the
+        // list objects request. Bucket owners need not specify this parameter in their
+        // requests.
+        RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string" enum:"RequestPayer"`
+}
+
+// String returns the string representation
+func (s ListObjectsInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListObjectsInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListObjectsInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "ListObjectsInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *ListObjectsInput) SetBucket(v string) *ListObjectsInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetDelimiter sets the Delimiter field's value.
+func (s *ListObjectsInput) SetDelimiter(v string) *ListObjectsInput {
+        s.Delimiter = &v
+        return s
+}
+
+// SetEncodingType sets the EncodingType field's value.
+func (s *ListObjectsInput) SetEncodingType(v string) *ListObjectsInput {
+        s.EncodingType = &v
+        return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListObjectsInput) SetMarker(v string) *ListObjectsInput {
+        s.Marker = &v
+        return s
+}
+
+// SetMaxKeys sets the MaxKeys field's value.
+func (s *ListObjectsInput) SetMaxKeys(v int64) *ListObjectsInput {
+        s.MaxKeys = &v
+        return s
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *ListObjectsInput) SetPrefix(v string) *ListObjectsInput {
+        s.Prefix = &v
+        return s
+}
+
+// SetRequestPayer sets the RequestPayer field's value.
+func (s *ListObjectsInput) SetRequestPayer(v string) *ListObjectsInput {
+        s.RequestPayer = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListObjectsOutput
+type ListObjectsOutput struct {
+        _ struct{} `type:"structure"`
+
+        CommonPrefixes []*CommonPrefix `type:"list" flattened:"true"`
+
+        Contents []*Object `type:"list" flattened:"true"`
+
+        Delimiter *string `type:"string"`
+
+        // Encoding type used by Amazon S3 to encode object keys in the response.
+        EncodingType *string `type:"string" enum:"EncodingType"`
+
+        // A flag that indicates whether or not Amazon S3 returned all of the results
+        // that satisfied the search criteria.
+        IsTruncated *bool `type:"boolean"`
+
+        Marker *string `type:"string"`
+
+        MaxKeys *int64 `type:"integer"`
+
+        Name *string `type:"string"`
+
+        // When response is truncated (the IsTruncated element value in the response
+        // is true), you can use the key name in this field as marker in the subsequent
+        // request to get next set of objects. Amazon S3 lists objects in alphabetical
+        // order Note: This element is returned only if you have delimiter request parameter
+        // specified. If response does not include the NextMaker and it is truncated,
+        // you can use the value of the last Key in the response as the marker in the
+        // subsequent request to get the next set of object keys.
+        NextMarker *string `type:"string"`
+
+        Prefix *string `type:"string"`
+}
+
+// String returns the string representation
+func (s ListObjectsOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListObjectsOutput) GoString() string {
+        return s.String()
+}
+
+// SetCommonPrefixes sets the CommonPrefixes field's value.
+func (s *ListObjectsOutput) SetCommonPrefixes(v []*CommonPrefix) *ListObjectsOutput {
+        s.CommonPrefixes = v
+        return s
+}
+
+// SetContents sets the Contents field's value.
+func (s *ListObjectsOutput) SetContents(v []*Object) *ListObjectsOutput {
+        s.Contents = v
+        return s
+}
+
+// SetDelimiter sets the Delimiter field's value.
+func (s *ListObjectsOutput) SetDelimiter(v string) *ListObjectsOutput {
+        s.Delimiter = &v
+        return s
+}
+
+// SetEncodingType sets the EncodingType field's value.
+func (s *ListObjectsOutput) SetEncodingType(v string) *ListObjectsOutput {
+        s.EncodingType = &v
+        return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListObjectsOutput) SetIsTruncated(v bool) *ListObjectsOutput {
+        s.IsTruncated = &v
+        return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListObjectsOutput) SetMarker(v string) *ListObjectsOutput {
+        s.Marker = &v
+        return s
+}
+
+// SetMaxKeys sets the MaxKeys field's value.
+func (s *ListObjectsOutput) SetMaxKeys(v int64) *ListObjectsOutput {
+        s.MaxKeys = &v
+        return s
+}
+
+// SetName sets the Name field's value.
+func (s *ListObjectsOutput) SetName(v string) *ListObjectsOutput {
+        s.Name = &v
+        return s
+}
+
+// SetNextMarker sets the NextMarker field's value.
+func (s *ListObjectsOutput) SetNextMarker(v string) *ListObjectsOutput {
+        s.NextMarker = &v
+        return s
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *ListObjectsOutput) SetPrefix(v string) *ListObjectsOutput {
+        s.Prefix = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListObjectsV2Request
+type ListObjectsV2Input struct {
+        _ struct{} `type:"structure"`
+
+        // Name of the bucket to list.
+        //
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // ContinuationToken indicates Amazon S3 that the list is being continued on
+        // this bucket with a token. ContinuationToken is obfuscated and is not a real
+        // key
+        ContinuationToken *string `location:"querystring" locationName:"continuation-token" type:"string"`
+
+        // A delimiter is a character you use to group keys.
+        Delimiter *string `location:"querystring" locationName:"delimiter" type:"string"`
+
+        // Encoding type used by Amazon S3 to encode object keys in the response.
+        EncodingType *string `location:"querystring" locationName:"encoding-type" type:"string" enum:"EncodingType"`
+
+        // The owner field is not present in listV2 by default, if you want to return
+        // owner field with each key in the result then set the fetch owner field to
+        // true
+        FetchOwner *bool `location:"querystring" locationName:"fetch-owner" type:"boolean"`
+
+        // Sets the maximum number of keys returned in the response. The response might
+        // contain fewer keys but will never contain more.
+        MaxKeys *int64 `location:"querystring" locationName:"max-keys" type:"integer"`
+
+        // Limits the response to keys that begin with the specified prefix.
+        Prefix *string `location:"querystring" locationName:"prefix" type:"string"`
+
+        // Confirms that the requester knows that she or he will be charged for the
+        // list objects request in V2 style. Bucket owners need not specify this parameter
+        // in their requests.
+        RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string" enum:"RequestPayer"`
+
+        // StartAfter is where you want Amazon S3 to start listing from. Amazon S3 starts
+        // listing after this specified key. StartAfter can be any key in the bucket
+        StartAfter *string `location:"querystring" locationName:"start-after" type:"string"`
+}
+
+// String returns the string representation
+func (s ListObjectsV2Input) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListObjectsV2Input) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListObjectsV2Input) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "ListObjectsV2Input"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *ListObjectsV2Input) SetBucket(v string) *ListObjectsV2Input {
+        s.Bucket = &v
+        return s
+}
+
+// SetContinuationToken sets the ContinuationToken field's value.
+func (s *ListObjectsV2Input) SetContinuationToken(v string) *ListObjectsV2Input {
+        s.ContinuationToken = &v
+        return s
+}
+
+// SetDelimiter sets the Delimiter field's value.
+func (s *ListObjectsV2Input) SetDelimiter(v string) *ListObjectsV2Input {
+        s.Delimiter = &v
+        return s
+}
+
+// SetEncodingType sets the EncodingType field's value.
+func (s *ListObjectsV2Input) SetEncodingType(v string) *ListObjectsV2Input {
+        s.EncodingType = &v
+        return s
+}
+
+// SetFetchOwner sets the FetchOwner field's value.
+func (s *ListObjectsV2Input) SetFetchOwner(v bool) *ListObjectsV2Input {
+        s.FetchOwner = &v
+        return s
+}
+
+// SetMaxKeys sets the MaxKeys field's value.
+func (s *ListObjectsV2Input) SetMaxKeys(v int64) *ListObjectsV2Input {
+        s.MaxKeys = &v
+        return s
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *ListObjectsV2Input) SetPrefix(v string) *ListObjectsV2Input {
+        s.Prefix = &v
+        return s
+}
+
+// SetRequestPayer sets the RequestPayer field's value.
+func (s *ListObjectsV2Input) SetRequestPayer(v string) *ListObjectsV2Input {
+        s.RequestPayer = &v
+        return s
+}
+
+// SetStartAfter sets the StartAfter field's value.
+func (s *ListObjectsV2Input) SetStartAfter(v string) *ListObjectsV2Input {
+        s.StartAfter = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListObjectsV2Output
+type ListObjectsV2Output struct {
+        _ struct{} `type:"structure"`
+
+        // CommonPrefixes contains all (if there are any) keys between Prefix and the
+        // next occurrence of the string specified by delimiter
+        CommonPrefixes []*CommonPrefix `type:"list" flattened:"true"`
+
+        // Metadata about each object returned.
+        Contents []*Object `type:"list" flattened:"true"`
+
+        // ContinuationToken indicates Amazon S3 that the list is being continued on
+        // this bucket with a token. ContinuationToken is obfuscated and is not a real
+        // key
+        ContinuationToken *string `type:"string"`
+
+        // A delimiter is a character you use to group keys.
+        Delimiter *string `type:"string"`
+
+        // Encoding type used by Amazon S3 to encode object keys in the response.
+        EncodingType *string `type:"string" enum:"EncodingType"`
+
+        // A flag that indicates whether or not Amazon S3 returned all of the results
+        // that satisfied the search criteria.
+        IsTruncated *bool `type:"boolean"`
+
+        // KeyCount is the number of keys returned with this request. KeyCount will
+        // always be less than equals to MaxKeys field. Say you ask for 50 keys, your
+        // result will include less than equals 50 keys
+        KeyCount *int64 `type:"integer"`
+
+        // Sets the maximum number of keys returned in the response. The response might
+        // contain fewer keys but will never contain more.
+        MaxKeys *int64 `type:"integer"`
+
+        // Name of the bucket to list.
+        Name *string `type:"string"`
+
+        // NextContinuationToken is sent when isTruncated is true which means there
+        // are more keys in the bucket that can be listed. The next list requests to
+        // Amazon S3 can be continued with this NextContinuationToken. NextContinuationToken
+        // is obfuscated and is not a real key
+        NextContinuationToken *string `type:"string"`
+
+        // Limits the response to keys that begin with the specified prefix.
+        Prefix *string `type:"string"`
+
+        // StartAfter is where you want Amazon S3 to start listing from. Amazon S3 starts
+        // listing after this specified key. StartAfter can be any key in the bucket
+        StartAfter *string `type:"string"`
+}
+
+// String returns the string representation
+func (s ListObjectsV2Output) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListObjectsV2Output) GoString() string {
+        return s.String()
+}
+
+// SetCommonPrefixes sets the CommonPrefixes field's value.
+func (s *ListObjectsV2Output) SetCommonPrefixes(v []*CommonPrefix) *ListObjectsV2Output {
+        s.CommonPrefixes = v
+        return s
+}
+
+// SetContents sets the Contents field's value.
+func (s *ListObjectsV2Output) SetContents(v []*Object) *ListObjectsV2Output {
+        s.Contents = v
+        return s
+}
+
+// SetContinuationToken sets the ContinuationToken field's value.
+func (s *ListObjectsV2Output) SetContinuationToken(v string) *ListObjectsV2Output {
+        s.ContinuationToken = &v
+        return s
+}
+
+// SetDelimiter sets the Delimiter field's value.
+func (s *ListObjectsV2Output) SetDelimiter(v string) *ListObjectsV2Output {
+        s.Delimiter = &v
+        return s
+}
+
+// SetEncodingType sets the EncodingType field's value.
+func (s *ListObjectsV2Output) SetEncodingType(v string) *ListObjectsV2Output {
+        s.EncodingType = &v
+        return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListObjectsV2Output) SetIsTruncated(v bool) *ListObjectsV2Output {
+        s.IsTruncated = &v
+        return s
+}
+
+// SetKeyCount sets the KeyCount field's value.
+func (s *ListObjectsV2Output) SetKeyCount(v int64) *ListObjectsV2Output {
+        s.KeyCount = &v
+        return s
+}
+
+// SetMaxKeys sets the MaxKeys field's value.
+func (s *ListObjectsV2Output) SetMaxKeys(v int64) *ListObjectsV2Output {
+        s.MaxKeys = &v
+        return s
+}
+
+// SetName sets the Name field's value.
+func (s *ListObjectsV2Output) SetName(v string) *ListObjectsV2Output {
+        s.Name = &v
+        return s
+}
+
+// SetNextContinuationToken sets the NextContinuationToken field's value.
+func (s *ListObjectsV2Output) SetNextContinuationToken(v string) *ListObjectsV2Output {
+        s.NextContinuationToken = &v
+        return s
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *ListObjectsV2Output) SetPrefix(v string) *ListObjectsV2Output {
+        s.Prefix = &v
+        return s
+}
+
+// SetStartAfter sets the StartAfter field's value.
+func (s *ListObjectsV2Output) SetStartAfter(v string) *ListObjectsV2Output {
+        s.StartAfter = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListPartsRequest
+type ListPartsInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Key is a required field
+        Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`
+
+        // Sets the maximum number of parts to return.
+        MaxParts *int64 `location:"querystring" locationName:"max-parts" type:"integer"`
+
+        // Specifies the part after which listing should begin. Only parts with higher
+        // part numbers will be listed.
+        PartNumberMarker *int64 `location:"querystring" locationName:"part-number-marker" type:"integer"`
+
+        // Confirms that the requester knows that she or he will be charged for the
+        // request. Bucket owners need not specify this parameter in their requests.
+        // Documentation on downloading objects from requester pays buckets can be found
+        // at http://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html
+        RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string" enum:"RequestPayer"`
+
+        // Upload ID identifying the multipart upload whose parts are being listed.
+        //
+        // UploadId is a required field
+        UploadId *string `location:"querystring" locationName:"uploadId" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s ListPartsInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListPartsInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListPartsInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "ListPartsInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+        if s.UploadId == nil {
+                invalidParams.Add(request.NewErrParamRequired("UploadId"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *ListPartsInput) SetBucket(v string) *ListPartsInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *ListPartsInput) SetKey(v string) *ListPartsInput {
+        s.Key = &v
+        return s
+}
+
+// SetMaxParts sets the MaxParts field's value.
+func (s *ListPartsInput) SetMaxParts(v int64) *ListPartsInput {
+        s.MaxParts = &v
+        return s
+}
+
+// SetPartNumberMarker sets the PartNumberMarker field's value.
+func (s *ListPartsInput) SetPartNumberMarker(v int64) *ListPartsInput {
+        s.PartNumberMarker = &v
+        return s
+}
+
+// SetRequestPayer sets the RequestPayer field's value.
+func (s *ListPartsInput) SetRequestPayer(v string) *ListPartsInput {
+        s.RequestPayer = &v
+        return s
+}
+
+// SetUploadId sets the UploadId field's value.
+func (s *ListPartsInput) SetUploadId(v string) *ListPartsInput {
+        s.UploadId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListPartsOutput
+type ListPartsOutput struct {
+        _ struct{} `type:"structure"`
+
+        // Date when multipart upload will become eligible for abort operation by lifecycle.
+        AbortDate *time.Time `location:"header" locationName:"x-amz-abort-date" type:"timestamp" timestampFormat:"rfc822"`
+
+        // Id of the lifecycle rule that makes a multipart upload eligible for abort
+        // operation.
+        AbortRuleId *string `location:"header" locationName:"x-amz-abort-rule-id" type:"string"`
+
+        // Name of the bucket to which the multipart upload was initiated.
+        Bucket *string `type:"string"`
+
+        // Identifies who initiated the multipart upload.
+        Initiator *Initiator `type:"structure"`
+
+        // Indicates whether the returned list of parts is truncated.
+        IsTruncated *bool `type:"boolean"`
+
+        // Object key for which the multipart upload was initiated.
+        Key *string `min:"1" type:"string"`
+
+        // Maximum number of parts that were allowed in the response.
+        MaxParts *int64 `type:"integer"`
+
+        // When a list is truncated, this element specifies the last part in the list,
+        // as well as the value to use for the part-number-marker request parameter
+        // in a subsequent request.
+        NextPartNumberMarker *int64 `type:"integer"`
+
+        Owner *Owner `type:"structure"`
+
+        // Part number after which listing begins.
+        PartNumberMarker *int64 `type:"integer"`
+
+        Parts []*Part `locationName:"Part" type:"list" flattened:"true"`
+
+        // If present, indicates that the requester was successfully charged for the
+        // request.
+        RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`
+
+        // The class of storage used to store the object.
+        StorageClass *string `type:"string" enum:"StorageClass"`
+
+        // Upload ID identifying the multipart upload whose parts are being listed.
+        UploadId *string `type:"string"`
+}
+
+// String returns the string representation
+func (s ListPartsOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListPartsOutput) GoString() string {
+        return s.String()
+}
+
+// SetAbortDate sets the AbortDate field's value.
+func (s *ListPartsOutput) SetAbortDate(v time.Time) *ListPartsOutput {
+        s.AbortDate = &v
+        return s
+}
+
+// SetAbortRuleId sets the AbortRuleId field's value.
+func (s *ListPartsOutput) SetAbortRuleId(v string) *ListPartsOutput {
+        s.AbortRuleId = &v
+        return s
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *ListPartsOutput) SetBucket(v string) *ListPartsOutput {
+        s.Bucket = &v
+        return s
+}
+
+// SetInitiator sets the Initiator field's value.
+func (s *ListPartsOutput) SetInitiator(v *Initiator) *ListPartsOutput {
+        s.Initiator = v
+        return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListPartsOutput) SetIsTruncated(v bool) *ListPartsOutput {
+        s.IsTruncated = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *ListPartsOutput) SetKey(v string) *ListPartsOutput {
+        s.Key = &v
+        return s
+}
+
+// SetMaxParts sets the MaxParts field's value.
+func (s *ListPartsOutput) SetMaxParts(v int64) *ListPartsOutput {
+        s.MaxParts = &v
+        return s
+}
+
+// SetNextPartNumberMarker sets the NextPartNumberMarker field's value.
+func (s *ListPartsOutput) SetNextPartNumberMarker(v int64) *ListPartsOutput {
+        s.NextPartNumberMarker = &v
+        return s
+}
+
+// SetOwner sets the Owner field's value.
+func (s *ListPartsOutput) SetOwner(v *Owner) *ListPartsOutput {
+        s.Owner = v
+        return s
+}
+
+// SetPartNumberMarker sets the PartNumberMarker field's value.
+func (s *ListPartsOutput) SetPartNumberMarker(v int64) *ListPartsOutput {
+        s.PartNumberMarker = &v
+        return s
+}
+
+// SetParts sets the Parts field's value.
+func (s *ListPartsOutput) SetParts(v []*Part) *ListPartsOutput {
+        s.Parts = v
+        return s
+}
+
+// SetRequestCharged sets the RequestCharged field's value.
+func (s *ListPartsOutput) SetRequestCharged(v string) *ListPartsOutput {
+        s.RequestCharged = &v
+        return s
+}
+
+// SetStorageClass sets the StorageClass field's value.
+func (s *ListPartsOutput) SetStorageClass(v string) *ListPartsOutput {
+        s.StorageClass = &v
+        return s
+}
+
+// SetUploadId sets the UploadId field's value.
+func (s *ListPartsOutput) SetUploadId(v string) *ListPartsOutput {
+        s.UploadId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/LoggingEnabled
+type LoggingEnabled struct {
+        _ struct{} `type:"structure"`
+
+        // Specifies the bucket where you want Amazon S3 to store server access logs.
+        // You can have your logs delivered to any bucket that you own, including the
+        // same bucket that is being logged. You can also configure multiple buckets
+        // to deliver their logs to the same target bucket. In this case you should
+        // choose a different TargetPrefix for each source bucket so that the delivered
+        // log files can be distinguished by key.
+        TargetBucket *string `type:"string"`
+
+        TargetGrants []*TargetGrant `locationNameList:"Grant" type:"list"`
+
+        // This element lets you specify a prefix for the keys that the log files will
+        // be stored under.
+        TargetPrefix *string `type:"string"`
+}
+
+// String returns the string representation
+func (s LoggingEnabled) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s LoggingEnabled) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *LoggingEnabled) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "LoggingEnabled"}
+        if s.TargetGrants != nil {
+                for i, v := range s.TargetGrants {
+                        if v == nil {
+                                continue
+                        }
+                        if err := v.Validate(); err != nil {
+                                invalidParams.AddNested(fmt.Sprintf("%s[%v]", "TargetGrants", i), err.(request.ErrInvalidParams))
+                        }
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetTargetBucket sets the TargetBucket field's value.
+func (s *LoggingEnabled) SetTargetBucket(v string) *LoggingEnabled {
+        s.TargetBucket = &v
+        return s
+}
+
+// SetTargetGrants sets the TargetGrants field's value.
+func (s *LoggingEnabled) SetTargetGrants(v []*TargetGrant) *LoggingEnabled {
+        s.TargetGrants = v
+        return s
+}
+
+// SetTargetPrefix sets the TargetPrefix field's value.
+func (s *LoggingEnabled) SetTargetPrefix(v string) *LoggingEnabled {
+        s.TargetPrefix = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/MetricsAndOperator
+type MetricsAndOperator struct {
+        _ struct{} `type:"structure"`
+
+        // The prefix used when evaluating an AND predicate.
+        Prefix *string `type:"string"`
+
+        // The list of tags used when evaluating an AND predicate.
+        Tags []*Tag `locationName:"Tag" locationNameList:"Tag" type:"list" flattened:"true"`
+}
+
+// String returns the string representation
+func (s MetricsAndOperator) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s MetricsAndOperator) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *MetricsAndOperator) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "MetricsAndOperator"}
+        if s.Tags != nil {
+                for i, v := range s.Tags {
+                        if v == nil {
+                                continue
+                        }
+                        if err := v.Validate(); err != nil {
+                                invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams))
+                        }
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *MetricsAndOperator) SetPrefix(v string) *MetricsAndOperator {
+        s.Prefix = &v
+        return s
+}
+
+// SetTags sets the Tags field's value.
+func (s *MetricsAndOperator) SetTags(v []*Tag) *MetricsAndOperator {
+        s.Tags = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/MetricsConfiguration
+type MetricsConfiguration struct {
+        _ struct{} `type:"structure"`
+
+        // Specifies a metrics configuration filter. The metrics configuration will
+        // only include objects that meet the filter's criteria. A filter must be a
+        // prefix, a tag, or a conjunction (MetricsAndOperator).
+        Filter *MetricsFilter `type:"structure"`
+
+        // The ID used to identify the metrics configuration.
+        //
+        // Id is a required field
+        Id *string `type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s MetricsConfiguration) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s MetricsConfiguration) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *MetricsConfiguration) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "MetricsConfiguration"}
+        if s.Id == nil {
+                invalidParams.Add(request.NewErrParamRequired("Id"))
+        }
+        if s.Filter != nil {
+                if err := s.Filter.Validate(); err != nil {
+                        invalidParams.AddNested("Filter", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetFilter sets the Filter field's value.
+func (s *MetricsConfiguration) SetFilter(v *MetricsFilter) *MetricsConfiguration {
+        s.Filter = v
+        return s
+}
+
+// SetId sets the Id field's value.
+func (s *MetricsConfiguration) SetId(v string) *MetricsConfiguration {
+        s.Id = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/MetricsFilter
+type MetricsFilter struct {
+        _ struct{} `type:"structure"`
+
+        // A conjunction (logical AND) of predicates, which is used in evaluating a
+        // metrics filter. The operator must have at least two predicates, and an object
+        // must match all of the predicates in order for the filter to apply.
+        And *MetricsAndOperator `type:"structure"`
+
+        // The prefix used when evaluating a metrics filter.
+        Prefix *string `type:"string"`
+
+        // The tag used when evaluating a metrics filter.
+        Tag *Tag `type:"structure"`
+}
+
+// String returns the string representation
+func (s MetricsFilter) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s MetricsFilter) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *MetricsFilter) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "MetricsFilter"}
+        if s.And != nil {
+                if err := s.And.Validate(); err != nil {
+                        invalidParams.AddNested("And", err.(request.ErrInvalidParams))
+                }
+        }
+        if s.Tag != nil {
+                if err := s.Tag.Validate(); err != nil {
+                        invalidParams.AddNested("Tag", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetAnd sets the And field's value.
+func (s *MetricsFilter) SetAnd(v *MetricsAndOperator) *MetricsFilter {
+        s.And = v
+        return s
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *MetricsFilter) SetPrefix(v string) *MetricsFilter {
+        s.Prefix = &v
+        return s
+}
+
+// SetTag sets the Tag field's value.
+func (s *MetricsFilter) SetTag(v *Tag) *MetricsFilter {
+        s.Tag = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/MultipartUpload
+type MultipartUpload struct {
+        _ struct{} `type:"structure"`
+
+        // Date and time at which the multipart upload was initiated.
+        Initiated *time.Time `type:"timestamp" timestampFormat:"iso8601"`
+
+        // Identifies who initiated the multipart upload.
+        Initiator *Initiator `type:"structure"`
+
+        // Key of the object for which the multipart upload was initiated.
+        Key *string `min:"1" type:"string"`
+
+        Owner *Owner `type:"structure"`
+
+        // The class of storage used to store the object.
+        StorageClass *string `type:"string" enum:"StorageClass"`
+
+        // Upload ID that identifies the multipart upload.
+        UploadId *string `type:"string"`
+}
+
+// String returns the string representation
+func (s MultipartUpload) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s MultipartUpload) GoString() string {
+        return s.String()
+}
+
+// SetInitiated sets the Initiated field's value.
+func (s *MultipartUpload) SetInitiated(v time.Time) *MultipartUpload {
+        s.Initiated = &v
+        return s
+}
+
+// SetInitiator sets the Initiator field's value.
+func (s *MultipartUpload) SetInitiator(v *Initiator) *MultipartUpload {
+        s.Initiator = v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *MultipartUpload) SetKey(v string) *MultipartUpload {
+        s.Key = &v
+        return s
+}
+
+// SetOwner sets the Owner field's value.
+func (s *MultipartUpload) SetOwner(v *Owner) *MultipartUpload {
+        s.Owner = v
+        return s
+}
+
+// SetStorageClass sets the StorageClass field's value.
+func (s *MultipartUpload) SetStorageClass(v string) *MultipartUpload {
+        s.StorageClass = &v
+        return s
+}
+
+// SetUploadId sets the UploadId field's value.
+func (s *MultipartUpload) SetUploadId(v string) *MultipartUpload {
+        s.UploadId = &v
+        return s
+}
+
+// Specifies when noncurrent object versions expire. Upon expiration, Amazon
+// S3 permanently deletes the noncurrent object versions. You set this lifecycle
+// configuration action on a bucket that has versioning enabled (or suspended)
+// to request that Amazon S3 delete noncurrent object versions at a specific
+// period in the object's lifetime.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/NoncurrentVersionExpiration
+type NoncurrentVersionExpiration struct {
+        _ struct{} `type:"structure"`
+
+        // Specifies the number of days an object is noncurrent before Amazon S3 can
+        // perform the associated action. For information about the noncurrent days
+        // calculations, see How Amazon S3 Calculates When an Object Became Noncurrent
+        // (http://docs.aws.amazon.com/AmazonS3/latest/dev/s3-access-control.html)
+        NoncurrentDays *int64 `type:"integer"`
+}
+
+// String returns the string representation
+func (s NoncurrentVersionExpiration) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s NoncurrentVersionExpiration) GoString() string {
+        return s.String()
+}
+
+// SetNoncurrentDays sets the NoncurrentDays field's value.
+func (s *NoncurrentVersionExpiration) SetNoncurrentDays(v int64) *NoncurrentVersionExpiration {
+        s.NoncurrentDays = &v
+        return s
+}
+
+// Container for the transition rule that describes when noncurrent objects
+// transition to the STANDARD_IA or GLACIER storage class. If your bucket is
+// versioning-enabled (or versioning is suspended), you can set this action
+// to request that Amazon S3 transition noncurrent object versions to the STANDARD_IA
+// or GLACIER storage class at a specific period in the object's lifetime.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/NoncurrentVersionTransition
+type NoncurrentVersionTransition struct {
+        _ struct{} `type:"structure"`
+
+        // Specifies the number of days an object is noncurrent before Amazon S3 can
+        // perform the associated action. For information about the noncurrent days
+        // calculations, see How Amazon S3 Calculates When an Object Became Noncurrent
+        // (http://docs.aws.amazon.com/AmazonS3/latest/dev/s3-access-control.html)
+        NoncurrentDays *int64 `type:"integer"`
+
+        // The class of storage used to store the object.
+        StorageClass *string `type:"string" enum:"TransitionStorageClass"`
+}
+
+// String returns the string representation
+func (s NoncurrentVersionTransition) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s NoncurrentVersionTransition) GoString() string {
+        return s.String()
+}
+
+// SetNoncurrentDays sets the NoncurrentDays field's value.
+func (s *NoncurrentVersionTransition) SetNoncurrentDays(v int64) *NoncurrentVersionTransition {
+        s.NoncurrentDays = &v
+        return s
+}
+
+// SetStorageClass sets the StorageClass field's value.
+func (s *NoncurrentVersionTransition) SetStorageClass(v string) *NoncurrentVersionTransition {
+        s.StorageClass = &v
+        return s
+}
+
+// Container for specifying the notification configuration of the bucket. If
+// this element is empty, notifications are turned off on the bucket.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/NotificationConfiguration
+type NotificationConfiguration struct {
+        _ struct{} `type:"structure"`
+
+        LambdaFunctionConfigurations []*LambdaFunctionConfiguration `locationName:"CloudFunctionConfiguration" type:"list" flattened:"true"`
+
+        QueueConfigurations []*QueueConfiguration `locationName:"QueueConfiguration" type:"list" flattened:"true"`
+
+        TopicConfigurations []*TopicConfiguration `locationName:"TopicConfiguration" type:"list" flattened:"true"`
+}
+
+// String returns the string representation
+func (s NotificationConfiguration) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s NotificationConfiguration) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *NotificationConfiguration) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "NotificationConfiguration"}
+        if s.LambdaFunctionConfigurations != nil {
+                for i, v := range s.LambdaFunctionConfigurations {
+                        if v == nil {
+                                continue
+                        }
+                        if err := v.Validate(); err != nil {
+                                invalidParams.AddNested(fmt.Sprintf("%s[%v]", "LambdaFunctionConfigurations", i), err.(request.ErrInvalidParams))
+                        }
+                }
+        }
+        if s.QueueConfigurations != nil {
+                for i, v := range s.QueueConfigurations {
+                        if v == nil {
+                                continue
+                        }
+                        if err := v.Validate(); err != nil {
+                                invalidParams.AddNested(fmt.Sprintf("%s[%v]", "QueueConfigurations", i), err.(request.ErrInvalidParams))
+                        }
+                }
+        }
+        if s.TopicConfigurations != nil {
+                for i, v := range s.TopicConfigurations {
+                        if v == nil {
+                                continue
+                        }
+                        if err := v.Validate(); err != nil {
+                                invalidParams.AddNested(fmt.Sprintf("%s[%v]", "TopicConfigurations", i), err.(request.ErrInvalidParams))
+                        }
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetLambdaFunctionConfigurations sets the LambdaFunctionConfigurations field's value.
+func (s *NotificationConfiguration) SetLambdaFunctionConfigurations(v []*LambdaFunctionConfiguration) *NotificationConfiguration {
+        s.LambdaFunctionConfigurations = v
+        return s
+}
+
+// SetQueueConfigurations sets the QueueConfigurations field's value.
+func (s *NotificationConfiguration) SetQueueConfigurations(v []*QueueConfiguration) *NotificationConfiguration {
+        s.QueueConfigurations = v
+        return s
+}
+
+// SetTopicConfigurations sets the TopicConfigurations field's value.
+func (s *NotificationConfiguration) SetTopicConfigurations(v []*TopicConfiguration) *NotificationConfiguration {
+        s.TopicConfigurations = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/NotificationConfigurationDeprecated
+type NotificationConfigurationDeprecated struct {
+        _ struct{} `type:"structure"`
+
+        CloudFunctionConfiguration *CloudFunctionConfiguration `type:"structure"`
+
+        QueueConfiguration *QueueConfigurationDeprecated `type:"structure"`
+
+        TopicConfiguration *TopicConfigurationDeprecated `type:"structure"`
+}
+
+// String returns the string representation
+func (s NotificationConfigurationDeprecated) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s NotificationConfigurationDeprecated) GoString() string {
+        return s.String()
+}
+
+// SetCloudFunctionConfiguration sets the CloudFunctionConfiguration field's value.
+func (s *NotificationConfigurationDeprecated) SetCloudFunctionConfiguration(v *CloudFunctionConfiguration) *NotificationConfigurationDeprecated {
+        s.CloudFunctionConfiguration = v
+        return s
+}
+
+// SetQueueConfiguration sets the QueueConfiguration field's value.
+func (s *NotificationConfigurationDeprecated) SetQueueConfiguration(v *QueueConfigurationDeprecated) *NotificationConfigurationDeprecated {
+        s.QueueConfiguration = v
+        return s
+}
+
+// SetTopicConfiguration sets the TopicConfiguration field's value.
+func (s *NotificationConfigurationDeprecated) SetTopicConfiguration(v *TopicConfigurationDeprecated) *NotificationConfigurationDeprecated {
+        s.TopicConfiguration = v
+        return s
+}
+
+// Container for object key name filtering rules. For information about key
+// name filtering, go to Configuring Event Notifications (http://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html)
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/NotificationConfigurationFilter
+type NotificationConfigurationFilter struct {
+        _ struct{} `type:"structure"`
+
+        // Container for object key name prefix and suffix filtering rules.
+        Key *KeyFilter `locationName:"S3Key" type:"structure"`
+}
+
+// String returns the string representation
+func (s NotificationConfigurationFilter) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s NotificationConfigurationFilter) GoString() string {
+        return s.String()
+}
+
+// SetKey sets the Key field's value.
+func (s *NotificationConfigurationFilter) SetKey(v *KeyFilter) *NotificationConfigurationFilter {
+        s.Key = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Object
+type Object struct {
+        _ struct{} `type:"structure"`
+
+        ETag *string `type:"string"`
+
+        Key *string `min:"1" type:"string"`
+
+        LastModified *time.Time `type:"timestamp" timestampFormat:"iso8601"`
+
+        Owner *Owner `type:"structure"`
+
+        Size *int64 `type:"integer"`
+
+        // The class of storage used to store the object.
+        StorageClass *string `type:"string" enum:"ObjectStorageClass"`
+}
+
+// String returns the string representation
+func (s Object) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Object) GoString() string {
+        return s.String()
+}
+
+// SetETag sets the ETag field's value.
+func (s *Object) SetETag(v string) *Object {
+        s.ETag = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *Object) SetKey(v string) *Object {
+        s.Key = &v
+        return s
+}
+
+// SetLastModified sets the LastModified field's value.
+func (s *Object) SetLastModified(v time.Time) *Object {
+        s.LastModified = &v
+        return s
+}
+
+// SetOwner sets the Owner field's value.
+func (s *Object) SetOwner(v *Owner) *Object {
+        s.Owner = v
+        return s
+}
+
+// SetSize sets the Size field's value.
+func (s *Object) SetSize(v int64) *Object {
+        s.Size = &v
+        return s
+}
+
+// SetStorageClass sets the StorageClass field's value.
+func (s *Object) SetStorageClass(v string) *Object {
+        s.StorageClass = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ObjectIdentifier
+type ObjectIdentifier struct {
+        _ struct{} `type:"structure"`
+
+        // Key name of the object to delete.
+        //
+        // Key is a required field
+        Key *string `min:"1" type:"string" required:"true"`
+
+        // VersionId for the specific version of the object to delete.
+        VersionId *string `type:"string"`
+}
+
+// String returns the string representation
+func (s ObjectIdentifier) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ObjectIdentifier) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ObjectIdentifier) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "ObjectIdentifier"}
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetKey sets the Key field's value.
+func (s *ObjectIdentifier) SetKey(v string) *ObjectIdentifier {
+        s.Key = &v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *ObjectIdentifier) SetVersionId(v string) *ObjectIdentifier {
+        s.VersionId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ObjectVersion
+type ObjectVersion struct {
+        _ struct{} `type:"structure"`
+
+        ETag *string `type:"string"`
+
+        // Specifies whether the object is (true) or is not (false) the latest version
+        // of an object.
+        IsLatest *bool `type:"boolean"`
+
+        // The object key.
+        Key *string `min:"1" type:"string"`
+
+        // Date and time the object was last modified.
+        LastModified *time.Time `type:"timestamp" timestampFormat:"iso8601"`
+
+        Owner *Owner `type:"structure"`
+
+        // Size in bytes of the object.
+        Size *int64 `type:"integer"`
+
+        // The class of storage used to store the object.
+        StorageClass *string `type:"string" enum:"ObjectVersionStorageClass"`
+
+        // Version ID of an object.
+        VersionId *string `type:"string"`
+}
+
+// String returns the string representation
+func (s ObjectVersion) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ObjectVersion) GoString() string {
+        return s.String()
+}
+
+// SetETag sets the ETag field's value.
+func (s *ObjectVersion) SetETag(v string) *ObjectVersion {
+        s.ETag = &v
+        return s
+}
+
+// SetIsLatest sets the IsLatest field's value.
+func (s *ObjectVersion) SetIsLatest(v bool) *ObjectVersion {
+        s.IsLatest = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *ObjectVersion) SetKey(v string) *ObjectVersion {
+        s.Key = &v
+        return s
+}
+
+// SetLastModified sets the LastModified field's value.
+func (s *ObjectVersion) SetLastModified(v time.Time) *ObjectVersion {
+        s.LastModified = &v
+        return s
+}
+
+// SetOwner sets the Owner field's value.
+func (s *ObjectVersion) SetOwner(v *Owner) *ObjectVersion {
+        s.Owner = v
+        return s
+}
+
+// SetSize sets the Size field's value.
+func (s *ObjectVersion) SetSize(v int64) *ObjectVersion {
+        s.Size = &v
+        return s
+}
+
+// SetStorageClass sets the StorageClass field's value.
+func (s *ObjectVersion) SetStorageClass(v string) *ObjectVersion {
+        s.StorageClass = &v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *ObjectVersion) SetVersionId(v string) *ObjectVersion {
+        s.VersionId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Owner
+type Owner struct {
+        _ struct{} `type:"structure"`
+
+        DisplayName *string `type:"string"`
+
+        ID *string `type:"string"`
+}
+
+// String returns the string representation
+func (s Owner) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Owner) GoString() string {
+        return s.String()
+}
+
+// SetDisplayName sets the DisplayName field's value.
+func (s *Owner) SetDisplayName(v string) *Owner {
+        s.DisplayName = &v
+        return s
+}
+
+// SetID sets the ID field's value.
+func (s *Owner) SetID(v string) *Owner {
+        s.ID = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Part
+type Part struct {
+        _ struct{} `type:"structure"`
+
+        // Entity tag returned when the part was uploaded.
+        ETag *string `type:"string"`
+
+        // Date and time at which the part was uploaded.
+        LastModified *time.Time `type:"timestamp" timestampFormat:"iso8601"`
+
+        // Part number identifying the part. This is a positive integer between 1 and
+        // 10,000.
+        PartNumber *int64 `type:"integer"`
+
+        // Size of the uploaded part data.
+        Size *int64 `type:"integer"`
+}
+
+// String returns the string representation
+func (s Part) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Part) GoString() string {
+        return s.String()
+}
+
+// SetETag sets the ETag field's value.
+func (s *Part) SetETag(v string) *Part {
+        s.ETag = &v
+        return s
+}
+
+// SetLastModified sets the LastModified field's value.
+func (s *Part) SetLastModified(v time.Time) *Part {
+        s.LastModified = &v
+        return s
+}
+
+// SetPartNumber sets the PartNumber field's value.
+func (s *Part) SetPartNumber(v int64) *Part {
+        s.PartNumber = &v
+        return s
+}
+
+// SetSize sets the Size field's value.
+func (s *Part) SetSize(v int64) *Part {
+        s.Size = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketAccelerateConfigurationRequest
+type PutBucketAccelerateConfigurationInput struct {
+        _ struct{} `type:"structure" payload:"AccelerateConfiguration"`
+
+        // Specifies the Accelerate Configuration you want to set for the bucket.
+        //
+        // AccelerateConfiguration is a required field
+        AccelerateConfiguration *AccelerateConfiguration `locationName:"AccelerateConfiguration" type:"structure" required:"true"`
+
+        // Name of the bucket for which the accelerate configuration is set.
+        //
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s PutBucketAccelerateConfigurationInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketAccelerateConfigurationInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutBucketAccelerateConfigurationInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "PutBucketAccelerateConfigurationInput"}
+        if s.AccelerateConfiguration == nil {
+                invalidParams.Add(request.NewErrParamRequired("AccelerateConfiguration"))
+        }
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetAccelerateConfiguration sets the AccelerateConfiguration field's value.
+func (s *PutBucketAccelerateConfigurationInput) SetAccelerateConfiguration(v *AccelerateConfiguration) *PutBucketAccelerateConfigurationInput {
+        s.AccelerateConfiguration = v
+        return s
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *PutBucketAccelerateConfigurationInput) SetBucket(v string) *PutBucketAccelerateConfigurationInput {
+        s.Bucket = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketAccelerateConfigurationOutput
+type PutBucketAccelerateConfigurationOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutBucketAccelerateConfigurationOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketAccelerateConfigurationOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketAclRequest
+type PutBucketAclInput struct {
+        _ struct{} `type:"structure" payload:"AccessControlPolicy"`
+
+        // The canned ACL to apply to the bucket.
+        ACL *string `location:"header" locationName:"x-amz-acl" type:"string" enum:"BucketCannedACL"`
+
+        AccessControlPolicy *AccessControlPolicy `locationName:"AccessControlPolicy" type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Allows grantee the read, write, read ACP, and write ACP permissions on the
+        // bucket.
+        GrantFullControl *string `location:"header" locationName:"x-amz-grant-full-control" type:"string"`
+
+        // Allows grantee to list the objects in the bucket.
+        GrantRead *string `location:"header" locationName:"x-amz-grant-read" type:"string"`
+
+        // Allows grantee to read the bucket ACL.
+        GrantReadACP *string `location:"header" locationName:"x-amz-grant-read-acp" type:"string"`
+
+        // Allows grantee to create, overwrite, and delete any object in the bucket.
+        GrantWrite *string `location:"header" locationName:"x-amz-grant-write" type:"string"`
+
+        // Allows grantee to write the ACL for the applicable bucket.
+        GrantWriteACP *string `location:"header" locationName:"x-amz-grant-write-acp" type:"string"`
+}
+
+// String returns the string representation
+func (s PutBucketAclInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketAclInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutBucketAclInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "PutBucketAclInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.AccessControlPolicy != nil {
+                if err := s.AccessControlPolicy.Validate(); err != nil {
+                        invalidParams.AddNested("AccessControlPolicy", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetACL sets the ACL field's value.
+func (s *PutBucketAclInput) SetACL(v string) *PutBucketAclInput {
+        s.ACL = &v
+        return s
+}
+
+// SetAccessControlPolicy sets the AccessControlPolicy field's value.
+func (s *PutBucketAclInput) SetAccessControlPolicy(v *AccessControlPolicy) *PutBucketAclInput {
+        s.AccessControlPolicy = v
+        return s
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *PutBucketAclInput) SetBucket(v string) *PutBucketAclInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetGrantFullControl sets the GrantFullControl field's value.
+func (s *PutBucketAclInput) SetGrantFullControl(v string) *PutBucketAclInput {
+        s.GrantFullControl = &v
+        return s
+}
+
+// SetGrantRead sets the GrantRead field's value.
+func (s *PutBucketAclInput) SetGrantRead(v string) *PutBucketAclInput {
+        s.GrantRead = &v
+        return s
+}
+
+// SetGrantReadACP sets the GrantReadACP field's value.
+func (s *PutBucketAclInput) SetGrantReadACP(v string) *PutBucketAclInput {
+        s.GrantReadACP = &v
+        return s
+}
+
+// SetGrantWrite sets the GrantWrite field's value.
+func (s *PutBucketAclInput) SetGrantWrite(v string) *PutBucketAclInput {
+        s.GrantWrite = &v
+        return s
+}
+
+// SetGrantWriteACP sets the GrantWriteACP field's value.
+func (s *PutBucketAclInput) SetGrantWriteACP(v string) *PutBucketAclInput {
+        s.GrantWriteACP = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketAclOutput
+type PutBucketAclOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutBucketAclOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketAclOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketAnalyticsConfigurationRequest
+type PutBucketAnalyticsConfigurationInput struct {
+        _ struct{} `type:"structure" payload:"AnalyticsConfiguration"`
+
+        // The configuration and any analyses for the analytics filter.
+        //
+        // AnalyticsConfiguration is a required field
+        AnalyticsConfiguration *AnalyticsConfiguration `locationName:"AnalyticsConfiguration" type:"structure" required:"true"`
+
+        // The name of the bucket to which an analytics configuration is stored.
+        //
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // The identifier used to represent an analytics configuration.
+        //
+        // Id is a required field
+        Id *string `location:"querystring" locationName:"id" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s PutBucketAnalyticsConfigurationInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketAnalyticsConfigurationInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutBucketAnalyticsConfigurationInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "PutBucketAnalyticsConfigurationInput"}
+        if s.AnalyticsConfiguration == nil {
+                invalidParams.Add(request.NewErrParamRequired("AnalyticsConfiguration"))
+        }
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Id == nil {
+                invalidParams.Add(request.NewErrParamRequired("Id"))
+        }
+        if s.AnalyticsConfiguration != nil {
+                if err := s.AnalyticsConfiguration.Validate(); err != nil {
+                        invalidParams.AddNested("AnalyticsConfiguration", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetAnalyticsConfiguration sets the AnalyticsConfiguration field's value.
+func (s *PutBucketAnalyticsConfigurationInput) SetAnalyticsConfiguration(v *AnalyticsConfiguration) *PutBucketAnalyticsConfigurationInput {
+        s.AnalyticsConfiguration = v
+        return s
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *PutBucketAnalyticsConfigurationInput) SetBucket(v string) *PutBucketAnalyticsConfigurationInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetId sets the Id field's value.
+func (s *PutBucketAnalyticsConfigurationInput) SetId(v string) *PutBucketAnalyticsConfigurationInput {
+        s.Id = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketAnalyticsConfigurationOutput
+type PutBucketAnalyticsConfigurationOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutBucketAnalyticsConfigurationOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketAnalyticsConfigurationOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketCorsRequest
+type PutBucketCorsInput struct {
+        _ struct{} `type:"structure" payload:"CORSConfiguration"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // CORSConfiguration is a required field
+        CORSConfiguration *CORSConfiguration `locationName:"CORSConfiguration" type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s PutBucketCorsInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketCorsInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutBucketCorsInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "PutBucketCorsInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.CORSConfiguration == nil {
+                invalidParams.Add(request.NewErrParamRequired("CORSConfiguration"))
+        }
+        if s.CORSConfiguration != nil {
+                if err := s.CORSConfiguration.Validate(); err != nil {
+                        invalidParams.AddNested("CORSConfiguration", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *PutBucketCorsInput) SetBucket(v string) *PutBucketCorsInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetCORSConfiguration sets the CORSConfiguration field's value.
+func (s *PutBucketCorsInput) SetCORSConfiguration(v *CORSConfiguration) *PutBucketCorsInput {
+        s.CORSConfiguration = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketCorsOutput
+type PutBucketCorsOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutBucketCorsOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketCorsOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketInventoryConfigurationRequest
+type PutBucketInventoryConfigurationInput struct {
+        _ struct{} `type:"structure" payload:"InventoryConfiguration"`
+
+        // The name of the bucket where the inventory configuration will be stored.
+        //
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // The ID used to identify the inventory configuration.
+        //
+        // Id is a required field
+        Id *string `location:"querystring" locationName:"id" type:"string" required:"true"`
+
+        // Specifies the inventory configuration.
+        //
+        // InventoryConfiguration is a required field
+        InventoryConfiguration *InventoryConfiguration `locationName:"InventoryConfiguration" type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s PutBucketInventoryConfigurationInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketInventoryConfigurationInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutBucketInventoryConfigurationInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "PutBucketInventoryConfigurationInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Id == nil {
+                invalidParams.Add(request.NewErrParamRequired("Id"))
+        }
+        if s.InventoryConfiguration == nil {
+                invalidParams.Add(request.NewErrParamRequired("InventoryConfiguration"))
+        }
+        if s.InventoryConfiguration != nil {
+                if err := s.InventoryConfiguration.Validate(); err != nil {
+                        invalidParams.AddNested("InventoryConfiguration", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *PutBucketInventoryConfigurationInput) SetBucket(v string) *PutBucketInventoryConfigurationInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetId sets the Id field's value.
+func (s *PutBucketInventoryConfigurationInput) SetId(v string) *PutBucketInventoryConfigurationInput {
+        s.Id = &v
+        return s
+}
+
+// SetInventoryConfiguration sets the InventoryConfiguration field's value.
+func (s *PutBucketInventoryConfigurationInput) SetInventoryConfiguration(v *InventoryConfiguration) *PutBucketInventoryConfigurationInput {
+        s.InventoryConfiguration = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketInventoryConfigurationOutput
+type PutBucketInventoryConfigurationOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutBucketInventoryConfigurationOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketInventoryConfigurationOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketLifecycleConfigurationRequest
+type PutBucketLifecycleConfigurationInput struct {
+        _ struct{} `type:"structure" payload:"LifecycleConfiguration"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        LifecycleConfiguration *BucketLifecycleConfiguration `locationName:"LifecycleConfiguration" type:"structure"`
+}
+
+// String returns the string representation
+func (s PutBucketLifecycleConfigurationInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketLifecycleConfigurationInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutBucketLifecycleConfigurationInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "PutBucketLifecycleConfigurationInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.LifecycleConfiguration != nil {
+                if err := s.LifecycleConfiguration.Validate(); err != nil {
+                        invalidParams.AddNested("LifecycleConfiguration", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *PutBucketLifecycleConfigurationInput) SetBucket(v string) *PutBucketLifecycleConfigurationInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetLifecycleConfiguration sets the LifecycleConfiguration field's value.
+func (s *PutBucketLifecycleConfigurationInput) SetLifecycleConfiguration(v *BucketLifecycleConfiguration) *PutBucketLifecycleConfigurationInput {
+        s.LifecycleConfiguration = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketLifecycleConfigurationOutput
+type PutBucketLifecycleConfigurationOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutBucketLifecycleConfigurationOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketLifecycleConfigurationOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketLifecycleRequest
+type PutBucketLifecycleInput struct {
+        _ struct{} `type:"structure" payload:"LifecycleConfiguration"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        LifecycleConfiguration *LifecycleConfiguration `locationName:"LifecycleConfiguration" type:"structure"`
+}
+
+// String returns the string representation
+func (s PutBucketLifecycleInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketLifecycleInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutBucketLifecycleInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "PutBucketLifecycleInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.LifecycleConfiguration != nil {
+                if err := s.LifecycleConfiguration.Validate(); err != nil {
+                        invalidParams.AddNested("LifecycleConfiguration", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *PutBucketLifecycleInput) SetBucket(v string) *PutBucketLifecycleInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetLifecycleConfiguration sets the LifecycleConfiguration field's value.
+func (s *PutBucketLifecycleInput) SetLifecycleConfiguration(v *LifecycleConfiguration) *PutBucketLifecycleInput {
+        s.LifecycleConfiguration = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketLifecycleOutput
+type PutBucketLifecycleOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutBucketLifecycleOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketLifecycleOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketLoggingRequest
+type PutBucketLoggingInput struct {
+        _ struct{} `type:"structure" payload:"BucketLoggingStatus"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // BucketLoggingStatus is a required field
+        BucketLoggingStatus *BucketLoggingStatus `locationName:"BucketLoggingStatus" type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s PutBucketLoggingInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketLoggingInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutBucketLoggingInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "PutBucketLoggingInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.BucketLoggingStatus == nil {
+                invalidParams.Add(request.NewErrParamRequired("BucketLoggingStatus"))
+        }
+        if s.BucketLoggingStatus != nil {
+                if err := s.BucketLoggingStatus.Validate(); err != nil {
+                        invalidParams.AddNested("BucketLoggingStatus", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *PutBucketLoggingInput) SetBucket(v string) *PutBucketLoggingInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetBucketLoggingStatus sets the BucketLoggingStatus field's value.
+func (s *PutBucketLoggingInput) SetBucketLoggingStatus(v *BucketLoggingStatus) *PutBucketLoggingInput {
+        s.BucketLoggingStatus = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketLoggingOutput
+type PutBucketLoggingOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutBucketLoggingOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketLoggingOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketMetricsConfigurationRequest
+type PutBucketMetricsConfigurationInput struct {
+        _ struct{} `type:"structure" payload:"MetricsConfiguration"`
+
+        // The name of the bucket for which the metrics configuration is set.
+        //
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // The ID used to identify the metrics configuration.
+        //
+        // Id is a required field
+        Id *string `location:"querystring" locationName:"id" type:"string" required:"true"`
+
+        // Specifies the metrics configuration.
+        //
+        // MetricsConfiguration is a required field
+        MetricsConfiguration *MetricsConfiguration `locationName:"MetricsConfiguration" type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s PutBucketMetricsConfigurationInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketMetricsConfigurationInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutBucketMetricsConfigurationInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "PutBucketMetricsConfigurationInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Id == nil {
+                invalidParams.Add(request.NewErrParamRequired("Id"))
+        }
+        if s.MetricsConfiguration == nil {
+                invalidParams.Add(request.NewErrParamRequired("MetricsConfiguration"))
+        }
+        if s.MetricsConfiguration != nil {
+                if err := s.MetricsConfiguration.Validate(); err != nil {
+                        invalidParams.AddNested("MetricsConfiguration", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *PutBucketMetricsConfigurationInput) SetBucket(v string) *PutBucketMetricsConfigurationInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetId sets the Id field's value.
+func (s *PutBucketMetricsConfigurationInput) SetId(v string) *PutBucketMetricsConfigurationInput {
+        s.Id = &v
+        return s
+}
+
+// SetMetricsConfiguration sets the MetricsConfiguration field's value.
+func (s *PutBucketMetricsConfigurationInput) SetMetricsConfiguration(v *MetricsConfiguration) *PutBucketMetricsConfigurationInput {
+        s.MetricsConfiguration = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketMetricsConfigurationOutput
+type PutBucketMetricsConfigurationOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutBucketMetricsConfigurationOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketMetricsConfigurationOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketNotificationConfigurationRequest
+type PutBucketNotificationConfigurationInput struct {
+        _ struct{} `type:"structure" payload:"NotificationConfiguration"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Container for specifying the notification configuration of the bucket. If
+        // this element is empty, notifications are turned off on the bucket.
+        //
+        // NotificationConfiguration is a required field
+        NotificationConfiguration *NotificationConfiguration `locationName:"NotificationConfiguration" type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s PutBucketNotificationConfigurationInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketNotificationConfigurationInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutBucketNotificationConfigurationInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "PutBucketNotificationConfigurationInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.NotificationConfiguration == nil {
+                invalidParams.Add(request.NewErrParamRequired("NotificationConfiguration"))
+        }
+        if s.NotificationConfiguration != nil {
+                if err := s.NotificationConfiguration.Validate(); err != nil {
+                        invalidParams.AddNested("NotificationConfiguration", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *PutBucketNotificationConfigurationInput) SetBucket(v string) *PutBucketNotificationConfigurationInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetNotificationConfiguration sets the NotificationConfiguration field's value.
+func (s *PutBucketNotificationConfigurationInput) SetNotificationConfiguration(v *NotificationConfiguration) *PutBucketNotificationConfigurationInput {
+        s.NotificationConfiguration = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketNotificationConfigurationOutput
+type PutBucketNotificationConfigurationOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutBucketNotificationConfigurationOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketNotificationConfigurationOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketNotificationRequest
+type PutBucketNotificationInput struct {
+        _ struct{} `type:"structure" payload:"NotificationConfiguration"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // NotificationConfiguration is a required field
+        NotificationConfiguration *NotificationConfigurationDeprecated `locationName:"NotificationConfiguration" type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s PutBucketNotificationInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketNotificationInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutBucketNotificationInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "PutBucketNotificationInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.NotificationConfiguration == nil {
+                invalidParams.Add(request.NewErrParamRequired("NotificationConfiguration"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *PutBucketNotificationInput) SetBucket(v string) *PutBucketNotificationInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetNotificationConfiguration sets the NotificationConfiguration field's value.
+func (s *PutBucketNotificationInput) SetNotificationConfiguration(v *NotificationConfigurationDeprecated) *PutBucketNotificationInput {
+        s.NotificationConfiguration = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketNotificationOutput
+type PutBucketNotificationOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutBucketNotificationOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketNotificationOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketPolicyRequest
+type PutBucketPolicyInput struct {
+        _ struct{} `type:"structure" payload:"Policy"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // The bucket policy as a JSON document.
+        //
+        // Policy is a required field
+        Policy *string `type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s PutBucketPolicyInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketPolicyInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutBucketPolicyInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "PutBucketPolicyInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Policy == nil {
+                invalidParams.Add(request.NewErrParamRequired("Policy"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *PutBucketPolicyInput) SetBucket(v string) *PutBucketPolicyInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetPolicy sets the Policy field's value.
+func (s *PutBucketPolicyInput) SetPolicy(v string) *PutBucketPolicyInput {
+        s.Policy = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketPolicyOutput
+type PutBucketPolicyOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutBucketPolicyOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketPolicyOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketReplicationRequest
+type PutBucketReplicationInput struct {
+        _ struct{} `type:"structure" payload:"ReplicationConfiguration"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Container for replication rules. You can add as many as 1,000 rules. Total
+        // replication configuration size can be up to 2 MB.
+        //
+        // ReplicationConfiguration is a required field
+        ReplicationConfiguration *ReplicationConfiguration `locationName:"ReplicationConfiguration" type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s PutBucketReplicationInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketReplicationInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutBucketReplicationInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "PutBucketReplicationInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.ReplicationConfiguration == nil {
+                invalidParams.Add(request.NewErrParamRequired("ReplicationConfiguration"))
+        }
+        if s.ReplicationConfiguration != nil {
+                if err := s.ReplicationConfiguration.Validate(); err != nil {
+                        invalidParams.AddNested("ReplicationConfiguration", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *PutBucketReplicationInput) SetBucket(v string) *PutBucketReplicationInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetReplicationConfiguration sets the ReplicationConfiguration field's value.
+func (s *PutBucketReplicationInput) SetReplicationConfiguration(v *ReplicationConfiguration) *PutBucketReplicationInput {
+        s.ReplicationConfiguration = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketReplicationOutput
+type PutBucketReplicationOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutBucketReplicationOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketReplicationOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketRequestPaymentRequest
+type PutBucketRequestPaymentInput struct {
+        _ struct{} `type:"structure" payload:"RequestPaymentConfiguration"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // RequestPaymentConfiguration is a required field
+        RequestPaymentConfiguration *RequestPaymentConfiguration `locationName:"RequestPaymentConfiguration" type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s PutBucketRequestPaymentInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketRequestPaymentInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutBucketRequestPaymentInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "PutBucketRequestPaymentInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.RequestPaymentConfiguration == nil {
+                invalidParams.Add(request.NewErrParamRequired("RequestPaymentConfiguration"))
+        }
+        if s.RequestPaymentConfiguration != nil {
+                if err := s.RequestPaymentConfiguration.Validate(); err != nil {
+                        invalidParams.AddNested("RequestPaymentConfiguration", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *PutBucketRequestPaymentInput) SetBucket(v string) *PutBucketRequestPaymentInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetRequestPaymentConfiguration sets the RequestPaymentConfiguration field's value.
+func (s *PutBucketRequestPaymentInput) SetRequestPaymentConfiguration(v *RequestPaymentConfiguration) *PutBucketRequestPaymentInput {
+        s.RequestPaymentConfiguration = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketRequestPaymentOutput
+type PutBucketRequestPaymentOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutBucketRequestPaymentOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketRequestPaymentOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketTaggingRequest
+type PutBucketTaggingInput struct {
+        _ struct{} `type:"structure" payload:"Tagging"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Tagging is a required field
+        Tagging *Tagging `locationName:"Tagging" type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s PutBucketTaggingInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketTaggingInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutBucketTaggingInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "PutBucketTaggingInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Tagging == nil {
+                invalidParams.Add(request.NewErrParamRequired("Tagging"))
+        }
+        if s.Tagging != nil {
+                if err := s.Tagging.Validate(); err != nil {
+                        invalidParams.AddNested("Tagging", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *PutBucketTaggingInput) SetBucket(v string) *PutBucketTaggingInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetTagging sets the Tagging field's value.
+func (s *PutBucketTaggingInput) SetTagging(v *Tagging) *PutBucketTaggingInput {
+        s.Tagging = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketTaggingOutput
+type PutBucketTaggingOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutBucketTaggingOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketTaggingOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketVersioningRequest
+type PutBucketVersioningInput struct {
+        _ struct{} `type:"structure" payload:"VersioningConfiguration"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // The concatenation of the authentication device's serial number, a space,
+        // and the value that is displayed on your authentication device.
+        MFA *string `location:"header" locationName:"x-amz-mfa" type:"string"`
+
+        // VersioningConfiguration is a required field
+        VersioningConfiguration *VersioningConfiguration `locationName:"VersioningConfiguration" type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s PutBucketVersioningInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketVersioningInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutBucketVersioningInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "PutBucketVersioningInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.VersioningConfiguration == nil {
+                invalidParams.Add(request.NewErrParamRequired("VersioningConfiguration"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *PutBucketVersioningInput) SetBucket(v string) *PutBucketVersioningInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetMFA sets the MFA field's value.
+func (s *PutBucketVersioningInput) SetMFA(v string) *PutBucketVersioningInput {
+        s.MFA = &v
+        return s
+}
+
+// SetVersioningConfiguration sets the VersioningConfiguration field's value.
+func (s *PutBucketVersioningInput) SetVersioningConfiguration(v *VersioningConfiguration) *PutBucketVersioningInput {
+        s.VersioningConfiguration = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketVersioningOutput
+type PutBucketVersioningOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutBucketVersioningOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketVersioningOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketWebsiteRequest
+type PutBucketWebsiteInput struct {
+        _ struct{} `type:"structure" payload:"WebsiteConfiguration"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // WebsiteConfiguration is a required field
+        WebsiteConfiguration *WebsiteConfiguration `locationName:"WebsiteConfiguration" type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s PutBucketWebsiteInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketWebsiteInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutBucketWebsiteInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "PutBucketWebsiteInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.WebsiteConfiguration == nil {
+                invalidParams.Add(request.NewErrParamRequired("WebsiteConfiguration"))
+        }
+        if s.WebsiteConfiguration != nil {
+                if err := s.WebsiteConfiguration.Validate(); err != nil {
+                        invalidParams.AddNested("WebsiteConfiguration", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *PutBucketWebsiteInput) SetBucket(v string) *PutBucketWebsiteInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetWebsiteConfiguration sets the WebsiteConfiguration field's value.
+func (s *PutBucketWebsiteInput) SetWebsiteConfiguration(v *WebsiteConfiguration) *PutBucketWebsiteInput {
+        s.WebsiteConfiguration = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketWebsiteOutput
+type PutBucketWebsiteOutput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutBucketWebsiteOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutBucketWebsiteOutput) GoString() string {
+        return s.String()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObjectAclRequest
+type PutObjectAclInput struct {
+        _ struct{} `type:"structure" payload:"AccessControlPolicy"`
+
+        // The canned ACL to apply to the object.
+        ACL *string `location:"header" locationName:"x-amz-acl" type:"string" enum:"ObjectCannedACL"`
+
+        AccessControlPolicy *AccessControlPolicy `locationName:"AccessControlPolicy" type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Allows grantee the read, write, read ACP, and write ACP permissions on the
+        // bucket.
+        GrantFullControl *string `location:"header" locationName:"x-amz-grant-full-control" type:"string"`
+
+        // Allows grantee to list the objects in the bucket.
+        GrantRead *string `location:"header" locationName:"x-amz-grant-read" type:"string"`
+
+        // Allows grantee to read the bucket ACL.
+        GrantReadACP *string `location:"header" locationName:"x-amz-grant-read-acp" type:"string"`
+
+        // Allows grantee to create, overwrite, and delete any object in the bucket.
+        GrantWrite *string `location:"header" locationName:"x-amz-grant-write" type:"string"`
+
+        // Allows grantee to write the ACL for the applicable bucket.
+        GrantWriteACP *string `location:"header" locationName:"x-amz-grant-write-acp" type:"string"`
+
+        // Key is a required field
+        Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`
+
+        // Confirms that the requester knows that she or he will be charged for the
+        // request. Bucket owners need not specify this parameter in their requests.
+        // Documentation on downloading objects from requester pays buckets can be found
+        // at http://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html
+        RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string" enum:"RequestPayer"`
+
+        // VersionId used to reference a specific version of the object.
+        VersionId *string `location:"querystring" locationName:"versionId" type:"string"`
+}
+
+// String returns the string representation
+func (s PutObjectAclInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutObjectAclInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutObjectAclInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "PutObjectAclInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+        if s.AccessControlPolicy != nil {
+                if err := s.AccessControlPolicy.Validate(); err != nil {
+                        invalidParams.AddNested("AccessControlPolicy", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetACL sets the ACL field's value.
+func (s *PutObjectAclInput) SetACL(v string) *PutObjectAclInput {
+        s.ACL = &v
+        return s
+}
+
+// SetAccessControlPolicy sets the AccessControlPolicy field's value.
+func (s *PutObjectAclInput) SetAccessControlPolicy(v *AccessControlPolicy) *PutObjectAclInput {
+        s.AccessControlPolicy = v
+        return s
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *PutObjectAclInput) SetBucket(v string) *PutObjectAclInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetGrantFullControl sets the GrantFullControl field's value.
+func (s *PutObjectAclInput) SetGrantFullControl(v string) *PutObjectAclInput {
+        s.GrantFullControl = &v
+        return s
+}
+
+// SetGrantRead sets the GrantRead field's value.
+func (s *PutObjectAclInput) SetGrantRead(v string) *PutObjectAclInput {
+        s.GrantRead = &v
+        return s
+}
+
+// SetGrantReadACP sets the GrantReadACP field's value.
+func (s *PutObjectAclInput) SetGrantReadACP(v string) *PutObjectAclInput {
+        s.GrantReadACP = &v
+        return s
+}
+
+// SetGrantWrite sets the GrantWrite field's value.
+func (s *PutObjectAclInput) SetGrantWrite(v string) *PutObjectAclInput {
+        s.GrantWrite = &v
+        return s
+}
+
+// SetGrantWriteACP sets the GrantWriteACP field's value.
+func (s *PutObjectAclInput) SetGrantWriteACP(v string) *PutObjectAclInput {
+        s.GrantWriteACP = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *PutObjectAclInput) SetKey(v string) *PutObjectAclInput {
+        s.Key = &v
+        return s
+}
+
+// SetRequestPayer sets the RequestPayer field's value.
+func (s *PutObjectAclInput) SetRequestPayer(v string) *PutObjectAclInput {
+        s.RequestPayer = &v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *PutObjectAclInput) SetVersionId(v string) *PutObjectAclInput {
+        s.VersionId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObjectAclOutput
+type PutObjectAclOutput struct {
+        _ struct{} `type:"structure"`
+
+        // If present, indicates that the requester was successfully charged for the
+        // request.
+        RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`
+}
+
+// String returns the string representation
+func (s PutObjectAclOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutObjectAclOutput) GoString() string {
+        return s.String()
+}
+
+// SetRequestCharged sets the RequestCharged field's value.
+func (s *PutObjectAclOutput) SetRequestCharged(v string) *PutObjectAclOutput {
+        s.RequestCharged = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObjectRequest
+type PutObjectInput struct {
+        _ struct{} `type:"structure" payload:"Body"`
+
+        // The canned ACL to apply to the object.
+        ACL *string `location:"header" locationName:"x-amz-acl" type:"string" enum:"ObjectCannedACL"`
+
+        // Object data.
+        Body io.ReadSeeker `type:"blob"`
+
+        // Name of the bucket to which the PUT operation was initiated.
+        //
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Specifies caching behavior along the request/reply chain.
+        CacheControl *string `location:"header" locationName:"Cache-Control" type:"string"`
+
+        // Specifies presentational information for the object.
+        ContentDisposition *string `location:"header" locationName:"Content-Disposition" type:"string"`
+
+        // Specifies what content encodings have been applied to the object and thus
+        // what decoding mechanisms must be applied to obtain the media-type referenced
+        // by the Content-Type header field.
+        ContentEncoding *string `location:"header" locationName:"Content-Encoding" type:"string"`
+
+        // The language the content is in.
+        ContentLanguage *string `location:"header" locationName:"Content-Language" type:"string"`
+
+        // Size of the body in bytes. This parameter is useful when the size of the
+        // body cannot be determined automatically.
+        ContentLength *int64 `location:"header" locationName:"Content-Length" type:"long"`
+
+        // A standard MIME type describing the format of the object data.
+        ContentType *string `location:"header" locationName:"Content-Type" type:"string"`
+
+        // The date and time at which the object is no longer cacheable.
+        Expires *time.Time `location:"header" locationName:"Expires" type:"timestamp" timestampFormat:"rfc822"`
+
+        // Gives the grantee READ, READ_ACP, and WRITE_ACP permissions on the object.
+        GrantFullControl *string `location:"header" locationName:"x-amz-grant-full-control" type:"string"`
+
+        // Allows grantee to read the object data and its metadata.
+        GrantRead *string `location:"header" locationName:"x-amz-grant-read" type:"string"`
+
+        // Allows grantee to read the object ACL.
+        GrantReadACP *string `location:"header" locationName:"x-amz-grant-read-acp" type:"string"`
+
+        // Allows grantee to write the ACL for the applicable object.
+        GrantWriteACP *string `location:"header" locationName:"x-amz-grant-write-acp" type:"string"`
+
+        // Object key for which the PUT operation was initiated.
+        //
+        // Key is a required field
+        Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`
+
+        // A map of metadata to store with the object in S3.
+        Metadata map[string]*string `location:"headers" locationName:"x-amz-meta-" type:"map"`
+
+        // Confirms that the requester knows that she or he will be charged for the
+        // request. Bucket owners need not specify this parameter in their requests.
+        // Documentation on downloading objects from requester pays buckets can be found
+        // at http://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html
+        RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string" enum:"RequestPayer"`
+
+        // Specifies the algorithm to use to when encrypting the object (e.g., AES256).
+        SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`
+
+        // Specifies the customer-provided encryption key for Amazon S3 to use in encrypting
+        // data. This value is used to store the object and then it is discarded; Amazon
+        // does not store the encryption key. The key must be appropriate for use with
+        // the algorithm specified in the x-amz-server-side​-encryption​-customer-algorithm
+        // header.
+        SSECustomerKey *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key" type:"string"`
+
+        // Specifies the 128-bit MD5 digest of the encryption key according to RFC 1321.
+        // Amazon S3 uses this header for a message integrity check to ensure the encryption
+        // key was transmitted without error.
+        SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`
+
+        // Specifies the AWS KMS key ID to use for object encryption. All GET and PUT
+        // requests for an object protected by AWS KMS will fail if not made via SSL
+        // or using SigV4. Documentation on configuring any of the officially supported
+        // AWS SDKs and CLI can be found at http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingAWSSDK.html#specify-signature-version
+        SSEKMSKeyId *string `location:"header" locationName:"x-amz-server-side-encryption-aws-kms-key-id" type:"string"`
+
+        // The Server-side encryption algorithm used when storing this object in S3
+        // (e.g., AES256, aws:kms).
+        ServerSideEncryption *string `location:"header" locationName:"x-amz-server-side-encryption" type:"string" enum:"ServerSideEncryption"`
+
+        // The type of storage to use for the object. Defaults to 'STANDARD'.
+        StorageClass *string `location:"header" locationName:"x-amz-storage-class" type:"string" enum:"StorageClass"`
+
+        // The tag-set for the object. The tag-set must be encoded as URL Query parameters
+        Tagging *string `location:"header" locationName:"x-amz-tagging" type:"string"`
+
+        // If the bucket is configured as a website, redirects requests for this object
+        // to another object in the same bucket or to an external URL. Amazon S3 stores
+        // the value of this header in the object metadata.
+        WebsiteRedirectLocation *string `location:"header" locationName:"x-amz-website-redirect-location" type:"string"`
+}
+
+// String returns the string representation
+func (s PutObjectInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutObjectInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutObjectInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "PutObjectInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetACL sets the ACL field's value.
+func (s *PutObjectInput) SetACL(v string) *PutObjectInput {
+        s.ACL = &v
+        return s
+}
+
+// SetBody sets the Body field's value.
+func (s *PutObjectInput) SetBody(v io.ReadSeeker) *PutObjectInput {
+        s.Body = v
+        return s
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *PutObjectInput) SetBucket(v string) *PutObjectInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetCacheControl sets the CacheControl field's value.
+func (s *PutObjectInput) SetCacheControl(v string) *PutObjectInput {
+        s.CacheControl = &v
+        return s
+}
+
+// SetContentDisposition sets the ContentDisposition field's value.
+func (s *PutObjectInput) SetContentDisposition(v string) *PutObjectInput {
+        s.ContentDisposition = &v
+        return s
+}
+
+// SetContentEncoding sets the ContentEncoding field's value.
+func (s *PutObjectInput) SetContentEncoding(v string) *PutObjectInput {
+        s.ContentEncoding = &v
+        return s
+}
+
+// SetContentLanguage sets the ContentLanguage field's value.
+func (s *PutObjectInput) SetContentLanguage(v string) *PutObjectInput {
+        s.ContentLanguage = &v
+        return s
+}
+
+// SetContentLength sets the ContentLength field's value.
+func (s *PutObjectInput) SetContentLength(v int64) *PutObjectInput {
+        s.ContentLength = &v
+        return s
+}
+
+// SetContentType sets the ContentType field's value.
+func (s *PutObjectInput) SetContentType(v string) *PutObjectInput {
+        s.ContentType = &v
+        return s
+}
+
+// SetExpires sets the Expires field's value.
+func (s *PutObjectInput) SetExpires(v time.Time) *PutObjectInput {
+        s.Expires = &v
+        return s
+}
+
+// SetGrantFullControl sets the GrantFullControl field's value.
+func (s *PutObjectInput) SetGrantFullControl(v string) *PutObjectInput {
+        s.GrantFullControl = &v
+        return s
+}
+
+// SetGrantRead sets the GrantRead field's value.
+func (s *PutObjectInput) SetGrantRead(v string) *PutObjectInput {
+        s.GrantRead = &v
+        return s
+}
+
+// SetGrantReadACP sets the GrantReadACP field's value.
+func (s *PutObjectInput) SetGrantReadACP(v string) *PutObjectInput {
+        s.GrantReadACP = &v
+        return s
+}
+
+// SetGrantWriteACP sets the GrantWriteACP field's value.
+func (s *PutObjectInput) SetGrantWriteACP(v string) *PutObjectInput {
+        s.GrantWriteACP = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *PutObjectInput) SetKey(v string) *PutObjectInput {
+        s.Key = &v
+        return s
+}
+
+// SetMetadata sets the Metadata field's value.
+func (s *PutObjectInput) SetMetadata(v map[string]*string) *PutObjectInput {
+        s.Metadata = v
+        return s
+}
+
+// SetRequestPayer sets the RequestPayer field's value.
+func (s *PutObjectInput) SetRequestPayer(v string) *PutObjectInput {
+        s.RequestPayer = &v
+        return s
+}
+
+// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.
+func (s *PutObjectInput) SetSSECustomerAlgorithm(v string) *PutObjectInput {
+        s.SSECustomerAlgorithm = &v
+        return s
+}
+
+// SetSSECustomerKey sets the SSECustomerKey field's value.
+func (s *PutObjectInput) SetSSECustomerKey(v string) *PutObjectInput {
+        s.SSECustomerKey = &v
+        return s
+}
+
+// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.
+func (s *PutObjectInput) SetSSECustomerKeyMD5(v string) *PutObjectInput {
+        s.SSECustomerKeyMD5 = &v
+        return s
+}
+
+// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.
+func (s *PutObjectInput) SetSSEKMSKeyId(v string) *PutObjectInput {
+        s.SSEKMSKeyId = &v
+        return s
+}
+
+// SetServerSideEncryption sets the ServerSideEncryption field's value.
+func (s *PutObjectInput) SetServerSideEncryption(v string) *PutObjectInput {
+        s.ServerSideEncryption = &v
+        return s
+}
+
+// SetStorageClass sets the StorageClass field's value.
+func (s *PutObjectInput) SetStorageClass(v string) *PutObjectInput {
+        s.StorageClass = &v
+        return s
+}
+
+// SetTagging sets the Tagging field's value.
+func (s *PutObjectInput) SetTagging(v string) *PutObjectInput {
+        s.Tagging = &v
+        return s
+}
+
+// SetWebsiteRedirectLocation sets the WebsiteRedirectLocation field's value.
+func (s *PutObjectInput) SetWebsiteRedirectLocation(v string) *PutObjectInput {
+        s.WebsiteRedirectLocation = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObjectOutput
+type PutObjectOutput struct {
+        _ struct{} `type:"structure"`
+
+        // Entity tag for the uploaded object.
+        ETag *string `location:"header" locationName:"ETag" type:"string"`
+
+        // If the object expiration is configured, this will contain the expiration
+        // date (expiry-date) and rule ID (rule-id). The value of rule-id is URL encoded.
+        Expiration *string `location:"header" locationName:"x-amz-expiration" type:"string"`
+
+        // If present, indicates that the requester was successfully charged for the
+        // request.
+        RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`
+
+        // If server-side encryption with a customer-provided encryption key was requested,
+        // the response will include this header confirming the encryption algorithm
+        // used.
+        SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`
+
+        // If server-side encryption with a customer-provided encryption key was requested,
+        // the response will include this header to provide round trip message integrity
+        // verification of the customer-provided encryption key.
+        SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`
+
+        // If present, specifies the ID of the AWS Key Management Service (KMS) master
+        // encryption key that was used for the object.
+        SSEKMSKeyId *string `location:"header" locationName:"x-amz-server-side-encryption-aws-kms-key-id" type:"string"`
+
+        // The Server-side encryption algorithm used when storing this object in S3
+        // (e.g., AES256, aws:kms).
+        ServerSideEncryption *string `location:"header" locationName:"x-amz-server-side-encryption" type:"string" enum:"ServerSideEncryption"`
+
+        // Version of the object.
+        VersionId *string `location:"header" locationName:"x-amz-version-id" type:"string"`
+}
+
+// String returns the string representation
+func (s PutObjectOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutObjectOutput) GoString() string {
+        return s.String()
+}
+
+// SetETag sets the ETag field's value.
+func (s *PutObjectOutput) SetETag(v string) *PutObjectOutput {
+        s.ETag = &v
+        return s
+}
+
+// SetExpiration sets the Expiration field's value.
+func (s *PutObjectOutput) SetExpiration(v string) *PutObjectOutput {
+        s.Expiration = &v
+        return s
+}
+
+// SetRequestCharged sets the RequestCharged field's value.
+func (s *PutObjectOutput) SetRequestCharged(v string) *PutObjectOutput {
+        s.RequestCharged = &v
+        return s
+}
+
+// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.
+func (s *PutObjectOutput) SetSSECustomerAlgorithm(v string) *PutObjectOutput {
+        s.SSECustomerAlgorithm = &v
+        return s
+}
+
+// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.
+func (s *PutObjectOutput) SetSSECustomerKeyMD5(v string) *PutObjectOutput {
+        s.SSECustomerKeyMD5 = &v
+        return s
+}
+
+// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.
+func (s *PutObjectOutput) SetSSEKMSKeyId(v string) *PutObjectOutput {
+        s.SSEKMSKeyId = &v
+        return s
+}
+
+// SetServerSideEncryption sets the ServerSideEncryption field's value.
+func (s *PutObjectOutput) SetServerSideEncryption(v string) *PutObjectOutput {
+        s.ServerSideEncryption = &v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *PutObjectOutput) SetVersionId(v string) *PutObjectOutput {
+        s.VersionId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObjectTaggingRequest
+type PutObjectTaggingInput struct {
+        _ struct{} `type:"structure" payload:"Tagging"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Key is a required field
+        Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`
+
+        // Tagging is a required field
+        Tagging *Tagging `locationName:"Tagging" type:"structure" required:"true"`
+
+        VersionId *string `location:"querystring" locationName:"versionId" type:"string"`
+}
+
+// String returns the string representation
+func (s PutObjectTaggingInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutObjectTaggingInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutObjectTaggingInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "PutObjectTaggingInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+        if s.Tagging == nil {
+                invalidParams.Add(request.NewErrParamRequired("Tagging"))
+        }
+        if s.Tagging != nil {
+                if err := s.Tagging.Validate(); err != nil {
+                        invalidParams.AddNested("Tagging", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *PutObjectTaggingInput) SetBucket(v string) *PutObjectTaggingInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *PutObjectTaggingInput) SetKey(v string) *PutObjectTaggingInput {
+        s.Key = &v
+        return s
+}
+
+// SetTagging sets the Tagging field's value.
+func (s *PutObjectTaggingInput) SetTagging(v *Tagging) *PutObjectTaggingInput {
+        s.Tagging = v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *PutObjectTaggingInput) SetVersionId(v string) *PutObjectTaggingInput {
+        s.VersionId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObjectTaggingOutput
+type PutObjectTaggingOutput struct {
+        _ struct{} `type:"structure"`
+
+        VersionId *string `location:"header" locationName:"x-amz-version-id" type:"string"`
+}
+
+// String returns the string representation
+func (s PutObjectTaggingOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutObjectTaggingOutput) GoString() string {
+        return s.String()
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *PutObjectTaggingOutput) SetVersionId(v string) *PutObjectTaggingOutput {
+        s.VersionId = &v
+        return s
+}
+
+// Container for specifying an configuration when you want Amazon S3 to publish
+// events to an Amazon Simple Queue Service (Amazon SQS) queue.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/QueueConfiguration
+type QueueConfiguration struct {
+        _ struct{} `type:"structure"`
+
+        // Events is a required field
+        Events []*string `locationName:"Event" type:"list" flattened:"true" required:"true"`
+
+        // Container for object key name filtering rules. For information about key
+        // name filtering, go to Configuring Event Notifications (http://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html)
+        Filter *NotificationConfigurationFilter `type:"structure"`
+
+        // Optional unique identifier for configurations in a notification configuration.
+        // If you don't provide one, Amazon S3 will assign an ID.
+        Id *string `type:"string"`
+
+        // Amazon SQS queue ARN to which Amazon S3 will publish a message when it detects
+        // events of specified type.
+        //
+        // QueueArn is a required field
+        QueueArn *string `locationName:"Queue" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s QueueConfiguration) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s QueueConfiguration) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *QueueConfiguration) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "QueueConfiguration"}
+        if s.Events == nil {
+                invalidParams.Add(request.NewErrParamRequired("Events"))
+        }
+        if s.QueueArn == nil {
+                invalidParams.Add(request.NewErrParamRequired("QueueArn"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetEvents sets the Events field's value.
+func (s *QueueConfiguration) SetEvents(v []*string) *QueueConfiguration {
+        s.Events = v
+        return s
+}
+
+// SetFilter sets the Filter field's value.
+func (s *QueueConfiguration) SetFilter(v *NotificationConfigurationFilter) *QueueConfiguration {
+        s.Filter = v
+        return s
+}
+
+// SetId sets the Id field's value.
+func (s *QueueConfiguration) SetId(v string) *QueueConfiguration {
+        s.Id = &v
+        return s
+}
+
+// SetQueueArn sets the QueueArn field's value.
+func (s *QueueConfiguration) SetQueueArn(v string) *QueueConfiguration {
+        s.QueueArn = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/QueueConfigurationDeprecated
+type QueueConfigurationDeprecated struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket event for which to send notifications.
+        Event *string `deprecated:"true" type:"string" enum:"Event"`
+
+        Events []*string `locationName:"Event" type:"list" flattened:"true"`
+
+        // Optional unique identifier for configurations in a notification configuration.
+        // If you don't provide one, Amazon S3 will assign an ID.
+        Id *string `type:"string"`
+
+        Queue *string `type:"string"`
+}
+
+// String returns the string representation
+func (s QueueConfigurationDeprecated) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s QueueConfigurationDeprecated) GoString() string {
+        return s.String()
+}
+
+// SetEvent sets the Event field's value.
+func (s *QueueConfigurationDeprecated) SetEvent(v string) *QueueConfigurationDeprecated {
+        s.Event = &v
+        return s
+}
+
+// SetEvents sets the Events field's value.
+func (s *QueueConfigurationDeprecated) SetEvents(v []*string) *QueueConfigurationDeprecated {
+        s.Events = v
+        return s
+}
+
+// SetId sets the Id field's value.
+func (s *QueueConfigurationDeprecated) SetId(v string) *QueueConfigurationDeprecated {
+        s.Id = &v
+        return s
+}
+
+// SetQueue sets the Queue field's value.
+func (s *QueueConfigurationDeprecated) SetQueue(v string) *QueueConfigurationDeprecated {
+        s.Queue = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Redirect
+type Redirect struct {
+        _ struct{} `type:"structure"`
+
+        // The host name to use in the redirect request.
+        HostName *string `type:"string"`
+
+        // The HTTP redirect code to use on the response. Not required if one of the
+        // siblings is present.
+        HttpRedirectCode *string `type:"string"`
+
+        // Protocol to use (http, https) when redirecting requests. The default is the
+        // protocol that is used in the original request.
+        Protocol *string `type:"string" enum:"Protocol"`
+
+        // The object key prefix to use in the redirect request. For example, to redirect
+        // requests for all pages with prefix docs/ (objects in the docs/ folder) to
+        // documents/, you can set a condition block with KeyPrefixEquals set to docs/
+        // and in the Redirect set ReplaceKeyPrefixWith to /documents. Not required
+        // if one of the siblings is present. Can be present only if ReplaceKeyWith
+        // is not provided.
+        ReplaceKeyPrefixWith *string `type:"string"`
+
+        // The specific object key to use in the redirect request. For example, redirect
+        // request to error.html. Not required if one of the sibling is present. Can
+        // be present only if ReplaceKeyPrefixWith is not provided.
+        ReplaceKeyWith *string `type:"string"`
+}
+
+// String returns the string representation
+func (s Redirect) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Redirect) GoString() string {
+        return s.String()
+}
+
+// SetHostName sets the HostName field's value.
+func (s *Redirect) SetHostName(v string) *Redirect {
+        s.HostName = &v
+        return s
+}
+
+// SetHttpRedirectCode sets the HttpRedirectCode field's value.
+func (s *Redirect) SetHttpRedirectCode(v string) *Redirect {
+        s.HttpRedirectCode = &v
+        return s
+}
+
+// SetProtocol sets the Protocol field's value.
+func (s *Redirect) SetProtocol(v string) *Redirect {
+        s.Protocol = &v
+        return s
+}
+
+// SetReplaceKeyPrefixWith sets the ReplaceKeyPrefixWith field's value.
+func (s *Redirect) SetReplaceKeyPrefixWith(v string) *Redirect {
+        s.ReplaceKeyPrefixWith = &v
+        return s
+}
+
+// SetReplaceKeyWith sets the ReplaceKeyWith field's value.
+func (s *Redirect) SetReplaceKeyWith(v string) *Redirect {
+        s.ReplaceKeyWith = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/RedirectAllRequestsTo
+type RedirectAllRequestsTo struct {
+        _ struct{} `type:"structure"`
+
+        // Name of the host where requests will be redirected.
+        //
+        // HostName is a required field
+        HostName *string `type:"string" required:"true"`
+
+        // Protocol to use (http, https) when redirecting requests. The default is the
+        // protocol that is used in the original request.
+        Protocol *string `type:"string" enum:"Protocol"`
+}
+
+// String returns the string representation
+func (s RedirectAllRequestsTo) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RedirectAllRequestsTo) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *RedirectAllRequestsTo) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "RedirectAllRequestsTo"}
+        if s.HostName == nil {
+                invalidParams.Add(request.NewErrParamRequired("HostName"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetHostName sets the HostName field's value.
+func (s *RedirectAllRequestsTo) SetHostName(v string) *RedirectAllRequestsTo {
+        s.HostName = &v
+        return s
+}
+
+// SetProtocol sets the Protocol field's value.
+func (s *RedirectAllRequestsTo) SetProtocol(v string) *RedirectAllRequestsTo {
+        s.Protocol = &v
+        return s
+}
+
+// Container for replication rules. You can add as many as 1,000 rules. Total
+// replication configuration size can be up to 2 MB.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ReplicationConfiguration
+type ReplicationConfiguration struct {
+        _ struct{} `type:"structure"`
+
+        // Amazon Resource Name (ARN) of an IAM role for Amazon S3 to assume when replicating
+        // the objects.
+        //
+        // Role is a required field
+        Role *string `type:"string" required:"true"`
+
+        // Container for information about a particular replication rule. Replication
+        // configuration must have at least one rule and can contain up to 1,000 rules.
+        //
+        // Rules is a required field
+        Rules []*ReplicationRule `locationName:"Rule" type:"list" flattened:"true" required:"true"`
+}
+
+// String returns the string representation
+func (s ReplicationConfiguration) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReplicationConfiguration) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ReplicationConfiguration) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "ReplicationConfiguration"}
+        if s.Role == nil {
+                invalidParams.Add(request.NewErrParamRequired("Role"))
+        }
+        if s.Rules == nil {
+                invalidParams.Add(request.NewErrParamRequired("Rules"))
+        }
+        if s.Rules != nil {
+                for i, v := range s.Rules {
+                        if v == nil {
+                                continue
+                        }
+                        if err := v.Validate(); err != nil {
+                                invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Rules", i), err.(request.ErrInvalidParams))
+                        }
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetRole sets the Role field's value.
+func (s *ReplicationConfiguration) SetRole(v string) *ReplicationConfiguration {
+        s.Role = &v
+        return s
+}
+
+// SetRules sets the Rules field's value.
+func (s *ReplicationConfiguration) SetRules(v []*ReplicationRule) *ReplicationConfiguration {
+        s.Rules = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ReplicationRule
+type ReplicationRule struct {
+        _ struct{} `type:"structure"`
+
+        // Destination is a required field
+        Destination *Destination `type:"structure" required:"true"`
+
+        // Unique identifier for the rule. The value cannot be longer than 255 characters.
+        ID *string `type:"string"`
+
+        // Object keyname prefix identifying one or more objects to which the rule applies.
+        // Maximum prefix length can be up to 1,024 characters. Overlapping prefixes
+        // are not supported.
+        //
+        // Prefix is a required field
+        Prefix *string `type:"string" required:"true"`
+
+        // The rule is ignored if status is not Enabled.
+        //
+        // Status is a required field
+        Status *string `type:"string" required:"true" enum:"ReplicationRuleStatus"`
+}
+
+// String returns the string representation
+func (s ReplicationRule) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ReplicationRule) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ReplicationRule) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "ReplicationRule"}
+        if s.Destination == nil {
+                invalidParams.Add(request.NewErrParamRequired("Destination"))
+        }
+        if s.Prefix == nil {
+                invalidParams.Add(request.NewErrParamRequired("Prefix"))
+        }
+        if s.Status == nil {
+                invalidParams.Add(request.NewErrParamRequired("Status"))
+        }
+        if s.Destination != nil {
+                if err := s.Destination.Validate(); err != nil {
+                        invalidParams.AddNested("Destination", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetDestination sets the Destination field's value.
+func (s *ReplicationRule) SetDestination(v *Destination) *ReplicationRule {
+        s.Destination = v
+        return s
+}
+
+// SetID sets the ID field's value.
+func (s *ReplicationRule) SetID(v string) *ReplicationRule {
+        s.ID = &v
+        return s
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *ReplicationRule) SetPrefix(v string) *ReplicationRule {
+        s.Prefix = &v
+        return s
+}
+
+// SetStatus sets the Status field's value.
+func (s *ReplicationRule) SetStatus(v string) *ReplicationRule {
+        s.Status = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/RequestPaymentConfiguration
+type RequestPaymentConfiguration struct {
+        _ struct{} `type:"structure"`
+
+        // Specifies who pays for the download and request fees.
+        //
+        // Payer is a required field
+        Payer *string `type:"string" required:"true" enum:"Payer"`
+}
+
+// String returns the string representation
+func (s RequestPaymentConfiguration) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RequestPaymentConfiguration) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *RequestPaymentConfiguration) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "RequestPaymentConfiguration"}
+        if s.Payer == nil {
+                invalidParams.Add(request.NewErrParamRequired("Payer"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetPayer sets the Payer field's value.
+func (s *RequestPaymentConfiguration) SetPayer(v string) *RequestPaymentConfiguration {
+        s.Payer = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/RestoreObjectRequest
+type RestoreObjectInput struct {
+        _ struct{} `type:"structure" payload:"RestoreRequest"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Key is a required field
+        Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`
+
+        // Confirms that the requester knows that she or he will be charged for the
+        // request. Bucket owners need not specify this parameter in their requests.
+        // Documentation on downloading objects from requester pays buckets can be found
+        // at http://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html
+        RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string" enum:"RequestPayer"`
+
+        RestoreRequest *RestoreRequest `locationName:"RestoreRequest" type:"structure"`
+
+        VersionId *string `location:"querystring" locationName:"versionId" type:"string"`
+}
+
+// String returns the string representation
+func (s RestoreObjectInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RestoreObjectInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *RestoreObjectInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "RestoreObjectInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+        if s.RestoreRequest != nil {
+                if err := s.RestoreRequest.Validate(); err != nil {
+                        invalidParams.AddNested("RestoreRequest", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *RestoreObjectInput) SetBucket(v string) *RestoreObjectInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *RestoreObjectInput) SetKey(v string) *RestoreObjectInput {
+        s.Key = &v
+        return s
+}
+
+// SetRequestPayer sets the RequestPayer field's value.
+func (s *RestoreObjectInput) SetRequestPayer(v string) *RestoreObjectInput {
+        s.RequestPayer = &v
+        return s
+}
+
+// SetRestoreRequest sets the RestoreRequest field's value.
+func (s *RestoreObjectInput) SetRestoreRequest(v *RestoreRequest) *RestoreObjectInput {
+        s.RestoreRequest = v
+        return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *RestoreObjectInput) SetVersionId(v string) *RestoreObjectInput {
+        s.VersionId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/RestoreObjectOutput
+type RestoreObjectOutput struct {
+        _ struct{} `type:"structure"`
+
+        // If present, indicates that the requester was successfully charged for the
+        // request.
+        RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`
+}
+
+// String returns the string representation
+func (s RestoreObjectOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RestoreObjectOutput) GoString() string {
+        return s.String()
+}
+
+// SetRequestCharged sets the RequestCharged field's value.
+func (s *RestoreObjectOutput) SetRequestCharged(v string) *RestoreObjectOutput {
+        s.RequestCharged = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/RestoreRequest
+type RestoreRequest struct {
+        _ struct{} `type:"structure"`
+
+        // Lifetime of the active copy in days
+        //
+        // Days is a required field
+        Days *int64 `type:"integer" required:"true"`
+
+        // Glacier related prameters pertaining to this job.
+        GlacierJobParameters *GlacierJobParameters `type:"structure"`
+}
+
+// String returns the string representation
+func (s RestoreRequest) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RestoreRequest) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *RestoreRequest) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "RestoreRequest"}
+        if s.Days == nil {
+                invalidParams.Add(request.NewErrParamRequired("Days"))
+        }
+        if s.GlacierJobParameters != nil {
+                if err := s.GlacierJobParameters.Validate(); err != nil {
+                        invalidParams.AddNested("GlacierJobParameters", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetDays sets the Days field's value.
+func (s *RestoreRequest) SetDays(v int64) *RestoreRequest {
+        s.Days = &v
+        return s
+}
+
+// SetGlacierJobParameters sets the GlacierJobParameters field's value.
+func (s *RestoreRequest) SetGlacierJobParameters(v *GlacierJobParameters) *RestoreRequest {
+        s.GlacierJobParameters = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/RoutingRule
+type RoutingRule struct {
+        _ struct{} `type:"structure"`
+
+        // A container for describing a condition that must be met for the specified
+        // redirect to apply. For example, 1. If request is for pages in the /docs folder,
+        // redirect to the /documents folder. 2. If request results in HTTP error 4xx,
+        // redirect request to another host where you might process the error.
+        Condition *Condition `type:"structure"`
+
+        // Container for redirect information. You can redirect requests to another
+        // host, to another page, or with another protocol. In the event of an error,
+        // you can can specify a different error code to return.
+        //
+        // Redirect is a required field
+        Redirect *Redirect `type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s RoutingRule) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RoutingRule) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *RoutingRule) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "RoutingRule"}
+        if s.Redirect == nil {
+                invalidParams.Add(request.NewErrParamRequired("Redirect"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetCondition sets the Condition field's value.
+func (s *RoutingRule) SetCondition(v *Condition) *RoutingRule {
+        s.Condition = v
+        return s
+}
+
+// SetRedirect sets the Redirect field's value.
+func (s *RoutingRule) SetRedirect(v *Redirect) *RoutingRule {
+        s.Redirect = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Rule
+type Rule struct {
+        _ struct{} `type:"structure"`
+
+        // Specifies the days since the initiation of an Incomplete Multipart Upload
+        // that Lifecycle will wait before permanently removing all parts of the upload.
+        AbortIncompleteMultipartUpload *AbortIncompleteMultipartUpload `type:"structure"`
+
+        Expiration *LifecycleExpiration `type:"structure"`
+
+        // Unique identifier for the rule. The value cannot be longer than 255 characters.
+        ID *string `type:"string"`
+
+        // Specifies when noncurrent object versions expire. Upon expiration, Amazon
+        // S3 permanently deletes the noncurrent object versions. You set this lifecycle
+        // configuration action on a bucket that has versioning enabled (or suspended)
+        // to request that Amazon S3 delete noncurrent object versions at a specific
+        // period in the object's lifetime.
+        NoncurrentVersionExpiration *NoncurrentVersionExpiration `type:"structure"`
+
+        // Container for the transition rule that describes when noncurrent objects
+        // transition to the STANDARD_IA or GLACIER storage class. If your bucket is
+        // versioning-enabled (or versioning is suspended), you can set this action
+        // to request that Amazon S3 transition noncurrent object versions to the STANDARD_IA
+        // or GLACIER storage class at a specific period in the object's lifetime.
+        NoncurrentVersionTransition *NoncurrentVersionTransition `type:"structure"`
+
+        // Prefix identifying one or more objects to which the rule applies.
+        //
+        // Prefix is a required field
+        Prefix *string `type:"string" required:"true"`
+
+        // If 'Enabled', the rule is currently being applied. If 'Disabled', the rule
+        // is not currently being applied.
+        //
+        // Status is a required field
+        Status *string `type:"string" required:"true" enum:"ExpirationStatus"`
+
+        Transition *Transition `type:"structure"`
+}
+
+// String returns the string representation
+func (s Rule) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Rule) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *Rule) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "Rule"}
+        if s.Prefix == nil {
+                invalidParams.Add(request.NewErrParamRequired("Prefix"))
+        }
+        if s.Status == nil {
+                invalidParams.Add(request.NewErrParamRequired("Status"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetAbortIncompleteMultipartUpload sets the AbortIncompleteMultipartUpload field's value.
+func (s *Rule) SetAbortIncompleteMultipartUpload(v *AbortIncompleteMultipartUpload) *Rule {
+        s.AbortIncompleteMultipartUpload = v
+        return s
+}
+
+// SetExpiration sets the Expiration field's value.
+func (s *Rule) SetExpiration(v *LifecycleExpiration) *Rule {
+        s.Expiration = v
+        return s
+}
+
+// SetID sets the ID field's value.
+func (s *Rule) SetID(v string) *Rule {
+        s.ID = &v
+        return s
+}
+
+// SetNoncurrentVersionExpiration sets the NoncurrentVersionExpiration field's value.
+func (s *Rule) SetNoncurrentVersionExpiration(v *NoncurrentVersionExpiration) *Rule {
+        s.NoncurrentVersionExpiration = v
+        return s
+}
+
+// SetNoncurrentVersionTransition sets the NoncurrentVersionTransition field's value.
+func (s *Rule) SetNoncurrentVersionTransition(v *NoncurrentVersionTransition) *Rule {
+        s.NoncurrentVersionTransition = v
+        return s
+}
+
+// SetPrefix sets the Prefix field's value.
+func (s *Rule) SetPrefix(v string) *Rule {
+        s.Prefix = &v
+        return s
+}
+
+// SetStatus sets the Status field's value.
+func (s *Rule) SetStatus(v string) *Rule {
+        s.Status = &v
+        return s
+}
+
+// SetTransition sets the Transition field's value.
+func (s *Rule) SetTransition(v *Transition) *Rule {
+        s.Transition = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/StorageClassAnalysis
+type StorageClassAnalysis struct {
+        _ struct{} `type:"structure"`
+
+        // A container used to describe how data related to the storage class analysis
+        // should be exported.
+        DataExport *StorageClassAnalysisDataExport `type:"structure"`
+}
+
+// String returns the string representation
+func (s StorageClassAnalysis) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s StorageClassAnalysis) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *StorageClassAnalysis) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "StorageClassAnalysis"}
+        if s.DataExport != nil {
+                if err := s.DataExport.Validate(); err != nil {
+                        invalidParams.AddNested("DataExport", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetDataExport sets the DataExport field's value.
+func (s *StorageClassAnalysis) SetDataExport(v *StorageClassAnalysisDataExport) *StorageClassAnalysis {
+        s.DataExport = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/StorageClassAnalysisDataExport
+type StorageClassAnalysisDataExport struct {
+        _ struct{} `type:"structure"`
+
+        // The place to store the data for an analysis.
+        //
+        // Destination is a required field
+        Destination *AnalyticsExportDestination `type:"structure" required:"true"`
+
+        // The version of the output schema to use when exporting data. Must be V_1.
+        //
+        // OutputSchemaVersion is a required field
+        OutputSchemaVersion *string `type:"string" required:"true" enum:"StorageClassAnalysisSchemaVersion"`
+}
+
+// String returns the string representation
+func (s StorageClassAnalysisDataExport) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s StorageClassAnalysisDataExport) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *StorageClassAnalysisDataExport) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "StorageClassAnalysisDataExport"}
+        if s.Destination == nil {
+                invalidParams.Add(request.NewErrParamRequired("Destination"))
+        }
+        if s.OutputSchemaVersion == nil {
+                invalidParams.Add(request.NewErrParamRequired("OutputSchemaVersion"))
+        }
+        if s.Destination != nil {
+                if err := s.Destination.Validate(); err != nil {
+                        invalidParams.AddNested("Destination", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetDestination sets the Destination field's value.
+func (s *StorageClassAnalysisDataExport) SetDestination(v *AnalyticsExportDestination) *StorageClassAnalysisDataExport {
+        s.Destination = v
+        return s
+}
+
+// SetOutputSchemaVersion sets the OutputSchemaVersion field's value.
+func (s *StorageClassAnalysisDataExport) SetOutputSchemaVersion(v string) *StorageClassAnalysisDataExport {
+        s.OutputSchemaVersion = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Tag
+type Tag struct {
+        _ struct{} `type:"structure"`
+
+        // Name of the tag.
+        //
+        // Key is a required field
+        Key *string `min:"1" type:"string" required:"true"`
+
+        // Value of the tag.
+        //
+        // Value is a required field
+        Value *string `type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s Tag) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Tag) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *Tag) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "Tag"}
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+        if s.Value == nil {
+                invalidParams.Add(request.NewErrParamRequired("Value"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetKey sets the Key field's value.
+func (s *Tag) SetKey(v string) *Tag {
+        s.Key = &v
+        return s
+}
+
+// SetValue sets the Value field's value.
+func (s *Tag) SetValue(v string) *Tag {
+        s.Value = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Tagging
+type Tagging struct {
+        _ struct{} `type:"structure"`
+
+        // TagSet is a required field
+        TagSet []*Tag `locationNameList:"Tag" type:"list" required:"true"`
+}
+
+// String returns the string representation
+func (s Tagging) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Tagging) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *Tagging) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "Tagging"}
+        if s.TagSet == nil {
+                invalidParams.Add(request.NewErrParamRequired("TagSet"))
+        }
+        if s.TagSet != nil {
+                for i, v := range s.TagSet {
+                        if v == nil {
+                                continue
+                        }
+                        if err := v.Validate(); err != nil {
+                                invalidParams.AddNested(fmt.Sprintf("%s[%v]", "TagSet", i), err.(request.ErrInvalidParams))
+                        }
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetTagSet sets the TagSet field's value.
+func (s *Tagging) SetTagSet(v []*Tag) *Tagging {
+        s.TagSet = v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/TargetGrant
+type TargetGrant struct {
+        _ struct{} `type:"structure"`
+
+        Grantee *Grantee `type:"structure"`
+
+        // Logging permissions assigned to the Grantee for the bucket.
+        Permission *string `type:"string" enum:"BucketLogsPermission"`
+}
+
+// String returns the string representation
+func (s TargetGrant) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s TargetGrant) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *TargetGrant) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "TargetGrant"}
+        if s.Grantee != nil {
+                if err := s.Grantee.Validate(); err != nil {
+                        invalidParams.AddNested("Grantee", err.(request.ErrInvalidParams))
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetGrantee sets the Grantee field's value.
+func (s *TargetGrant) SetGrantee(v *Grantee) *TargetGrant {
+        s.Grantee = v
+        return s
+}
+
+// SetPermission sets the Permission field's value.
+func (s *TargetGrant) SetPermission(v string) *TargetGrant {
+        s.Permission = &v
+        return s
+}
+
+// Container for specifying the configuration when you want Amazon S3 to publish
+// events to an Amazon Simple Notification Service (Amazon SNS) topic.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/TopicConfiguration
+type TopicConfiguration struct {
+        _ struct{} `type:"structure"`
+
+        // Events is a required field
+        Events []*string `locationName:"Event" type:"list" flattened:"true" required:"true"`
+
+        // Container for object key name filtering rules. For information about key
+        // name filtering, go to Configuring Event Notifications (http://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html)
+        Filter *NotificationConfigurationFilter `type:"structure"`
+
+        // Optional unique identifier for configurations in a notification configuration.
+        // If you don't provide one, Amazon S3 will assign an ID.
+        Id *string `type:"string"`
+
+        // Amazon SNS topic ARN to which Amazon S3 will publish a message when it detects
+        // events of specified type.
+        //
+        // TopicArn is a required field
+        TopicArn *string `locationName:"Topic" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s TopicConfiguration) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s TopicConfiguration) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *TopicConfiguration) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "TopicConfiguration"}
+        if s.Events == nil {
+                invalidParams.Add(request.NewErrParamRequired("Events"))
+        }
+        if s.TopicArn == nil {
+                invalidParams.Add(request.NewErrParamRequired("TopicArn"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetEvents sets the Events field's value.
+func (s *TopicConfiguration) SetEvents(v []*string) *TopicConfiguration {
+        s.Events = v
+        return s
+}
+
+// SetFilter sets the Filter field's value.
+func (s *TopicConfiguration) SetFilter(v *NotificationConfigurationFilter) *TopicConfiguration {
+        s.Filter = v
+        return s
+}
+
+// SetId sets the Id field's value.
+func (s *TopicConfiguration) SetId(v string) *TopicConfiguration {
+        s.Id = &v
+        return s
+}
+
+// SetTopicArn sets the TopicArn field's value.
+func (s *TopicConfiguration) SetTopicArn(v string) *TopicConfiguration {
+        s.TopicArn = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/TopicConfigurationDeprecated
+type TopicConfigurationDeprecated struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket event for which to send notifications.
+        Event *string `deprecated:"true" type:"string" enum:"Event"`
+
+        Events []*string `locationName:"Event" type:"list" flattened:"true"`
+
+        // Optional unique identifier for configurations in a notification configuration.
+        // If you don't provide one, Amazon S3 will assign an ID.
+        Id *string `type:"string"`
+
+        // Amazon SNS topic to which Amazon S3 will publish a message to report the
+        // specified events for the bucket.
+        Topic *string `type:"string"`
+}
+
+// String returns the string representation
+func (s TopicConfigurationDeprecated) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s TopicConfigurationDeprecated) GoString() string {
+        return s.String()
+}
+
+// SetEvent sets the Event field's value.
+func (s *TopicConfigurationDeprecated) SetEvent(v string) *TopicConfigurationDeprecated {
+        s.Event = &v
+        return s
+}
+
+// SetEvents sets the Events field's value.
+func (s *TopicConfigurationDeprecated) SetEvents(v []*string) *TopicConfigurationDeprecated {
+        s.Events = v
+        return s
+}
+
+// SetId sets the Id field's value.
+func (s *TopicConfigurationDeprecated) SetId(v string) *TopicConfigurationDeprecated {
+        s.Id = &v
+        return s
+}
+
+// SetTopic sets the Topic field's value.
+func (s *TopicConfigurationDeprecated) SetTopic(v string) *TopicConfigurationDeprecated {
+        s.Topic = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Transition
+type Transition struct {
+        _ struct{} `type:"structure"`
+
+        // Indicates at what date the object is to be moved or deleted. Should be in
+        // GMT ISO 8601 Format.
+        Date *time.Time `type:"timestamp" timestampFormat:"iso8601"`
+
+        // Indicates the lifetime, in days, of the objects that are subject to the rule.
+        // The value must be a non-zero positive integer.
+        Days *int64 `type:"integer"`
+
+        // The class of storage used to store the object.
+        StorageClass *string `type:"string" enum:"TransitionStorageClass"`
+}
+
+// String returns the string representation
+func (s Transition) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Transition) GoString() string {
+        return s.String()
+}
+
+// SetDate sets the Date field's value.
+func (s *Transition) SetDate(v time.Time) *Transition {
+        s.Date = &v
+        return s
+}
+
+// SetDays sets the Days field's value.
+func (s *Transition) SetDays(v int64) *Transition {
+        s.Days = &v
+        return s
+}
+
+// SetStorageClass sets the StorageClass field's value.
+func (s *Transition) SetStorageClass(v string) *Transition {
+        s.StorageClass = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/UploadPartCopyRequest
+type UploadPartCopyInput struct {
+        _ struct{} `type:"structure"`
+
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // The name of the source bucket and key name of the source object, separated
+        // by a slash (/). Must be URL-encoded.
+        //
+        // CopySource is a required field
+        CopySource *string `location:"header" locationName:"x-amz-copy-source" type:"string" required:"true"`
+
+        // Copies the object if its entity tag (ETag) matches the specified tag.
+        CopySourceIfMatch *string `location:"header" locationName:"x-amz-copy-source-if-match" type:"string"`
+
+        // Copies the object if it has been modified since the specified time.
+        CopySourceIfModifiedSince *time.Time `location:"header" locationName:"x-amz-copy-source-if-modified-since" type:"timestamp" timestampFormat:"rfc822"`
+
+        // Copies the object if its entity tag (ETag) is different than the specified
+        // ETag.
+        CopySourceIfNoneMatch *string `location:"header" locationName:"x-amz-copy-source-if-none-match" type:"string"`
+
+        // Copies the object if it hasn't been modified since the specified time.
+        CopySourceIfUnmodifiedSince *time.Time `location:"header" locationName:"x-amz-copy-source-if-unmodified-since" type:"timestamp" timestampFormat:"rfc822"`
+
+        // The range of bytes to copy from the source object. The range value must use
+        // the form bytes=first-last, where the first and last are the zero-based byte
+        // offsets to copy. For example, bytes=0-9 indicates that you want to copy the
+        // first ten bytes of the source. You can copy a range only if the source object
+        // is greater than 5 GB.
+        CopySourceRange *string `location:"header" locationName:"x-amz-copy-source-range" type:"string"`
+
+        // Specifies the algorithm to use when decrypting the source object (e.g., AES256).
+        CopySourceSSECustomerAlgorithm *string `location:"header" locationName:"x-amz-copy-source-server-side-encryption-customer-algorithm" type:"string"`
+
+        // Specifies the customer-provided encryption key for Amazon S3 to use to decrypt
+        // the source object. The encryption key provided in this header must be one
+        // that was used when the source object was created.
+        CopySourceSSECustomerKey *string `location:"header" locationName:"x-amz-copy-source-server-side-encryption-customer-key" type:"string"`
+
+        // Specifies the 128-bit MD5 digest of the encryption key according to RFC 1321.
+        // Amazon S3 uses this header for a message integrity check to ensure the encryption
+        // key was transmitted without error.
+        CopySourceSSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-copy-source-server-side-encryption-customer-key-MD5" type:"string"`
+
+        // Key is a required field
+        Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`
+
+        // Part number of part being copied. This is a positive integer between 1 and
+        // 10,000.
+        //
+        // PartNumber is a required field
+        PartNumber *int64 `location:"querystring" locationName:"partNumber" type:"integer" required:"true"`
+
+        // Confirms that the requester knows that she or he will be charged for the
+        // request. Bucket owners need not specify this parameter in their requests.
+        // Documentation on downloading objects from requester pays buckets can be found
+        // at http://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html
+        RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string" enum:"RequestPayer"`
+
+        // Specifies the algorithm to use to when encrypting the object (e.g., AES256).
+        SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`
+
+        // Specifies the customer-provided encryption key for Amazon S3 to use in encrypting
+        // data. This value is used to store the object and then it is discarded; Amazon
+        // does not store the encryption key. The key must be appropriate for use with
+        // the algorithm specified in the x-amz-server-side​-encryption​-customer-algorithm
+        // header. This must be the same encryption key specified in the initiate multipart
+        // upload request.
+        SSECustomerKey *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key" type:"string"`
+
+        // Specifies the 128-bit MD5 digest of the encryption key according to RFC 1321.
+        // Amazon S3 uses this header for a message integrity check to ensure the encryption
+        // key was transmitted without error.
+        SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`
+
+        // Upload ID identifying the multipart upload whose part is being copied.
+        //
+        // UploadId is a required field
+        UploadId *string `location:"querystring" locationName:"uploadId" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s UploadPartCopyInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UploadPartCopyInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UploadPartCopyInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "UploadPartCopyInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.CopySource == nil {
+                invalidParams.Add(request.NewErrParamRequired("CopySource"))
+        }
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+        if s.PartNumber == nil {
+                invalidParams.Add(request.NewErrParamRequired("PartNumber"))
+        }
+        if s.UploadId == nil {
+                invalidParams.Add(request.NewErrParamRequired("UploadId"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *UploadPartCopyInput) SetBucket(v string) *UploadPartCopyInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetCopySource sets the CopySource field's value.
+func (s *UploadPartCopyInput) SetCopySource(v string) *UploadPartCopyInput {
+        s.CopySource = &v
+        return s
+}
+
+// SetCopySourceIfMatch sets the CopySourceIfMatch field's value.
+func (s *UploadPartCopyInput) SetCopySourceIfMatch(v string) *UploadPartCopyInput {
+        s.CopySourceIfMatch = &v
+        return s
+}
+
+// SetCopySourceIfModifiedSince sets the CopySourceIfModifiedSince field's value.
+func (s *UploadPartCopyInput) SetCopySourceIfModifiedSince(v time.Time) *UploadPartCopyInput {
+        s.CopySourceIfModifiedSince = &v
+        return s
+}
+
+// SetCopySourceIfNoneMatch sets the CopySourceIfNoneMatch field's value.
+func (s *UploadPartCopyInput) SetCopySourceIfNoneMatch(v string) *UploadPartCopyInput {
+        s.CopySourceIfNoneMatch = &v
+        return s
+}
+
+// SetCopySourceIfUnmodifiedSince sets the CopySourceIfUnmodifiedSince field's value.
+func (s *UploadPartCopyInput) SetCopySourceIfUnmodifiedSince(v time.Time) *UploadPartCopyInput {
+        s.CopySourceIfUnmodifiedSince = &v
+        return s
+}
+
+// SetCopySourceRange sets the CopySourceRange field's value.
+func (s *UploadPartCopyInput) SetCopySourceRange(v string) *UploadPartCopyInput {
+        s.CopySourceRange = &v
+        return s
+}
+
+// SetCopySourceSSECustomerAlgorithm sets the CopySourceSSECustomerAlgorithm field's value.
+func (s *UploadPartCopyInput) SetCopySourceSSECustomerAlgorithm(v string) *UploadPartCopyInput {
+        s.CopySourceSSECustomerAlgorithm = &v
+        return s
+}
+
+// SetCopySourceSSECustomerKey sets the CopySourceSSECustomerKey field's value.
+func (s *UploadPartCopyInput) SetCopySourceSSECustomerKey(v string) *UploadPartCopyInput {
+        s.CopySourceSSECustomerKey = &v
+        return s
+}
+
+// SetCopySourceSSECustomerKeyMD5 sets the CopySourceSSECustomerKeyMD5 field's value.
+func (s *UploadPartCopyInput) SetCopySourceSSECustomerKeyMD5(v string) *UploadPartCopyInput {
+        s.CopySourceSSECustomerKeyMD5 = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *UploadPartCopyInput) SetKey(v string) *UploadPartCopyInput {
+        s.Key = &v
+        return s
+}
+
+// SetPartNumber sets the PartNumber field's value.
+func (s *UploadPartCopyInput) SetPartNumber(v int64) *UploadPartCopyInput {
+        s.PartNumber = &v
+        return s
+}
+
+// SetRequestPayer sets the RequestPayer field's value.
+func (s *UploadPartCopyInput) SetRequestPayer(v string) *UploadPartCopyInput {
+        s.RequestPayer = &v
+        return s
+}
+
+// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.
+func (s *UploadPartCopyInput) SetSSECustomerAlgorithm(v string) *UploadPartCopyInput {
+        s.SSECustomerAlgorithm = &v
+        return s
+}
+
+// SetSSECustomerKey sets the SSECustomerKey field's value.
+func (s *UploadPartCopyInput) SetSSECustomerKey(v string) *UploadPartCopyInput {
+        s.SSECustomerKey = &v
+        return s
+}
+
+// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.
+func (s *UploadPartCopyInput) SetSSECustomerKeyMD5(v string) *UploadPartCopyInput {
+        s.SSECustomerKeyMD5 = &v
+        return s
+}
+
+// SetUploadId sets the UploadId field's value.
+func (s *UploadPartCopyInput) SetUploadId(v string) *UploadPartCopyInput {
+        s.UploadId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/UploadPartCopyOutput
+type UploadPartCopyOutput struct {
+        _ struct{} `type:"structure" payload:"CopyPartResult"`
+
+        CopyPartResult *CopyPartResult `type:"structure"`
+
+        // The version of the source object that was copied, if you have enabled versioning
+        // on the source bucket.
+        CopySourceVersionId *string `location:"header" locationName:"x-amz-copy-source-version-id" type:"string"`
+
+        // If present, indicates that the requester was successfully charged for the
+        // request.
+        RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`
+
+        // If server-side encryption with a customer-provided encryption key was requested,
+        // the response will include this header confirming the encryption algorithm
+        // used.
+        SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`
+
+        // If server-side encryption with a customer-provided encryption key was requested,
+        // the response will include this header to provide round trip message integrity
+        // verification of the customer-provided encryption key.
+        SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`
+
+        // If present, specifies the ID of the AWS Key Management Service (KMS) master
+        // encryption key that was used for the object.
+        SSEKMSKeyId *string `location:"header" locationName:"x-amz-server-side-encryption-aws-kms-key-id" type:"string"`
+
+        // The Server-side encryption algorithm used when storing this object in S3
+        // (e.g., AES256, aws:kms).
+        ServerSideEncryption *string `location:"header" locationName:"x-amz-server-side-encryption" type:"string" enum:"ServerSideEncryption"`
+}
+
+// String returns the string representation
+func (s UploadPartCopyOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UploadPartCopyOutput) GoString() string {
+        return s.String()
+}
+
+// SetCopyPartResult sets the CopyPartResult field's value.
+func (s *UploadPartCopyOutput) SetCopyPartResult(v *CopyPartResult) *UploadPartCopyOutput {
+        s.CopyPartResult = v
+        return s
+}
+
+// SetCopySourceVersionId sets the CopySourceVersionId field's value.
+func (s *UploadPartCopyOutput) SetCopySourceVersionId(v string) *UploadPartCopyOutput {
+        s.CopySourceVersionId = &v
+        return s
+}
+
+// SetRequestCharged sets the RequestCharged field's value.
+func (s *UploadPartCopyOutput) SetRequestCharged(v string) *UploadPartCopyOutput {
+        s.RequestCharged = &v
+        return s
+}
+
+// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.
+func (s *UploadPartCopyOutput) SetSSECustomerAlgorithm(v string) *UploadPartCopyOutput {
+        s.SSECustomerAlgorithm = &v
+        return s
+}
+
+// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.
+func (s *UploadPartCopyOutput) SetSSECustomerKeyMD5(v string) *UploadPartCopyOutput {
+        s.SSECustomerKeyMD5 = &v
+        return s
+}
+
+// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.
+func (s *UploadPartCopyOutput) SetSSEKMSKeyId(v string) *UploadPartCopyOutput {
+        s.SSEKMSKeyId = &v
+        return s
+}
+
+// SetServerSideEncryption sets the ServerSideEncryption field's value.
+func (s *UploadPartCopyOutput) SetServerSideEncryption(v string) *UploadPartCopyOutput {
+        s.ServerSideEncryption = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/UploadPartRequest
+type UploadPartInput struct {
+        _ struct{} `type:"structure" payload:"Body"`
+
+        // Object data.
+        Body io.ReadSeeker `type:"blob"`
+
+        // Name of the bucket to which the multipart upload was initiated.
+        //
+        // Bucket is a required field
+        Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
+
+        // Size of the body in bytes. This parameter is useful when the size of the
+        // body cannot be determined automatically.
+        ContentLength *int64 `location:"header" locationName:"Content-Length" type:"long"`
+
+        // Object key for which the multipart upload was initiated.
+        //
+        // Key is a required field
+        Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`
+
+        // Part number of part being uploaded. This is a positive integer between 1
+        // and 10,000.
+        //
+        // PartNumber is a required field
+        PartNumber *int64 `location:"querystring" locationName:"partNumber" type:"integer" required:"true"`
+
+        // Confirms that the requester knows that she or he will be charged for the
+        // request. Bucket owners need not specify this parameter in their requests.
+        // Documentation on downloading objects from requester pays buckets can be found
+        // at http://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html
+        RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string" enum:"RequestPayer"`
+
+        // Specifies the algorithm to use to when encrypting the object (e.g., AES256).
+        SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`
+
+        // Specifies the customer-provided encryption key for Amazon S3 to use in encrypting
+        // data. This value is used to store the object and then it is discarded; Amazon
+        // does not store the encryption key. The key must be appropriate for use with
+        // the algorithm specified in the x-amz-server-side​-encryption​-customer-algorithm
+        // header. This must be the same encryption key specified in the initiate multipart
+        // upload request.
+        SSECustomerKey *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key" type:"string"`
+
+        // Specifies the 128-bit MD5 digest of the encryption key according to RFC 1321.
+        // Amazon S3 uses this header for a message integrity check to ensure the encryption
+        // key was transmitted without error.
+        SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`
+
+        // Upload ID identifying the multipart upload whose part is being uploaded.
+        //
+        // UploadId is a required field
+        UploadId *string `location:"querystring" locationName:"uploadId" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s UploadPartInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UploadPartInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UploadPartInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "UploadPartInput"}
+        if s.Bucket == nil {
+                invalidParams.Add(request.NewErrParamRequired("Bucket"))
+        }
+        if s.Key == nil {
+                invalidParams.Add(request.NewErrParamRequired("Key"))
+        }
+        if s.Key != nil && len(*s.Key) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+        }
+        if s.PartNumber == nil {
+                invalidParams.Add(request.NewErrParamRequired("PartNumber"))
+        }
+        if s.UploadId == nil {
+                invalidParams.Add(request.NewErrParamRequired("UploadId"))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetBody sets the Body field's value.
+func (s *UploadPartInput) SetBody(v io.ReadSeeker) *UploadPartInput {
+        s.Body = v
+        return s
+}
+
+// SetBucket sets the Bucket field's value.
+func (s *UploadPartInput) SetBucket(v string) *UploadPartInput {
+        s.Bucket = &v
+        return s
+}
+
+// SetContentLength sets the ContentLength field's value.
+func (s *UploadPartInput) SetContentLength(v int64) *UploadPartInput {
+        s.ContentLength = &v
+        return s
+}
+
+// SetKey sets the Key field's value.
+func (s *UploadPartInput) SetKey(v string) *UploadPartInput {
+        s.Key = &v
+        return s
+}
+
+// SetPartNumber sets the PartNumber field's value.
+func (s *UploadPartInput) SetPartNumber(v int64) *UploadPartInput {
+        s.PartNumber = &v
+        return s
+}
+
+// SetRequestPayer sets the RequestPayer field's value.
+func (s *UploadPartInput) SetRequestPayer(v string) *UploadPartInput {
+        s.RequestPayer = &v
+        return s
+}
+
+// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.
+func (s *UploadPartInput) SetSSECustomerAlgorithm(v string) *UploadPartInput {
+        s.SSECustomerAlgorithm = &v
+        return s
+}
+
+// SetSSECustomerKey sets the SSECustomerKey field's value.
+func (s *UploadPartInput) SetSSECustomerKey(v string) *UploadPartInput {
+        s.SSECustomerKey = &v
+        return s
+}
+
+// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.
+func (s *UploadPartInput) SetSSECustomerKeyMD5(v string) *UploadPartInput {
+        s.SSECustomerKeyMD5 = &v
+        return s
+}
+
+// SetUploadId sets the UploadId field's value.
+func (s *UploadPartInput) SetUploadId(v string) *UploadPartInput {
+        s.UploadId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/UploadPartOutput
+type UploadPartOutput struct {
+        _ struct{} `type:"structure"`
+
+        // Entity tag for the uploaded object.
+        ETag *string `location:"header" locationName:"ETag" type:"string"`
+
+        // If present, indicates that the requester was successfully charged for the
+        // request.
+        RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`
+
+        // If server-side encryption with a customer-provided encryption key was requested,
+        // the response will include this header confirming the encryption algorithm
+        // used.
+        SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`
+
+        // If server-side encryption with a customer-provided encryption key was requested,
+        // the response will include this header to provide round trip message integrity
+        // verification of the customer-provided encryption key.
+        SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`
+
+        // If present, specifies the ID of the AWS Key Management Service (KMS) master
+        // encryption key that was used for the object.
+        SSEKMSKeyId *string `location:"header" locationName:"x-amz-server-side-encryption-aws-kms-key-id" type:"string"`
+
+        // The Server-side encryption algorithm used when storing this object in S3
+        // (e.g., AES256, aws:kms).
+        ServerSideEncryption *string `location:"header" locationName:"x-amz-server-side-encryption" type:"string" enum:"ServerSideEncryption"`
+}
+
+// String returns the string representation
+func (s UploadPartOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UploadPartOutput) GoString() string {
+        return s.String()
+}
+
+// SetETag sets the ETag field's value.
+func (s *UploadPartOutput) SetETag(v string) *UploadPartOutput {
+        s.ETag = &v
+        return s
+}
+
+// SetRequestCharged sets the RequestCharged field's value.
+func (s *UploadPartOutput) SetRequestCharged(v string) *UploadPartOutput {
+        s.RequestCharged = &v
+        return s
+}
+
+// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.
+func (s *UploadPartOutput) SetSSECustomerAlgorithm(v string) *UploadPartOutput {
+        s.SSECustomerAlgorithm = &v
+        return s
+}
+
+// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.
+func (s *UploadPartOutput) SetSSECustomerKeyMD5(v string) *UploadPartOutput {
+        s.SSECustomerKeyMD5 = &v
+        return s
+}
+
+// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.
+func (s *UploadPartOutput) SetSSEKMSKeyId(v string) *UploadPartOutput {
+        s.SSEKMSKeyId = &v
+        return s
+}
+
+// SetServerSideEncryption sets the ServerSideEncryption field's value.
+func (s *UploadPartOutput) SetServerSideEncryption(v string) *UploadPartOutput {
+        s.ServerSideEncryption = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/VersioningConfiguration
+type VersioningConfiguration struct {
+        _ struct{} `type:"structure"`
+
+        // Specifies whether MFA delete is enabled in the bucket versioning configuration.
+        // This element is only returned if the bucket has been configured with MFA
+        // delete. If the bucket has never been so configured, this element is not returned.
+        MFADelete *string `locationName:"MfaDelete" type:"string" enum:"MFADelete"`
+
+        // The versioning state of the bucket.
+        Status *string `type:"string" enum:"BucketVersioningStatus"`
+}
+
+// String returns the string representation
+func (s VersioningConfiguration) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VersioningConfiguration) GoString() string {
+        return s.String()
+}
+
+// SetMFADelete sets the MFADelete field's value.
+func (s *VersioningConfiguration) SetMFADelete(v string) *VersioningConfiguration {
+        s.MFADelete = &v
+        return s
+}
+
+// SetStatus sets the Status field's value.
+func (s *VersioningConfiguration) SetStatus(v string) *VersioningConfiguration {
+        s.Status = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/WebsiteConfiguration
+type WebsiteConfiguration struct {
+        _ struct{} `type:"structure"`
+
+        ErrorDocument *ErrorDocument `type:"structure"`
+
+        IndexDocument *IndexDocument `type:"structure"`
+
+        RedirectAllRequestsTo *RedirectAllRequestsTo `type:"structure"`
+
+        RoutingRules []*RoutingRule `locationNameList:"RoutingRule" type:"list"`
+}
+
+// String returns the string representation
+func (s WebsiteConfiguration) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s WebsiteConfiguration) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *WebsiteConfiguration) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "WebsiteConfiguration"}
+        if s.ErrorDocument != nil {
+                if err := s.ErrorDocument.Validate(); err != nil {
+                        invalidParams.AddNested("ErrorDocument", err.(request.ErrInvalidParams))
+                }
+        }
+        if s.IndexDocument != nil {
+                if err := s.IndexDocument.Validate(); err != nil {
+                        invalidParams.AddNested("IndexDocument", err.(request.ErrInvalidParams))
+                }
+        }
+        if s.RedirectAllRequestsTo != nil {
+                if err := s.RedirectAllRequestsTo.Validate(); err != nil {
+                        invalidParams.AddNested("RedirectAllRequestsTo", err.(request.ErrInvalidParams))
+                }
+        }
+        if s.RoutingRules != nil {
+                for i, v := range s.RoutingRules {
+                        if v == nil {
+                                continue
+                        }
+                        if err := v.Validate(); err != nil {
+                                invalidParams.AddNested(fmt.Sprintf("%s[%v]", "RoutingRules", i), err.(request.ErrInvalidParams))
+                        }
+                }
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetErrorDocument sets the ErrorDocument field's value.
+func (s *WebsiteConfiguration) SetErrorDocument(v *ErrorDocument) *WebsiteConfiguration {
+        s.ErrorDocument = v
+        return s
+}
+
+// SetIndexDocument sets the IndexDocument field's value.
+func (s *WebsiteConfiguration) SetIndexDocument(v *IndexDocument) *WebsiteConfiguration {
+        s.IndexDocument = v
+        return s
+}
+
+// SetRedirectAllRequestsTo sets the RedirectAllRequestsTo field's value.
+func (s *WebsiteConfiguration) SetRedirectAllRequestsTo(v *RedirectAllRequestsTo) *WebsiteConfiguration {
+        s.RedirectAllRequestsTo = v
+        return s
+}
+
+// SetRoutingRules sets the RoutingRules field's value.
+func (s *WebsiteConfiguration) SetRoutingRules(v []*RoutingRule) *WebsiteConfiguration {
+        s.RoutingRules = v
+        return s
+}
+
+const (
+        // AnalyticsS3ExportFileFormatCsv is a AnalyticsS3ExportFileFormat enum value
+        AnalyticsS3ExportFileFormatCsv = "CSV"
+)
+
+const (
+        // BucketAccelerateStatusEnabled is a BucketAccelerateStatus enum value
+        BucketAccelerateStatusEnabled = "Enabled"
+
+        // BucketAccelerateStatusSuspended is a BucketAccelerateStatus enum value
+        BucketAccelerateStatusSuspended = "Suspended"
+)
+
+const (
+        // BucketCannedACLPrivate is a BucketCannedACL enum value
+        BucketCannedACLPrivate = "private"
+
+        // BucketCannedACLPublicRead is a BucketCannedACL enum value
+        BucketCannedACLPublicRead = "public-read"
+
+        // BucketCannedACLPublicReadWrite is a BucketCannedACL enum value
+        BucketCannedACLPublicReadWrite = "public-read-write"
+
+        // BucketCannedACLAuthenticatedRead is a BucketCannedACL enum value
+        BucketCannedACLAuthenticatedRead = "authenticated-read"
+)
+
+const (
+        // BucketLocationConstraintEu is a BucketLocationConstraint enum value
+        BucketLocationConstraintEu = "EU"
+
+        // BucketLocationConstraintEuWest1 is a BucketLocationConstraint enum value
+        BucketLocationConstraintEuWest1 = "eu-west-1"
+
+        // BucketLocationConstraintUsWest1 is a BucketLocationConstraint enum value
+        BucketLocationConstraintUsWest1 = "us-west-1"
+
+        // BucketLocationConstraintUsWest2 is a BucketLocationConstraint enum value
+        BucketLocationConstraintUsWest2 = "us-west-2"
+
+        // BucketLocationConstraintApSouth1 is a BucketLocationConstraint enum value
+        BucketLocationConstraintApSouth1 = "ap-south-1"
+
+        // BucketLocationConstraintApSoutheast1 is a BucketLocationConstraint enum value
+        BucketLocationConstraintApSoutheast1 = "ap-southeast-1"
+
+        // BucketLocationConstraintApSoutheast2 is a BucketLocationConstraint enum value
+        BucketLocationConstraintApSoutheast2 = "ap-southeast-2"
+
+        // BucketLocationConstraintApNortheast1 is a BucketLocationConstraint enum value
+        BucketLocationConstraintApNortheast1 = "ap-northeast-1"
+
+        // BucketLocationConstraintSaEast1 is a BucketLocationConstraint enum value
+        BucketLocationConstraintSaEast1 = "sa-east-1"
+
+        // BucketLocationConstraintCnNorth1 is a BucketLocationConstraint enum value
+        BucketLocationConstraintCnNorth1 = "cn-north-1"
+
+        // BucketLocationConstraintEuCentral1 is a BucketLocationConstraint enum value
+        BucketLocationConstraintEuCentral1 = "eu-central-1"
+)
+
+const (
+        // BucketLogsPermissionFullControl is a BucketLogsPermission enum value
+        BucketLogsPermissionFullControl = "FULL_CONTROL"
+
+        // BucketLogsPermissionRead is a BucketLogsPermission enum value
+        BucketLogsPermissionRead = "READ"
+
+        // BucketLogsPermissionWrite is a BucketLogsPermission enum value
+        BucketLogsPermissionWrite = "WRITE"
+)
+
+const (
+        // BucketVersioningStatusEnabled is a BucketVersioningStatus enum value
+        BucketVersioningStatusEnabled = "Enabled"
+
+        // BucketVersioningStatusSuspended is a BucketVersioningStatus enum value
+        BucketVersioningStatusSuspended = "Suspended"
+)
+
+// Requests Amazon S3 to encode the object keys in the response and specifies
+// the encoding method to use. An object key may contain any Unicode character;
+// however, XML 1.0 parser cannot parse some characters, such as characters
+// with an ASCII value from 0 to 10. For characters that are not supported in
+// XML 1.0, you can add this parameter to request that Amazon S3 encode the
+// keys in the response.
+const (
+        // EncodingTypeUrl is a EncodingType enum value
+        EncodingTypeUrl = "url"
+)
+
+// Bucket event for which to send notifications.
+const (
+        // EventS3ReducedRedundancyLostObject is a Event enum value
+        EventS3ReducedRedundancyLostObject = "s3:ReducedRedundancyLostObject"
+
+        // EventS3ObjectCreated is a Event enum value
+        EventS3ObjectCreated = "s3:ObjectCreated:*"
+
+        // EventS3ObjectCreatedPut is a Event enum value
+        EventS3ObjectCreatedPut = "s3:ObjectCreated:Put"
+
+        // EventS3ObjectCreatedPost is a Event enum value
+        EventS3ObjectCreatedPost = "s3:ObjectCreated:Post"
+
+        // EventS3ObjectCreatedCopy is a Event enum value
+        EventS3ObjectCreatedCopy = "s3:ObjectCreated:Copy"
+
+        // EventS3ObjectCreatedCompleteMultipartUpload is a Event enum value
+        EventS3ObjectCreatedCompleteMultipartUpload = "s3:ObjectCreated:CompleteMultipartUpload"
+
+        // EventS3ObjectRemoved is a Event enum value
+        EventS3ObjectRemoved = "s3:ObjectRemoved:*"
+
+        // EventS3ObjectRemovedDelete is a Event enum value
+        EventS3ObjectRemovedDelete = "s3:ObjectRemoved:Delete"
+
+        // EventS3ObjectRemovedDeleteMarkerCreated is a Event enum value
+        EventS3ObjectRemovedDeleteMarkerCreated = "s3:ObjectRemoved:DeleteMarkerCreated"
+)
+
+const (
+        // ExpirationStatusEnabled is a ExpirationStatus enum value
+        ExpirationStatusEnabled = "Enabled"
+
+        // ExpirationStatusDisabled is a ExpirationStatus enum value
+        ExpirationStatusDisabled = "Disabled"
+)
+
+const (
+        // FilterRuleNamePrefix is a FilterRuleName enum value
+        FilterRuleNamePrefix = "prefix"
+
+        // FilterRuleNameSuffix is a FilterRuleName enum value
+        FilterRuleNameSuffix = "suffix"
+)
+
+const (
+        // InventoryFormatCsv is a InventoryFormat enum value
+        InventoryFormatCsv = "CSV"
+)
+
+const (
+        // InventoryFrequencyDaily is a InventoryFrequency enum value
+        InventoryFrequencyDaily = "Daily"
+
+        // InventoryFrequencyWeekly is a InventoryFrequency enum value
+        InventoryFrequencyWeekly = "Weekly"
+)
+
+const (
+        // InventoryIncludedObjectVersionsAll is a InventoryIncludedObjectVersions enum value
+        InventoryIncludedObjectVersionsAll = "All"
+
+        // InventoryIncludedObjectVersionsCurrent is a InventoryIncludedObjectVersions enum value
+        InventoryIncludedObjectVersionsCurrent = "Current"
+)
+
+const (
+        // InventoryOptionalFieldSize is a InventoryOptionalField enum value
+        InventoryOptionalFieldSize = "Size"
+
+        // InventoryOptionalFieldLastModifiedDate is a InventoryOptionalField enum value
+        InventoryOptionalFieldLastModifiedDate = "LastModifiedDate"
+
+        // InventoryOptionalFieldStorageClass is a InventoryOptionalField enum value
+        InventoryOptionalFieldStorageClass = "StorageClass"
+
+        // InventoryOptionalFieldEtag is a InventoryOptionalField enum value
+        InventoryOptionalFieldEtag = "ETag"
+
+        // InventoryOptionalFieldIsMultipartUploaded is a InventoryOptionalField enum value
+        InventoryOptionalFieldIsMultipartUploaded = "IsMultipartUploaded"
+
+        // InventoryOptionalFieldReplicationStatus is a InventoryOptionalField enum value
+        InventoryOptionalFieldReplicationStatus = "ReplicationStatus"
+)
+
+const (
+        // MFADeleteEnabled is a MFADelete enum value
+        MFADeleteEnabled = "Enabled"
+
+        // MFADeleteDisabled is a MFADelete enum value
+        MFADeleteDisabled = "Disabled"
+)
+
+const (
+        // MFADeleteStatusEnabled is a MFADeleteStatus enum value
+        MFADeleteStatusEnabled = "Enabled"
+
+        // MFADeleteStatusDisabled is a MFADeleteStatus enum value
+        MFADeleteStatusDisabled = "Disabled"
+)
+
+const (
+        // MetadataDirectiveCopy is a MetadataDirective enum value
+        MetadataDirectiveCopy = "COPY"
+
+        // MetadataDirectiveReplace is a MetadataDirective enum value
+        MetadataDirectiveReplace = "REPLACE"
+)
+
+const (
+        // ObjectCannedACLPrivate is a ObjectCannedACL enum value
+        ObjectCannedACLPrivate = "private"
+
+        // ObjectCannedACLPublicRead is a ObjectCannedACL enum value
+        ObjectCannedACLPublicRead = "public-read"
+
+        // ObjectCannedACLPublicReadWrite is a ObjectCannedACL enum value
+        ObjectCannedACLPublicReadWrite = "public-read-write"
+
+        // ObjectCannedACLAuthenticatedRead is a ObjectCannedACL enum value
+        ObjectCannedACLAuthenticatedRead = "authenticated-read"
+
+        // ObjectCannedACLAwsExecRead is a ObjectCannedACL enum value
+        ObjectCannedACLAwsExecRead = "aws-exec-read"
+
+        // ObjectCannedACLBucketOwnerRead is a ObjectCannedACL enum value
+        ObjectCannedACLBucketOwnerRead = "bucket-owner-read"
+
+        // ObjectCannedACLBucketOwnerFullControl is a ObjectCannedACL enum value
+        ObjectCannedACLBucketOwnerFullControl = "bucket-owner-full-control"
+)
+
+const (
+        // ObjectStorageClassStandard is a ObjectStorageClass enum value
+        ObjectStorageClassStandard = "STANDARD"
+
+        // ObjectStorageClassReducedRedundancy is a ObjectStorageClass enum value
+        ObjectStorageClassReducedRedundancy = "REDUCED_REDUNDANCY"
+
+        // ObjectStorageClassGlacier is a ObjectStorageClass enum value
+        ObjectStorageClassGlacier = "GLACIER"
+)
+
+const (
+        // ObjectVersionStorageClassStandard is a ObjectVersionStorageClass enum value
+        ObjectVersionStorageClassStandard = "STANDARD"
+)
+
+const (
+        // PayerRequester is a Payer enum value
+        PayerRequester = "Requester"
+
+        // PayerBucketOwner is a Payer enum value
+        PayerBucketOwner = "BucketOwner"
+)
+
+const (
+        // PermissionFullControl is a Permission enum value
+        PermissionFullControl = "FULL_CONTROL"
+
+        // PermissionWrite is a Permission enum value
+        PermissionWrite = "WRITE"
+
+        // PermissionWriteAcp is a Permission enum value
+        PermissionWriteAcp = "WRITE_ACP"
+
+        // PermissionRead is a Permission enum value
+        PermissionRead = "READ"
+
+        // PermissionReadAcp is a Permission enum value
+        PermissionReadAcp = "READ_ACP"
+)
+
+const (
+        // ProtocolHttp is a Protocol enum value
+        ProtocolHttp = "http"
+
+        // ProtocolHttps is a Protocol enum value
+        ProtocolHttps = "https"
+)
+
+const (
+        // ReplicationRuleStatusEnabled is a ReplicationRuleStatus enum value
+        ReplicationRuleStatusEnabled = "Enabled"
+
+        // ReplicationRuleStatusDisabled is a ReplicationRuleStatus enum value
+        ReplicationRuleStatusDisabled = "Disabled"
+)
+
+const (
+        // ReplicationStatusComplete is a ReplicationStatus enum value
+        ReplicationStatusComplete = "COMPLETE"
+
+        // ReplicationStatusPending is a ReplicationStatus enum value
+        ReplicationStatusPending = "PENDING"
+
+        // ReplicationStatusFailed is a ReplicationStatus enum value
+        ReplicationStatusFailed = "FAILED"
+
+        // ReplicationStatusReplica is a ReplicationStatus enum value
+        ReplicationStatusReplica = "REPLICA"
+)
+
+// If present, indicates that the requester was successfully charged for the
+// request.
+const (
+        // RequestChargedRequester is a RequestCharged enum value
+        RequestChargedRequester = "requester"
+)
+
+// Confirms that the requester knows that she or he will be charged for the
+// request. Bucket owners need not specify this parameter in their requests.
+// Documentation on downloading objects from requester pays buckets can be found
+// at http://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html
+const (
+        // RequestPayerRequester is a RequestPayer enum value
+        RequestPayerRequester = "requester"
+)
+
+const (
+        // ServerSideEncryptionAes256 is a ServerSideEncryption enum value
+        ServerSideEncryptionAes256 = "AES256"
+
+        // ServerSideEncryptionAwsKms is a ServerSideEncryption enum value
+        ServerSideEncryptionAwsKms = "aws:kms"
+)
+
+const (
+        // StorageClassStandard is a StorageClass enum value
+        StorageClassStandard = "STANDARD"
+
+        // StorageClassReducedRedundancy is a StorageClass enum value
+        StorageClassReducedRedundancy = "REDUCED_REDUNDANCY"
+
+        // StorageClassStandardIa is a StorageClass enum value
+        StorageClassStandardIa = "STANDARD_IA"
+)
+
+const (
+        // StorageClassAnalysisSchemaVersionV1 is a StorageClassAnalysisSchemaVersion enum value
+        StorageClassAnalysisSchemaVersionV1 = "V_1"
+)
+
+const (
+        // TaggingDirectiveCopy is a TaggingDirective enum value
+        TaggingDirectiveCopy = "COPY"
+
+        // TaggingDirectiveReplace is a TaggingDirective enum value
+        TaggingDirectiveReplace = "REPLACE"
+)
+
+const (
+        // TierStandard is a Tier enum value
+        TierStandard = "Standard"
+
+        // TierBulk is a Tier enum value
+        TierBulk = "Bulk"
+
+        // TierExpedited is a Tier enum value
+        TierExpedited = "Expedited"
+)
+
+const (
+        // TransitionStorageClassGlacier is a TransitionStorageClass enum value
+        TransitionStorageClassGlacier = "GLACIER"
+
+        // TransitionStorageClassStandardIa is a TransitionStorageClass enum value
+        TransitionStorageClassStandardIa = "STANDARD_IA"
+)
+
+const (
+        // TypeCanonicalUser is a Type enum value
+        TypeCanonicalUser = "CanonicalUser"
+
+        // TypeAmazonCustomerByEmail is a Type enum value
+        TypeAmazonCustomerByEmail = "AmazonCustomerByEmail"
+
+        // TypeGroup is a Type enum value
+        TypeGroup = "Group"
+)
diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/bucket_location.go b/vendor/github.com/aws/aws-sdk-go/service/s3/bucket_location.go
new file mode 100644
index 0000000..bc68a46
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/bucket_location.go
@@ -0,0 +1,106 @@
+package s3
+
+import (
+        "io/ioutil"
+        "regexp"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/awsutil"
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+var reBucketLocation = regexp.MustCompile(`>([^<>]+)<\/Location`)
+
+// NormalizeBucketLocation is a utility function which will update the
+// passed in value to always be a region ID. Generally this would be used
+// with GetBucketLocation API operation.
+//
+// Replaces empty string with "us-east-1", and "EU" with "eu-west-1".
+//
+// See http://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETlocation.html
+// for more information on the values that can be returned.
+func NormalizeBucketLocation(loc string) string {
+        switch loc {
+        case "":
+                loc = "us-east-1"
+        case "EU":
+                loc = "eu-west-1"
+        }
+
+        return loc
+}
+
+// NormalizeBucketLocationHandler is a request handler which will update the
+// GetBucketLocation's result LocationConstraint value to always be a region ID.
+//
+// Replaces empty string with "us-east-1", and "EU" with "eu-west-1".
+//
+// See http://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETlocation.html
+// for more information on the values that can be returned.
+//
+//     req, result := svc.GetBucketLocationRequest(&s3.GetBucketLocationInput{
+//         Bucket: aws.String(bucket),
+//     })
+//     req.Handlers.Unmarshal.PushBackNamed(NormalizeBucketLocationHandler)
+//     err := req.Send()
+var NormalizeBucketLocationHandler = request.NamedHandler{
+        Name: "awssdk.s3.NormalizeBucketLocation",
+        Fn: func(req *request.Request) {
+                if req.Error != nil {
+                        return
+                }
+
+                out := req.Data.(*GetBucketLocationOutput)
+                loc := NormalizeBucketLocation(aws.StringValue(out.LocationConstraint))
+                out.LocationConstraint = aws.String(loc)
+        },
+}
+
+// WithNormalizeBucketLocation is a request option which will update the
+// GetBucketLocation's result LocationConstraint value to always be a region ID.
+//
+// Replaces empty string with "us-east-1", and "EU" with "eu-west-1".
+//
+// See http://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETlocation.html
+// for more information on the values that can be returned.
+//
+//     result, err := svc.GetBucketLocationWithContext(ctx,
+//         &s3.GetBucketLocationInput{
+//             Bucket: aws.String(bucket),
+//         },
+//         s3.WithNormalizeBucketLocation,
+//     )
+func WithNormalizeBucketLocation(r *request.Request) {
+        r.Handlers.Unmarshal.PushBackNamed(NormalizeBucketLocationHandler)
+}
+
+func buildGetBucketLocation(r *request.Request) {
+        if r.DataFilled() {
+                out := r.Data.(*GetBucketLocationOutput)
+                b, err := ioutil.ReadAll(r.HTTPResponse.Body)
+                if err != nil {
+                        r.Error = awserr.New("SerializationError", "failed reading response body", err)
+                        return
+                }
+
+                match := reBucketLocation.FindSubmatch(b)
+                if len(match) > 1 {
+                        loc := string(match[1])
+                        out.LocationConstraint = aws.String(loc)
+                }
+        }
+}
+
+func populateLocationConstraint(r *request.Request) {
+        if r.ParamsFilled() && aws.StringValue(r.Config.Region) != "us-east-1" {
+                in := r.Params.(*CreateBucketInput)
+                if in.CreateBucketConfiguration == nil {
+                        r.Params = awsutil.CopyOf(r.Params)
+                        in = r.Params.(*CreateBucketInput)
+                        in.CreateBucketConfiguration = &CreateBucketConfiguration{
+                                LocationConstraint: r.Config.Region,
+                        }
+                }
+        }
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/content_md5.go b/vendor/github.com/aws/aws-sdk-go/service/s3/content_md5.go
new file mode 100644
index 0000000..9fc5df9
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/content_md5.go
@@ -0,0 +1,36 @@
+package s3
+
+import (
+        "crypto/md5"
+        "encoding/base64"
+        "io"
+
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+// contentMD5 computes and sets the HTTP Content-MD5 header for requests that
+// require it.
+func contentMD5(r *request.Request) {
+        h := md5.New()
+
+        // hash the body.  seek back to the first position after reading to reset
+        // the body for transmission.  copy errors may be assumed to be from the
+        // body.
+        _, err := io.Copy(h, r.Body)
+        if err != nil {
+                r.Error = awserr.New("ContentMD5", "failed to read body", err)
+                return
+        }
+        _, err = r.Body.Seek(0, 0)
+        if err != nil {
+                r.Error = awserr.New("ContentMD5", "failed to seek body", err)
+                return
+        }
+
+        // encode the md5 checksum in base64 and set the request header.
+        sum := h.Sum(nil)
+        sum64 := make([]byte, base64.StdEncoding.EncodedLen(len(sum)))
+        base64.StdEncoding.Encode(sum64, sum)
+        r.HTTPRequest.Header.Set("Content-MD5", string(sum64))
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/customizations.go b/vendor/github.com/aws/aws-sdk-go/service/s3/customizations.go
new file mode 100644
index 0000000..8463347
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/customizations.go
@@ -0,0 +1,46 @@
+package s3
+
+import (
+        "github.com/aws/aws-sdk-go/aws/client"
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+func init() {
+        initClient = defaultInitClientFn
+        initRequest = defaultInitRequestFn
+}
+
+func defaultInitClientFn(c *client.Client) {
+        // Support building custom endpoints based on config
+        c.Handlers.Build.PushFront(updateEndpointForS3Config)
+
+        // Require SSL when using SSE keys
+        c.Handlers.Validate.PushBack(validateSSERequiresSSL)
+        c.Handlers.Build.PushBack(computeSSEKeys)
+
+        // S3 uses custom error unmarshaling logic
+        c.Handlers.UnmarshalError.Clear()
+        c.Handlers.UnmarshalError.PushBack(unmarshalError)
+}
+
+func defaultInitRequestFn(r *request.Request) {
+        // Add reuest handlers for specific platforms.
+        // e.g. 100-continue support for PUT requests using Go 1.6
+        platformRequestHandlers(r)
+
+        switch r.Operation.Name {
+        case opPutBucketCors, opPutBucketLifecycle, opPutBucketPolicy,
+                opPutBucketTagging, opDeleteObjects, opPutBucketLifecycleConfiguration,
+                opPutBucketReplication:
+                // These S3 operations require Content-MD5 to be set
+                r.Handlers.Build.PushBack(contentMD5)
+        case opGetBucketLocation:
+                // GetBucketLocation has custom parsing logic
+                r.Handlers.Unmarshal.PushFront(buildGetBucketLocation)
+        case opCreateBucket:
+                // Auto-populate LocationConstraint with current region
+                r.Handlers.Validate.PushFront(populateLocationConstraint)
+        case opCopyObject, opUploadPartCopy, opCompleteMultipartUpload:
+                r.Handlers.Unmarshal.PushFront(copyMultipartStatusOKUnmarhsalError)
+        }
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/doc.go b/vendor/github.com/aws/aws-sdk-go/service/s3/doc.go
new file mode 100644
index 0000000..f045fd0
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/doc.go
@@ -0,0 +1,78 @@
+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
+
+// Package s3 provides the client and types for making API
+// requests to Amazon Simple Storage Service.
+//
+// See https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01 for more information on this service.
+//
+// See s3 package documentation for more information.
+// https://docs.aws.amazon.com/sdk-for-go/api/service/s3/
+//
+// Using the Client
+//
+// To use the client for Amazon Simple Storage Service you will first need
+// to create a new instance of it.
+//
+// When creating a client for an AWS service you'll first need to have a Session
+// already created. The Session provides configuration that can be shared
+// between multiple service clients. Additional configuration can be applied to
+// the Session and service's client when they are constructed. The aws package's
+// Config type contains several fields such as Region for the AWS Region the
+// client should make API requests too. The optional Config value can be provided
+// as the variadic argument for Sessions and client creation.
+//
+// Once the service's client is created you can use it to make API requests the
+// AWS service. These clients are safe to use concurrently.
+//
+//   // Create a session to share configuration, and load external configuration.
+//   sess := session.Must(session.NewSession())
+//
+//   // Create the service's client with the session.
+//   svc := s3.New(sess)
+//
+// See the SDK's documentation for more information on how to use service clients.
+// https://docs.aws.amazon.com/sdk-for-go/api/
+//
+// See aws package's Config type for more information on configuration options.
+// https://docs.aws.amazon.com/sdk-for-go/api/aws/#Config
+//
+// See the Amazon Simple Storage Service client S3 for more
+// information on creating the service's client.
+// https://docs.aws.amazon.com/sdk-for-go/api/service/s3/#New
+//
+// Once the client is created you can make an API request to the service.
+// Each API method takes a input parameter, and returns the service response
+// and an error.
+//
+// The API method will document which error codes the service can be returned
+// by the operation if the service models the API operation's errors. These
+// errors will also be available as const strings prefixed with "ErrCode".
+//
+//   result, err := svc.AbortMultipartUpload(params)
+//   if err != nil {
+//       // Cast err to awserr.Error to handle specific error codes.
+//       aerr, ok := err.(awserr.Error)
+//       if ok && aerr.Code() == <error code to check for> {
+//           // Specific error code handling
+//       }
+//       return err
+//   }
+//
+//   fmt.Println("AbortMultipartUpload result:")
+//   fmt.Println(result)
+//
+// Using the Client with Context
+//
+// The service's client also provides methods to make API requests with a Context
+// value. This allows you to control the timeout, and cancellation of pending
+// requests. These methods also take request Option as variadic parameter to apply
+// additional configuration to the API request.
+//
+//   ctx := context.Background()
+//
+//   result, err := svc.AbortMultipartUploadWithContext(ctx, params)
+//
+// See the request package documentation for more information on using Context pattern
+// with the SDK.
+// https://docs.aws.amazon.com/sdk-for-go/api/aws/request/
+package s3
diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/doc_custom.go b/vendor/github.com/aws/aws-sdk-go/service/s3/doc_custom.go
new file mode 100644
index 0000000..b794a63
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/doc_custom.go
@@ -0,0 +1,109 @@
+// Upload Managers
+//
+// The s3manager package's Uploader provides concurrent upload of content to S3
+// by taking advantage of S3's Multipart APIs. The Uploader also supports both
+// io.Reader for streaming uploads, and will also take advantage of io.ReadSeeker
+// for optimizations if the Body satisfies that type. Once the Uploader instance
+// is created you can call Upload concurrently from multiple goroutines safely.
+//
+//   // The session the S3 Uploader will use
+//   sess := session.Must(session.NewSession())
+//
+//   // Create an uploader with the session and default options
+//   uploader := s3manager.NewUploader(sess)
+//
+//   f, err  := os.Open(filename)
+//   if err != nil {
+//       return fmt.Errorf("failed to open file %q, %v", filename, err)
+//   }
+//
+//   // Upload the file to S3.
+//   result, err := uploader.Upload(&s3manager.UploadInput{
+//       Bucket: aws.String(myBucket),
+//       Key:    aws.String(myString),
+//       Body:   f,
+//   })
+//   if err != nil {
+//       return fmt.Errorf("failed to upload file, %v", err)
+//   }
+//   fmt.Printf("file uploaded to, %s\n", aws.StringValue(result.Location))
+//
+// See the s3manager package's Uploader type documentation for more information.
+// https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3manager/#Uploader
+//
+// Download Manager
+//
+// The s3manager package's Downloader provides concurrently downloading of Objects
+// from S3. The Downloader will write S3 Object content with an io.WriterAt.
+// Once the Downloader instance is created you can call Upload concurrently from
+// multiple goroutines safely.
+//
+//   // The session the S3 Downloader will use
+//   sess := session.Must(session.NewSession())
+//
+//   // Create a downloader with the session and default options
+//   downloader := s3manager.NewDownloader(sess)
+//
+//   // Create a file to write the S3 Object contents to.
+//   f, err := os.Create(filename)
+//   if err != nil {
+//       return fmt.Errorf("failed to create file %q, %v", filename, err)
+//   }
+//
+//   // Write the contents of S3 Object to the file
+//   n, err := downloader.Download(f, &s3.GetObjectInput{
+//       Bucket: aws.String(myBucket),
+//       Key:    aws.String(myString),
+//   })
+//   if err != nil {
+//       return fmt.Errorf("failed to upload file, %v", err)
+//   }
+//   fmt.Printf("file downloaded, %d bytes\n", n)
+//
+// See the s3manager package's Downloader type documentation for more information.
+// https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3manager/#Downloader
+//
+// Get Bucket Region
+//
+// GetBucketRegion will attempt to get the region for a bucket using a region
+// hint to determine which AWS partition to perform the query on. Use this utility
+// to determine the region a bucket is in.
+//
+//   sess := session.Must(session.NewSession())
+//
+//   bucket := "my-bucket"
+//   region, err := s3manager.GetBucketRegion(ctx, sess, bucket, "us-west-2")
+//   if err != nil {
+//       if aerr, ok := err.(awserr.Error); ok && aerr.Code() == "NotFound" {
+//            fmt.Fprintf(os.Stderr, "unable to find bucket %s's region not found\n", bucket)
+//       }
+//       return err
+//   }
+//   fmt.Printf("Bucket %s is in %s region\n", bucket, region)
+//
+// See the s3manager package's GetBucketRegion function documentation for more information
+// https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3manager/#GetBucketRegion
+//
+// S3 Crypto Client
+//
+// The s3crypto package provides the tools to upload and download encrypted
+// content from S3. The Encryption and Decryption clients can be used concurrently
+// once the client is created.
+//
+//    sess := session.Must(session.NewSession())
+//
+//    // Create the decryption client.
+//    svc := s3crypto.NewDecryptionClient(sess)
+//
+//    // The object will be downloaded from S3 and decrypted locally. By metadata
+//    // about the object's encryption will instruct the decryption client how
+//    // decrypt the content of the object. By default KMS is used for keys.
+//    result, err := svc.GetObject(&s3.GetObjectInput {
+//        Bucket: aws.String(myBucket),
+//        Key: aws.String(myKey),
+//    })
+//
+// See the s3crypto package documentation for more information.
+// https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3crypto/
+//
+package s3
diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/errors.go b/vendor/github.com/aws/aws-sdk-go/service/s3/errors.go
new file mode 100644
index 0000000..931cb17
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/errors.go
@@ -0,0 +1,48 @@
+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
+
+package s3
+
+const (
+
+        // ErrCodeBucketAlreadyExists for service response error code
+        // "BucketAlreadyExists".
+        //
+        // The requested bucket name is not available. The bucket namespace is shared
+        // by all users of the system. Please select a different name and try again.
+        ErrCodeBucketAlreadyExists = "BucketAlreadyExists"
+
+        // ErrCodeBucketAlreadyOwnedByYou for service response error code
+        // "BucketAlreadyOwnedByYou".
+        ErrCodeBucketAlreadyOwnedByYou = "BucketAlreadyOwnedByYou"
+
+        // ErrCodeNoSuchBucket for service response error code
+        // "NoSuchBucket".
+        //
+        // The specified bucket does not exist.
+        ErrCodeNoSuchBucket = "NoSuchBucket"
+
+        // ErrCodeNoSuchKey for service response error code
+        // "NoSuchKey".
+        //
+        // The specified key does not exist.
+        ErrCodeNoSuchKey = "NoSuchKey"
+
+        // ErrCodeNoSuchUpload for service response error code
+        // "NoSuchUpload".
+        //
+        // The specified multipart upload does not exist.
+        ErrCodeNoSuchUpload = "NoSuchUpload"
+
+        // ErrCodeObjectAlreadyInActiveTierError for service response error code
+        // "ObjectAlreadyInActiveTierError".
+        //
+        // This operation is not allowed against this storage tier
+        ErrCodeObjectAlreadyInActiveTierError = "ObjectAlreadyInActiveTierError"
+
+        // ErrCodeObjectNotInActiveTierError for service response error code
+        // "ObjectNotInActiveTierError".
+        //
+        // The source object of the COPY operation is not in the active tier and is
+        // only stored in Amazon Glacier.
+        ErrCodeObjectNotInActiveTierError = "ObjectNotInActiveTierError"
+)
diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/host_style_bucket.go b/vendor/github.com/aws/aws-sdk-go/service/s3/host_style_bucket.go
new file mode 100644
index 0000000..ec3ffe4
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/host_style_bucket.go
@@ -0,0 +1,162 @@
+package s3
+
+import (
+        "fmt"
+        "net/url"
+        "regexp"
+        "strings"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/awsutil"
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+// an operationBlacklist is a list of operation names that should a
+// request handler should not be executed with.
+type operationBlacklist []string
+
+// Continue will return true of the Request's operation name is not
+// in the blacklist. False otherwise.
+func (b operationBlacklist) Continue(r *request.Request) bool {
+        for i := 0; i < len(b); i++ {
+                if b[i] == r.Operation.Name {
+                        return false
+                }
+        }
+        return true
+}
+
+var accelerateOpBlacklist = operationBlacklist{
+        opListBuckets, opCreateBucket, opDeleteBucket,
+}
+
+// Request handler to automatically add the bucket name to the endpoint domain
+// if possible. This style of bucket is valid for all bucket names which are
+// DNS compatible and do not contain "."
+func updateEndpointForS3Config(r *request.Request) {
+        forceHostStyle := aws.BoolValue(r.Config.S3ForcePathStyle)
+        accelerate := aws.BoolValue(r.Config.S3UseAccelerate)
+
+        if accelerate && accelerateOpBlacklist.Continue(r) {
+                if forceHostStyle {
+                        if r.Config.Logger != nil {
+                                r.Config.Logger.Log("ERROR: aws.Config.S3UseAccelerate is not compatible with aws.Config.S3ForcePathStyle, ignoring S3ForcePathStyle.")
+                        }
+                }
+                updateEndpointForAccelerate(r)
+        } else if !forceHostStyle && r.Operation.Name != opGetBucketLocation {
+                updateEndpointForHostStyle(r)
+        }
+}
+
+func updateEndpointForHostStyle(r *request.Request) {
+        bucket, ok := bucketNameFromReqParams(r.Params)
+        if !ok {
+                // Ignore operation requests if the bucketname was not provided
+                // if this is an input validation error the validation handler
+                // will report it.
+                return
+        }
+
+        if !hostCompatibleBucketName(r.HTTPRequest.URL, bucket) {
+                // bucket name must be valid to put into the host
+                return
+        }
+
+        moveBucketToHost(r.HTTPRequest.URL, bucket)
+}
+
+var (
+        accelElem = []byte("s3-accelerate.dualstack.")
+)
+
+func updateEndpointForAccelerate(r *request.Request) {
+        bucket, ok := bucketNameFromReqParams(r.Params)
+        if !ok {
+                // Ignore operation requests if the bucketname was not provided
+                // if this is an input validation error the validation handler
+                // will report it.
+                return
+        }
+
+        if !hostCompatibleBucketName(r.HTTPRequest.URL, bucket) {
+                r.Error = awserr.New("InvalidParameterException",
+                        fmt.Sprintf("bucket name %s is not compatible with S3 Accelerate", bucket),
+                        nil)
+                return
+        }
+
+        parts := strings.Split(r.HTTPRequest.URL.Host, ".")
+        if len(parts) < 3 {
+                r.Error = awserr.New("InvalidParameterExecption",
+                        fmt.Sprintf("unable to update endpoint host for S3 accelerate, hostname invalid, %s",
+                                r.HTTPRequest.URL.Host), nil)
+                return
+        }
+
+        if parts[0] == "s3" || strings.HasPrefix(parts[0], "s3-") {
+                parts[0] = "s3-accelerate"
+        }
+        for i := 1; i+1 < len(parts); i++ {
+                if parts[i] == aws.StringValue(r.Config.Region) {
+                        parts = append(parts[:i], parts[i+1:]...)
+                        break
+                }
+        }
+
+        r.HTTPRequest.URL.Host = strings.Join(parts, ".")
+
+        moveBucketToHost(r.HTTPRequest.URL, bucket)
+}
+
+// Attempts to retrieve the bucket name from the request input parameters.
+// If no bucket is found, or the field is empty "", false will be returned.
+func bucketNameFromReqParams(params interface{}) (string, bool) {
+        b, _ := awsutil.ValuesAtPath(params, "Bucket")
+        if len(b) == 0 {
+                return "", false
+        }
+
+        if bucket, ok := b[0].(*string); ok {
+                if bucketStr := aws.StringValue(bucket); bucketStr != "" {
+                        return bucketStr, true
+                }
+        }
+
+        return "", false
+}
+
+// hostCompatibleBucketName returns true if the request should
+// put the bucket in the host. This is false if S3ForcePathStyle is
+// explicitly set or if the bucket is not DNS compatible.
+func hostCompatibleBucketName(u *url.URL, bucket string) bool {
+        // Bucket might be DNS compatible but dots in the hostname will fail
+        // certificate validation, so do not use host-style.
+        if u.Scheme == "https" && strings.Contains(bucket, ".") {
+                return false
+        }
+
+        // if the bucket is DNS compatible
+        return dnsCompatibleBucketName(bucket)
+}
+
+var reDomain = regexp.MustCompile(`^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$`)
+var reIPAddress = regexp.MustCompile(`^(\d+\.){3}\d+$`)
+
+// dnsCompatibleBucketName returns true if the bucket name is DNS compatible.
+// Buckets created outside of the classic region MUST be DNS compatible.
+func dnsCompatibleBucketName(bucket string) bool {
+        return reDomain.MatchString(bucket) &&
+                !reIPAddress.MatchString(bucket) &&
+                !strings.Contains(bucket, "..")
+}
+
+// moveBucketToHost moves the bucket name from the URI path to URL host.
+func moveBucketToHost(u *url.URL, bucket string) {
+        u.Host = bucket + "." + u.Host
+        u.Path = strings.Replace(u.Path, "/{Bucket}", "", -1)
+        if u.Path == "" {
+                u.Path = "/"
+        }
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/platform_handlers.go b/vendor/github.com/aws/aws-sdk-go/service/s3/platform_handlers.go
new file mode 100644
index 0000000..8e6f330
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/platform_handlers.go
@@ -0,0 +1,8 @@
+// +build !go1.6
+
+package s3
+
+import "github.com/aws/aws-sdk-go/aws/request"
+
+func platformRequestHandlers(r *request.Request) {
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/platform_handlers_go1.6.go b/vendor/github.com/aws/aws-sdk-go/service/s3/platform_handlers_go1.6.go
new file mode 100644
index 0000000..14d05f7
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/platform_handlers_go1.6.go
@@ -0,0 +1,28 @@
+// +build go1.6
+
+package s3
+
+import (
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+func platformRequestHandlers(r *request.Request) {
+        if r.Operation.HTTPMethod == "PUT" {
+                // 100-Continue should only be used on put requests.
+                r.Handlers.Sign.PushBack(add100Continue)
+        }
+}
+
+func add100Continue(r *request.Request) {
+        if aws.BoolValue(r.Config.S3Disable100Continue) {
+                return
+        }
+        if r.HTTPRequest.ContentLength < 1024*1024*2 {
+                // Ignore requests smaller than 2MB. This helps prevent delaying
+                // requests unnecessarily.
+                return
+        }
+
+        r.HTTPRequest.Header.Set("Expect", "100-Continue")
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/service.go b/vendor/github.com/aws/aws-sdk-go/service/s3/service.go
new file mode 100644
index 0000000..614e477
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/service.go
@@ -0,0 +1,93 @@
+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
+
+package s3
+
+import (
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/client"
+        "github.com/aws/aws-sdk-go/aws/client/metadata"
+        "github.com/aws/aws-sdk-go/aws/request"
+        "github.com/aws/aws-sdk-go/aws/signer/v4"
+        "github.com/aws/aws-sdk-go/private/protocol/restxml"
+)
+
+// S3 provides the API operation methods for making requests to
+// Amazon Simple Storage Service. See this package's package overview docs
+// for details on the service.
+//
+// S3 methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
+type S3 struct {
+        *client.Client
+}
+
+// Used for custom client initialization logic
+var initClient func(*client.Client)
+
+// Used for custom request initialization logic
+var initRequest func(*request.Request)
+
+// Service information constants
+const (
+        ServiceName = "s3"        // Service endpoint prefix API calls made to.
+        EndpointsID = ServiceName // Service ID for Regions and Endpoints metadata.
+)
+
+// New creates a new instance of the S3 client with a session.
+// If additional configuration is needed for the client instance use the optional
+// aws.Config parameter to add your extra config.
+//
+// Example:
+//     // Create a S3 client from just a session.
+//     svc := s3.New(mySession)
+//
+//     // Create a S3 client with additional configuration
+//     svc := s3.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
+func New(p client.ConfigProvider, cfgs ...*aws.Config) *S3 {
+        c := p.ClientConfig(EndpointsID, cfgs...)
+        return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName)
+}
+
+// newClient creates, initializes and returns a new service client instance.
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *S3 {
+        svc := &S3{
+                Client: client.New(
+                        cfg,
+                        metadata.ClientInfo{
+                                ServiceName:   ServiceName,
+                                SigningName:   signingName,
+                                SigningRegion: signingRegion,
+                                Endpoint:      endpoint,
+                                APIVersion:    "2006-03-01",
+                        },
+                        handlers,
+                ),
+        }
+
+        // Handlers
+        svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler)
+        svc.Handlers.Build.PushBackNamed(restxml.BuildHandler)
+        svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler)
+        svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler)
+        svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler)
+
+        // Run custom client initialization if present
+        if initClient != nil {
+                initClient(svc.Client)
+        }
+
+        return svc
+}
+
+// newRequest creates a new request for a S3 operation and runs any
+// custom request initialization.
+func (c *S3) newRequest(op *request.Operation, params, data interface{}) *request.Request {
+        req := c.NewRequest(op, params, data)
+
+        // Run custom request initialization if present
+        if initRequest != nil {
+                initRequest(req)
+        }
+
+        return req
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/sse.go b/vendor/github.com/aws/aws-sdk-go/service/s3/sse.go
new file mode 100644
index 0000000..268ea2f
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/sse.go
@@ -0,0 +1,44 @@
+package s3
+
+import (
+        "crypto/md5"
+        "encoding/base64"
+
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/awsutil"
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+var errSSERequiresSSL = awserr.New("ConfigError", "cannot send SSE keys over HTTP.", nil)
+
+func validateSSERequiresSSL(r *request.Request) {
+        if r.HTTPRequest.URL.Scheme != "https" {
+                p, _ := awsutil.ValuesAtPath(r.Params, "SSECustomerKey||CopySourceSSECustomerKey")
+                if len(p) > 0 {
+                        r.Error = errSSERequiresSSL
+                }
+        }
+}
+
+func computeSSEKeys(r *request.Request) {
+        headers := []string{
+                "x-amz-server-side-encryption-customer-key",
+                "x-amz-copy-source-server-side-encryption-customer-key",
+        }
+
+        for _, h := range headers {
+                md5h := h + "-md5"
+                if key := r.HTTPRequest.Header.Get(h); key != "" {
+                        // Base64-encode the value
+                        b64v := base64.StdEncoding.EncodeToString([]byte(key))
+                        r.HTTPRequest.Header.Set(h, b64v)
+
+                        // Add MD5 if it wasn't computed
+                        if r.HTTPRequest.Header.Get(md5h) == "" {
+                                sum := md5.Sum([]byte(key))
+                                b64sum := base64.StdEncoding.EncodeToString(sum[:])
+                                r.HTTPRequest.Header.Set(md5h, b64sum)
+                        }
+                }
+        }
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/statusok_error.go b/vendor/github.com/aws/aws-sdk-go/service/s3/statusok_error.go
new file mode 100644
index 0000000..5a78fd3
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/statusok_error.go
@@ -0,0 +1,35 @@
+package s3
+
+import (
+        "bytes"
+        "io/ioutil"
+        "net/http"
+
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+func copyMultipartStatusOKUnmarhsalError(r *request.Request) {
+        b, err := ioutil.ReadAll(r.HTTPResponse.Body)
+        if err != nil {
+                r.Error = awserr.New("SerializationError", "unable to read response body", err)
+                return
+        }
+        body := bytes.NewReader(b)
+        r.HTTPResponse.Body = ioutil.NopCloser(body)
+        defer body.Seek(0, 0)
+
+        if body.Len() == 0 {
+                // If there is no body don't attempt to parse the body.
+                return
+        }
+
+        unmarshalError(r)
+        if err, ok := r.Error.(awserr.Error); ok && err != nil {
+                if err.Code() == "SerializationError" {
+                        r.Error = nil
+                        return
+                }
+                r.HTTPResponse.StatusCode = http.StatusServiceUnavailable
+        }
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/unmarshal_error.go b/vendor/github.com/aws/aws-sdk-go/service/s3/unmarshal_error.go
new file mode 100644
index 0000000..bcca862
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/unmarshal_error.go
@@ -0,0 +1,103 @@
+package s3
+
+import (
+        "encoding/xml"
+        "fmt"
+        "io"
+        "io/ioutil"
+        "net/http"
+        "strings"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+type xmlErrorResponse struct {
+        XMLName xml.Name `xml:"Error"`
+        Code    string   `xml:"Code"`
+        Message string   `xml:"Message"`
+}
+
+func unmarshalError(r *request.Request) {
+        defer r.HTTPResponse.Body.Close()
+        defer io.Copy(ioutil.Discard, r.HTTPResponse.Body)
+
+        hostID := r.HTTPResponse.Header.Get("X-Amz-Id-2")
+
+        // Bucket exists in a different region, and request needs
+        // to be made to the correct region.
+        if r.HTTPResponse.StatusCode == http.StatusMovedPermanently {
+                r.Error = requestFailure{
+                        RequestFailure: awserr.NewRequestFailure(
+                                awserr.New("BucketRegionError",
+                                        fmt.Sprintf("incorrect region, the bucket is not in '%s' region",
+                                                aws.StringValue(r.Config.Region)),
+                                        nil),
+                                r.HTTPResponse.StatusCode,
+                                r.RequestID,
+                        ),
+                        hostID: hostID,
+                }
+                return
+        }
+
+        var errCode, errMsg string
+
+        // Attempt to parse error from body if it is known
+        resp := &xmlErrorResponse{}
+        err := xml.NewDecoder(r.HTTPResponse.Body).Decode(resp)
+        if err != nil && err != io.EOF {
+                errCode = "SerializationError"
+                errMsg = "failed to decode S3 XML error response"
+        } else {
+                errCode = resp.Code
+                errMsg = resp.Message
+                err = nil
+        }
+
+        // Fallback to status code converted to message if still no error code
+        if len(errCode) == 0 {
+                statusText := http.StatusText(r.HTTPResponse.StatusCode)
+                errCode = strings.Replace(statusText, " ", "", -1)
+                errMsg = statusText
+        }
+
+        r.Error = requestFailure{
+                RequestFailure: awserr.NewRequestFailure(
+                        awserr.New(errCode, errMsg, err),
+                        r.HTTPResponse.StatusCode,
+                        r.RequestID,
+                ),
+                hostID: hostID,
+        }
+}
+
+// A RequestFailure provides access to the S3 Request ID and Host ID values
+// returned from API operation errors. Getting the error as a string will
+// return the formated error with the same information as awserr.RequestFailure,
+// while also adding the HostID value from the response.
+type RequestFailure interface {
+        awserr.RequestFailure
+
+        // Host ID is the S3 Host ID needed for debug, and contacting support
+        HostID() string
+}
+
+type requestFailure struct {
+        awserr.RequestFailure
+
+        hostID string
+}
+
+func (r requestFailure) Error() string {
+        extra := fmt.Sprintf("status code: %d, request id: %s, host id: %s",
+                r.StatusCode(), r.RequestID(), r.hostID)
+        return awserr.SprintError(r.Code(), r.Message(), extra, r.OrigErr())
+}
+func (r requestFailure) String() string {
+        return r.Error()
+}
+func (r requestFailure) HostID() string {
+        return r.hostID
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/waiters.go b/vendor/github.com/aws/aws-sdk-go/service/s3/waiters.go
new file mode 100644
index 0000000..cccfa8c
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/waiters.go
@@ -0,0 +1,214 @@
+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
+
+package s3
+
+import (
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+// WaitUntilBucketExists uses the Amazon S3 API operation
+// HeadBucket to wait for a condition to be met before returning.
+// If the condition is not meet within the max attempt window an error will
+// be returned.
+func (c *S3) WaitUntilBucketExists(input *HeadBucketInput) error {
+        return c.WaitUntilBucketExistsWithContext(aws.BackgroundContext(), input)
+}
+
+// WaitUntilBucketExistsWithContext is an extended version of WaitUntilBucketExists.
+// With the support for passing in a context and options to configure the
+// Waiter and the underlying request options.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) WaitUntilBucketExistsWithContext(ctx aws.Context, input *HeadBucketInput, opts ...request.WaiterOption) error {
+        w := request.Waiter{
+                Name:        "WaitUntilBucketExists",
+                MaxAttempts: 20,
+                Delay:       request.ConstantWaiterDelay(5 * time.Second),
+                Acceptors: []request.WaiterAcceptor{
+                        {
+                                State:    request.SuccessWaiterState,
+                                Matcher:  request.StatusWaiterMatch,
+                                Expected: 200,
+                        },
+                        {
+                                State:    request.SuccessWaiterState,
+                                Matcher:  request.StatusWaiterMatch,
+                                Expected: 301,
+                        },
+                        {
+                                State:    request.SuccessWaiterState,
+                                Matcher:  request.StatusWaiterMatch,
+                                Expected: 403,
+                        },
+                        {
+                                State:    request.RetryWaiterState,
+                                Matcher:  request.StatusWaiterMatch,
+                                Expected: 404,
+                        },
+                },
+                Logger: c.Config.Logger,
+                NewRequest: func(opts []request.Option) (*request.Request, error) {
+                        var inCpy *HeadBucketInput
+                        if input != nil {
+                                tmp := *input
+                                inCpy = &tmp
+                        }
+                        req, _ := c.HeadBucketRequest(inCpy)
+                        req.SetContext(ctx)
+                        req.ApplyOptions(opts...)
+                        return req, nil
+                },
+        }
+        w.ApplyOptions(opts...)
+
+        return w.WaitWithContext(ctx)
+}
+
+// WaitUntilBucketNotExists uses the Amazon S3 API operation
+// HeadBucket to wait for a condition to be met before returning.
+// If the condition is not meet within the max attempt window an error will
+// be returned.
+func (c *S3) WaitUntilBucketNotExists(input *HeadBucketInput) error {
+        return c.WaitUntilBucketNotExistsWithContext(aws.BackgroundContext(), input)
+}
+
+// WaitUntilBucketNotExistsWithContext is an extended version of WaitUntilBucketNotExists.
+// With the support for passing in a context and options to configure the
+// Waiter and the underlying request options.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) WaitUntilBucketNotExistsWithContext(ctx aws.Context, input *HeadBucketInput, opts ...request.WaiterOption) error {
+        w := request.Waiter{
+                Name:        "WaitUntilBucketNotExists",
+                MaxAttempts: 20,
+                Delay:       request.ConstantWaiterDelay(5 * time.Second),
+                Acceptors: []request.WaiterAcceptor{
+                        {
+                                State:    request.SuccessWaiterState,
+                                Matcher:  request.StatusWaiterMatch,
+                                Expected: 404,
+                        },
+                },
+                Logger: c.Config.Logger,
+                NewRequest: func(opts []request.Option) (*request.Request, error) {
+                        var inCpy *HeadBucketInput
+                        if input != nil {
+                                tmp := *input
+                                inCpy = &tmp
+                        }
+                        req, _ := c.HeadBucketRequest(inCpy)
+                        req.SetContext(ctx)
+                        req.ApplyOptions(opts...)
+                        return req, nil
+                },
+        }
+        w.ApplyOptions(opts...)
+
+        return w.WaitWithContext(ctx)
+}
+
+// WaitUntilObjectExists uses the Amazon S3 API operation
+// HeadObject to wait for a condition to be met before returning.
+// If the condition is not meet within the max attempt window an error will
+// be returned.
+func (c *S3) WaitUntilObjectExists(input *HeadObjectInput) error {
+        return c.WaitUntilObjectExistsWithContext(aws.BackgroundContext(), input)
+}
+
+// WaitUntilObjectExistsWithContext is an extended version of WaitUntilObjectExists.
+// With the support for passing in a context and options to configure the
+// Waiter and the underlying request options.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) WaitUntilObjectExistsWithContext(ctx aws.Context, input *HeadObjectInput, opts ...request.WaiterOption) error {
+        w := request.Waiter{
+                Name:        "WaitUntilObjectExists",
+                MaxAttempts: 20,
+                Delay:       request.ConstantWaiterDelay(5 * time.Second),
+                Acceptors: []request.WaiterAcceptor{
+                        {
+                                State:    request.SuccessWaiterState,
+                                Matcher:  request.StatusWaiterMatch,
+                                Expected: 200,
+                        },
+                        {
+                                State:    request.RetryWaiterState,
+                                Matcher:  request.StatusWaiterMatch,
+                                Expected: 404,
+                        },
+                },
+                Logger: c.Config.Logger,
+                NewRequest: func(opts []request.Option) (*request.Request, error) {
+                        var inCpy *HeadObjectInput
+                        if input != nil {
+                                tmp := *input
+                                inCpy = &tmp
+                        }
+                        req, _ := c.HeadObjectRequest(inCpy)
+                        req.SetContext(ctx)
+                        req.ApplyOptions(opts...)
+                        return req, nil
+                },
+        }
+        w.ApplyOptions(opts...)
+
+        return w.WaitWithContext(ctx)
+}
+
+// WaitUntilObjectNotExists uses the Amazon S3 API operation
+// HeadObject to wait for a condition to be met before returning.
+// If the condition is not meet within the max attempt window an error will
+// be returned.
+func (c *S3) WaitUntilObjectNotExists(input *HeadObjectInput) error {
+        return c.WaitUntilObjectNotExistsWithContext(aws.BackgroundContext(), input)
+}
+
+// WaitUntilObjectNotExistsWithContext is an extended version of WaitUntilObjectNotExists.
+// With the support for passing in a context and options to configure the
+// Waiter and the underlying request options.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *S3) WaitUntilObjectNotExistsWithContext(ctx aws.Context, input *HeadObjectInput, opts ...request.WaiterOption) error {
+        w := request.Waiter{
+                Name:        "WaitUntilObjectNotExists",
+                MaxAttempts: 20,
+                Delay:       request.ConstantWaiterDelay(5 * time.Second),
+                Acceptors: []request.WaiterAcceptor{
+                        {
+                                State:    request.SuccessWaiterState,
+                                Matcher:  request.StatusWaiterMatch,
+                                Expected: 404,
+                        },
+                },
+                Logger: c.Config.Logger,
+                NewRequest: func(opts []request.Option) (*request.Request, error) {
+                        var inCpy *HeadObjectInput
+                        if input != nil {
+                                tmp := *input
+                                inCpy = &tmp
+                        }
+                        req, _ := c.HeadObjectRequest(inCpy)
+                        req.SetContext(ctx)
+                        req.ApplyOptions(opts...)
+                        return req, nil
+                },
+        }
+        w.ApplyOptions(opts...)
+
+        return w.WaitWithContext(ctx)
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/service/sts/api.go b/vendor/github.com/aws/aws-sdk-go/service/sts/api.go
new file mode 100644
index 0000000..2de6528
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/sts/api.go
@@ -0,0 +1,2365 @@
+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
+
+package sts
+
+import (
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awsutil"
+        "github.com/aws/aws-sdk-go/aws/request"
+)
+
+const opAssumeRole = "AssumeRole"
+
+// AssumeRoleRequest generates a "aws/request.Request" representing the
+// client's request for the AssumeRole operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See AssumeRole for usage and error information.
+//
+// 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 AssumeRole method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the AssumeRoleRequest method.
+//    req, resp := client.AssumeRoleRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRole
+func (c *STS) AssumeRoleRequest(input *AssumeRoleInput) (req *request.Request, output *AssumeRoleOutput) {
+        op := &request.Operation{
+                Name:       opAssumeRole,
+                HTTPMethod: "POST",
+                HTTPPath:   "/",
+        }
+
+        if input == nil {
+                input = &AssumeRoleInput{}
+        }
+
+        output = &AssumeRoleOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// AssumeRole API operation for AWS Security Token Service.
+//
+// Returns a set of temporary security credentials (consisting of an access
+// key ID, a secret access key, and a security token) that you can use to access
+// AWS resources that you might not normally have access to. Typically, you
+// use AssumeRole for cross-account access or federation. For a comparison of
+// AssumeRole with the other APIs that produce temporary credentials, see Requesting
+// Temporary Security Credentials (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html)
+// and Comparing the AWS STS APIs (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#stsapi_comparison)
+// in the IAM User Guide.
+//
+// Important: You cannot call AssumeRole by using AWS root account credentials;
+// access is denied. You must use credentials for an IAM user or an IAM role
+// to call AssumeRole.
+//
+// For cross-account access, imagine that you own multiple accounts and need
+// to access resources in each account. You could create long-term credentials
+// in each account to access those resources. However, managing all those credentials
+// and remembering which one can access which account can be time consuming.
+// Instead, you can create one set of long-term credentials in one account and
+// then use temporary security credentials to access all the other accounts
+// by assuming roles in those accounts. For more information about roles, see
+// IAM Roles (Delegation and Federation) (http://docs.aws.amazon.com/IAM/latest/UserGuide/roles-toplevel.html)
+// in the IAM User Guide.
+//
+// For federation, you can, for example, grant single sign-on access to the
+// AWS Management Console. If you already have an identity and authentication
+// system in your corporate network, you don't have to recreate user identities
+// in AWS in order to grant those user identities access to AWS. Instead, after
+// a user has been authenticated, you call AssumeRole (and specify the role
+// with the appropriate permissions) to get temporary security credentials for
+// that user. With those temporary security credentials, you construct a sign-in
+// URL that users can use to access the console. For more information, see Common
+// Scenarios for Temporary Credentials (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html#sts-introduction)
+// in the IAM User Guide.
+//
+// The temporary security credentials are valid for the duration that you specified
+// when calling AssumeRole, which can be from 900 seconds (15 minutes) to a
+// maximum of 3600 seconds (1 hour). The default is 1 hour.
+//
+// The temporary security credentials created by AssumeRole can be used to make
+// API calls to any AWS service with the following exception: you cannot call
+// the STS service's GetFederationToken or GetSessionToken APIs.
+//
+// Optionally, you can pass an IAM access policy to this operation. If you choose
+// not to pass a policy, the temporary security credentials that are returned
+// by the operation have the permissions that are defined in the access policy
+// of the role that is being assumed. If you pass a policy to this operation,
+// the temporary security credentials that are returned by the operation have
+// the permissions that are allowed by both the access policy of the role that
+// is being assumed, and the policy that you pass. This gives you a way to further
+// restrict the permissions for the resulting temporary security credentials.
+// You cannot use the passed policy to grant permissions that are in excess
+// of those allowed by the access policy of the role that is being assumed.
+// For more information, see Permissions for AssumeRole, AssumeRoleWithSAML,
+// and AssumeRoleWithWebIdentity (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html)
+// in the IAM User Guide.
+//
+// To assume a role, your AWS account must be trusted by the role. The trust
+// relationship is defined in the role's trust policy when the role is created.
+// That trust policy states which accounts are allowed to delegate access to
+// this account's role.
+//
+// The user who wants to access the role must also have permissions delegated
+// from the role's administrator. If the user is in a different account than
+// the role, then the user's administrator must attach a policy that allows
+// the user to call AssumeRole on the ARN of the role in the other account.
+// If the user is in the same account as the role, then you can either attach
+// a policy to the user (identical to the previous different account user),
+// or you can add the user as a principal directly in the role's trust policy
+//
+// Using MFA with AssumeRole
+//
+// You can optionally include multi-factor authentication (MFA) information
+// when you call AssumeRole. This is useful for cross-account scenarios in which
+// you want to make sure that the user who is assuming the role has been authenticated
+// using an AWS MFA device. In that scenario, the trust policy of the role being
+// assumed includes a condition that tests for MFA authentication; if the caller
+// does not include valid MFA information, the request to assume the role is
+// denied. The condition in a trust policy that tests for MFA authentication
+// might look like the following example.
+//
+// "Condition": {"Bool": {"aws:MultiFactorAuthPresent": true}}
+//
+// For more information, see Configuring MFA-Protected API Access (http://docs.aws.amazon.com/IAM/latest/UserGuide/MFAProtectedAPI.html)
+// in the IAM User Guide guide.
+//
+// To use MFA with AssumeRole, you pass values for the SerialNumber and TokenCode
+// parameters. The SerialNumber value identifies the user's hardware or virtual
+// MFA device. The TokenCode is the time-based one-time password (TOTP) that
+// the MFA devices produces.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Security Token Service's
+// API operation AssumeRole for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeMalformedPolicyDocumentException "MalformedPolicyDocument"
+//   The request was rejected because the policy document was malformed. The error
+//   message describes the specific error.
+//
+//   * ErrCodePackedPolicyTooLargeException "PackedPolicyTooLarge"
+//   The request was rejected because the policy document was too large. The error
+//   message describes how big the policy document is, in packed form, as a percentage
+//   of what the API allows.
+//
+//   * ErrCodeRegionDisabledException "RegionDisabledException"
+//   STS is not activated in the requested region for the account that is being
+//   asked to generate credentials. The account administrator must use the IAM
+//   console to activate STS in that region. For more information, see Activating
+//   and Deactivating AWS STS in an AWS Region (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html)
+//   in the IAM User Guide.
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRole
+func (c *STS) AssumeRole(input *AssumeRoleInput) (*AssumeRoleOutput, error) {
+        req, out := c.AssumeRoleRequest(input)
+        return out, req.Send()
+}
+
+// AssumeRoleWithContext is the same as AssumeRole with the addition of
+// the ability to pass a context and additional request options.
+//
+// See AssumeRole for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *STS) AssumeRoleWithContext(ctx aws.Context, input *AssumeRoleInput, opts ...request.Option) (*AssumeRoleOutput, error) {
+        req, out := c.AssumeRoleRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opAssumeRoleWithSAML = "AssumeRoleWithSAML"
+
+// AssumeRoleWithSAMLRequest generates a "aws/request.Request" representing the
+// client's request for the AssumeRoleWithSAML operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See AssumeRoleWithSAML for usage and error information.
+//
+// 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 AssumeRoleWithSAML method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the AssumeRoleWithSAMLRequest method.
+//    req, resp := client.AssumeRoleWithSAMLRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRoleWithSAML
+func (c *STS) AssumeRoleWithSAMLRequest(input *AssumeRoleWithSAMLInput) (req *request.Request, output *AssumeRoleWithSAMLOutput) {
+        op := &request.Operation{
+                Name:       opAssumeRoleWithSAML,
+                HTTPMethod: "POST",
+                HTTPPath:   "/",
+        }
+
+        if input == nil {
+                input = &AssumeRoleWithSAMLInput{}
+        }
+
+        output = &AssumeRoleWithSAMLOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// AssumeRoleWithSAML API operation for AWS Security Token Service.
+//
+// Returns a set of temporary security credentials for users who have been authenticated
+// via a SAML authentication response. This operation provides a mechanism for
+// tying an enterprise identity store or directory to role-based AWS access
+// without user-specific credentials or configuration. For a comparison of AssumeRoleWithSAML
+// with the other APIs that produce temporary credentials, see Requesting Temporary
+// Security Credentials (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html)
+// and Comparing the AWS STS APIs (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#stsapi_comparison)
+// in the IAM User Guide.
+//
+// The temporary security credentials returned by this operation consist of
+// an access key ID, a secret access key, and a security token. Applications
+// can use these temporary security credentials to sign calls to AWS services.
+//
+// The temporary security credentials are valid for the duration that you specified
+// when calling AssumeRole, or until the time specified in the SAML authentication
+// response's SessionNotOnOrAfter value, whichever is shorter. The duration
+// can be from 900 seconds (15 minutes) to a maximum of 3600 seconds (1 hour).
+// The default is 1 hour.
+//
+// The temporary security credentials created by AssumeRoleWithSAML can be used
+// to make API calls to any AWS service with the following exception: you cannot
+// call the STS service's GetFederationToken or GetSessionToken APIs.
+//
+// Optionally, you can pass an IAM access policy to this operation. If you choose
+// not to pass a policy, the temporary security credentials that are returned
+// by the operation have the permissions that are defined in the access policy
+// of the role that is being assumed. If you pass a policy to this operation,
+// the temporary security credentials that are returned by the operation have
+// the permissions that are allowed by the intersection of both the access policy
+// of the role that is being assumed, and the policy that you pass. This means
+// that both policies must grant the permission for the action to be allowed.
+// This gives you a way to further restrict the permissions for the resulting
+// temporary security credentials. You cannot use the passed policy to grant
+// permissions that are in excess of those allowed by the access policy of the
+// role that is being assumed. For more information, see Permissions for AssumeRole,
+// AssumeRoleWithSAML, and AssumeRoleWithWebIdentity (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html)
+// in the IAM User Guide.
+//
+// Before your application can call AssumeRoleWithSAML, you must configure your
+// SAML identity provider (IdP) to issue the claims required by AWS. Additionally,
+// you must use AWS Identity and Access Management (IAM) to create a SAML provider
+// entity in your AWS account that represents your identity provider, and create
+// an IAM role that specifies this SAML provider in its trust policy.
+//
+// Calling AssumeRoleWithSAML does not require the use of AWS security credentials.
+// The identity of the caller is validated by using keys in the metadata document
+// that is uploaded for the SAML provider entity for your identity provider.
+//
+// Calling AssumeRoleWithSAML can result in an entry in your AWS CloudTrail
+// logs. The entry includes the value in the NameID element of the SAML assertion.
+// We recommend that you use a NameIDType that is not associated with any personally
+// identifiable information (PII). For example, you could instead use the Persistent
+// Identifier (urn:oasis:names:tc:SAML:2.0:nameid-format:persistent).
+//
+// For more information, see the following resources:
+//
+//    * About SAML 2.0-based Federation (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html)
+//    in the IAM User Guide.
+//
+//    * Creating SAML Identity Providers (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_saml.html)
+//    in the IAM User Guide.
+//
+//    * Configuring a Relying Party and Claims (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_saml_relying-party.html)
+//    in the IAM User Guide.
+//
+//    * Creating a Role for SAML 2.0 Federation (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)
+//    in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Security Token Service's
+// API operation AssumeRoleWithSAML for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeMalformedPolicyDocumentException "MalformedPolicyDocument"
+//   The request was rejected because the policy document was malformed. The error
+//   message describes the specific error.
+//
+//   * ErrCodePackedPolicyTooLargeException "PackedPolicyTooLarge"
+//   The request was rejected because the policy document was too large. The error
+//   message describes how big the policy document is, in packed form, as a percentage
+//   of what the API allows.
+//
+//   * ErrCodeIDPRejectedClaimException "IDPRejectedClaim"
+//   The identity provider (IdP) reported that authentication failed. This might
+//   be because the claim is invalid.
+//
+//   If this error is returned for the AssumeRoleWithWebIdentity operation, it
+//   can also mean that the claim has expired or has been explicitly revoked.
+//
+//   * ErrCodeInvalidIdentityTokenException "InvalidIdentityToken"
+//   The web identity token that was passed could not be validated by AWS. Get
+//   a new identity token from the identity provider and then retry the request.
+//
+//   * ErrCodeExpiredTokenException "ExpiredTokenException"
+//   The web identity token that was passed is expired or is not valid. Get a
+//   new identity token from the identity provider and then retry the request.
+//
+//   * ErrCodeRegionDisabledException "RegionDisabledException"
+//   STS is not activated in the requested region for the account that is being
+//   asked to generate credentials. The account administrator must use the IAM
+//   console to activate STS in that region. For more information, see Activating
+//   and Deactivating AWS STS in an AWS Region (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html)
+//   in the IAM User Guide.
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRoleWithSAML
+func (c *STS) AssumeRoleWithSAML(input *AssumeRoleWithSAMLInput) (*AssumeRoleWithSAMLOutput, error) {
+        req, out := c.AssumeRoleWithSAMLRequest(input)
+        return out, req.Send()
+}
+
+// AssumeRoleWithSAMLWithContext is the same as AssumeRoleWithSAML with the addition of
+// the ability to pass a context and additional request options.
+//
+// See AssumeRoleWithSAML for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *STS) AssumeRoleWithSAMLWithContext(ctx aws.Context, input *AssumeRoleWithSAMLInput, opts ...request.Option) (*AssumeRoleWithSAMLOutput, error) {
+        req, out := c.AssumeRoleWithSAMLRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opAssumeRoleWithWebIdentity = "AssumeRoleWithWebIdentity"
+
+// AssumeRoleWithWebIdentityRequest generates a "aws/request.Request" representing the
+// client's request for the AssumeRoleWithWebIdentity operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See AssumeRoleWithWebIdentity for usage and error information.
+//
+// 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 AssumeRoleWithWebIdentity method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the AssumeRoleWithWebIdentityRequest method.
+//    req, resp := client.AssumeRoleWithWebIdentityRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRoleWithWebIdentity
+func (c *STS) AssumeRoleWithWebIdentityRequest(input *AssumeRoleWithWebIdentityInput) (req *request.Request, output *AssumeRoleWithWebIdentityOutput) {
+        op := &request.Operation{
+                Name:       opAssumeRoleWithWebIdentity,
+                HTTPMethod: "POST",
+                HTTPPath:   "/",
+        }
+
+        if input == nil {
+                input = &AssumeRoleWithWebIdentityInput{}
+        }
+
+        output = &AssumeRoleWithWebIdentityOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// AssumeRoleWithWebIdentity API operation for AWS Security Token Service.
+//
+// Returns a set of temporary security credentials for users who have been authenticated
+// in a mobile or web application with a web identity provider, such as Amazon
+// Cognito, Login with Amazon, Facebook, Google, or any OpenID Connect-compatible
+// identity provider.
+//
+// For mobile applications, we recommend that you use Amazon Cognito. You can
+// use Amazon Cognito with the AWS SDK for iOS (http://aws.amazon.com/sdkforios/)
+// and the AWS SDK for Android (http://aws.amazon.com/sdkforandroid/) to uniquely
+// identify a user and supply the user with a consistent identity throughout
+// the lifetime of an application.
+//
+// To learn more about Amazon Cognito, see Amazon Cognito Overview (http://docs.aws.amazon.com/mobile/sdkforandroid/developerguide/cognito-auth.html#d0e840)
+// in the AWS SDK for Android Developer Guide guide and Amazon Cognito Overview
+// (http://docs.aws.amazon.com/mobile/sdkforios/developerguide/cognito-auth.html#d0e664)
+// in the AWS SDK for iOS Developer Guide.
+//
+// Calling AssumeRoleWithWebIdentity does not require the use of AWS security
+// credentials. Therefore, you can distribute an application (for example, on
+// mobile devices) that requests temporary security credentials without including
+// long-term AWS credentials in the application, and without deploying server-based
+// proxy services that use long-term AWS credentials. Instead, the identity
+// of the caller is validated by using a token from the web identity provider.
+// For a comparison of AssumeRoleWithWebIdentity with the other APIs that produce
+// temporary credentials, see Requesting Temporary Security Credentials (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html)
+// and Comparing the AWS STS APIs (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#stsapi_comparison)
+// in the IAM User Guide.
+//
+// The temporary security credentials returned by this API consist of an access
+// key ID, a secret access key, and a security token. Applications can use these
+// temporary security credentials to sign calls to AWS service APIs.
+//
+// The credentials are valid for the duration that you specified when calling
+// AssumeRoleWithWebIdentity, which can be from 900 seconds (15 minutes) to
+// a maximum of 3600 seconds (1 hour). The default is 1 hour.
+//
+// The temporary security credentials created by AssumeRoleWithWebIdentity can
+// be used to make API calls to any AWS service with the following exception:
+// you cannot call the STS service's GetFederationToken or GetSessionToken APIs.
+//
+// Optionally, you can pass an IAM access policy to this operation. If you choose
+// not to pass a policy, the temporary security credentials that are returned
+// by the operation have the permissions that are defined in the access policy
+// of the role that is being assumed. If you pass a policy to this operation,
+// the temporary security credentials that are returned by the operation have
+// the permissions that are allowed by both the access policy of the role that
+// is being assumed, and the policy that you pass. This gives you a way to further
+// restrict the permissions for the resulting temporary security credentials.
+// You cannot use the passed policy to grant permissions that are in excess
+// of those allowed by the access policy of the role that is being assumed.
+// For more information, see Permissions for AssumeRole, AssumeRoleWithSAML,
+// and AssumeRoleWithWebIdentity (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html)
+// in the IAM User Guide.
+//
+// Before your application can call AssumeRoleWithWebIdentity, you must have
+// an identity token from a supported identity provider and create a role that
+// the application can assume. The role that your application assumes must trust
+// the identity provider that is associated with the identity token. In other
+// words, the identity provider must be specified in the role's trust policy.
+//
+// Calling AssumeRoleWithWebIdentity can result in an entry in your AWS CloudTrail
+// logs. The entry includes the Subject (http://openid.net/specs/openid-connect-core-1_0.html#Claims)
+// of the provided Web Identity Token. We recommend that you avoid using any
+// personally identifiable information (PII) in this field. For example, you
+// could instead use a GUID or a pairwise identifier, as suggested in the OIDC
+// specification (http://openid.net/specs/openid-connect-core-1_0.html#SubjectIDTypes).
+//
+// For more information about how to use web identity federation and the AssumeRoleWithWebIdentity
+// API, see the following resources:
+//
+//    * Using Web Identity Federation APIs for Mobile Apps (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc_manual.html)
+//    and Federation Through a Web-based Identity Provider (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_assumerolewithwebidentity).
+//
+//
+//    *  Web Identity Federation Playground (https://web-identity-federation-playground.s3.amazonaws.com/index.html).
+//    This interactive website lets you walk through the process of authenticating
+//    via Login with Amazon, Facebook, or Google, getting temporary security
+//    credentials, and then using those credentials to make a request to AWS.
+//
+//
+//    * AWS SDK for iOS (http://aws.amazon.com/sdkforios/) and AWS SDK for Android
+//    (http://aws.amazon.com/sdkforandroid/). These toolkits contain sample
+//    apps that show how to invoke the identity providers, and then how to use
+//    the information from these providers to get and use temporary security
+//    credentials.
+//
+//    * Web Identity Federation with Mobile Applications (http://aws.amazon.com/articles/4617974389850313).
+//    This article discusses web identity federation and shows an example of
+//    how to use web identity federation to get access to content in Amazon
+//    S3.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Security Token Service's
+// API operation AssumeRoleWithWebIdentity for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeMalformedPolicyDocumentException "MalformedPolicyDocument"
+//   The request was rejected because the policy document was malformed. The error
+//   message describes the specific error.
+//
+//   * ErrCodePackedPolicyTooLargeException "PackedPolicyTooLarge"
+//   The request was rejected because the policy document was too large. The error
+//   message describes how big the policy document is, in packed form, as a percentage
+//   of what the API allows.
+//
+//   * ErrCodeIDPRejectedClaimException "IDPRejectedClaim"
+//   The identity provider (IdP) reported that authentication failed. This might
+//   be because the claim is invalid.
+//
+//   If this error is returned for the AssumeRoleWithWebIdentity operation, it
+//   can also mean that the claim has expired or has been explicitly revoked.
+//
+//   * ErrCodeIDPCommunicationErrorException "IDPCommunicationError"
+//   The request could not be fulfilled because the non-AWS identity provider
+//   (IDP) that was asked to verify the incoming identity token could not be reached.
+//   This is often a transient error caused by network conditions. Retry the request
+//   a limited number of times so that you don't exceed the request rate. If the
+//   error persists, the non-AWS identity provider might be down or not responding.
+//
+//   * ErrCodeInvalidIdentityTokenException "InvalidIdentityToken"
+//   The web identity token that was passed could not be validated by AWS. Get
+//   a new identity token from the identity provider and then retry the request.
+//
+//   * ErrCodeExpiredTokenException "ExpiredTokenException"
+//   The web identity token that was passed is expired or is not valid. Get a
+//   new identity token from the identity provider and then retry the request.
+//
+//   * ErrCodeRegionDisabledException "RegionDisabledException"
+//   STS is not activated in the requested region for the account that is being
+//   asked to generate credentials. The account administrator must use the IAM
+//   console to activate STS in that region. For more information, see Activating
+//   and Deactivating AWS STS in an AWS Region (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html)
+//   in the IAM User Guide.
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRoleWithWebIdentity
+func (c *STS) AssumeRoleWithWebIdentity(input *AssumeRoleWithWebIdentityInput) (*AssumeRoleWithWebIdentityOutput, error) {
+        req, out := c.AssumeRoleWithWebIdentityRequest(input)
+        return out, req.Send()
+}
+
+// AssumeRoleWithWebIdentityWithContext is the same as AssumeRoleWithWebIdentity with the addition of
+// the ability to pass a context and additional request options.
+//
+// See AssumeRoleWithWebIdentity for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *STS) AssumeRoleWithWebIdentityWithContext(ctx aws.Context, input *AssumeRoleWithWebIdentityInput, opts ...request.Option) (*AssumeRoleWithWebIdentityOutput, error) {
+        req, out := c.AssumeRoleWithWebIdentityRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opDecodeAuthorizationMessage = "DecodeAuthorizationMessage"
+
+// DecodeAuthorizationMessageRequest generates a "aws/request.Request" representing the
+// client's request for the DecodeAuthorizationMessage operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See DecodeAuthorizationMessage for usage and error information.
+//
+// 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 DecodeAuthorizationMessage method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the DecodeAuthorizationMessageRequest method.
+//    req, resp := client.DecodeAuthorizationMessageRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/DecodeAuthorizationMessage
+func (c *STS) DecodeAuthorizationMessageRequest(input *DecodeAuthorizationMessageInput) (req *request.Request, output *DecodeAuthorizationMessageOutput) {
+        op := &request.Operation{
+                Name:       opDecodeAuthorizationMessage,
+                HTTPMethod: "POST",
+                HTTPPath:   "/",
+        }
+
+        if input == nil {
+                input = &DecodeAuthorizationMessageInput{}
+        }
+
+        output = &DecodeAuthorizationMessageOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// DecodeAuthorizationMessage API operation for AWS Security Token Service.
+//
+// Decodes additional information about the authorization status of a request
+// from an encoded message returned in response to an AWS request.
+//
+// For example, if a user is not authorized to perform an action that he or
+// she has requested, the request returns a Client.UnauthorizedOperation response
+// (an HTTP 403 response). Some AWS actions additionally return an encoded message
+// that can provide details about this authorization failure.
+//
+// Only certain AWS actions return an encoded authorization message. The documentation
+// for an individual action indicates whether that action returns an encoded
+// message in addition to returning an HTTP code.
+//
+// The message is encoded because the details of the authorization status can
+// constitute privileged information that the user who requested the action
+// should not see. To decode an authorization status message, a user must be
+// granted permissions via an IAM policy to request the DecodeAuthorizationMessage
+// (sts:DecodeAuthorizationMessage) action.
+//
+// The decoded message includes the following type of information:
+//
+//    * Whether the request was denied due to an explicit deny or due to the
+//    absence of an explicit allow. For more information, see Determining Whether
+//    a Request is Allowed or Denied (http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html#policy-eval-denyallow)
+//    in the IAM User Guide.
+//
+//    * The principal who made the request.
+//
+//    * The requested action.
+//
+//    * The requested resource.
+//
+//    * The values of condition keys in the context of the user's request.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Security Token Service's
+// API operation DecodeAuthorizationMessage for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeInvalidAuthorizationMessageException "InvalidAuthorizationMessageException"
+//   The error returned if the message passed to DecodeAuthorizationMessage was
+//   invalid. This can happen if the token contains invalid characters, such as
+//   linebreaks.
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/DecodeAuthorizationMessage
+func (c *STS) DecodeAuthorizationMessage(input *DecodeAuthorizationMessageInput) (*DecodeAuthorizationMessageOutput, error) {
+        req, out := c.DecodeAuthorizationMessageRequest(input)
+        return out, req.Send()
+}
+
+// DecodeAuthorizationMessageWithContext is the same as DecodeAuthorizationMessage with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DecodeAuthorizationMessage for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *STS) DecodeAuthorizationMessageWithContext(ctx aws.Context, input *DecodeAuthorizationMessageInput, opts ...request.Option) (*DecodeAuthorizationMessageOutput, error) {
+        req, out := c.DecodeAuthorizationMessageRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetCallerIdentity = "GetCallerIdentity"
+
+// GetCallerIdentityRequest generates a "aws/request.Request" representing the
+// client's request for the GetCallerIdentity operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetCallerIdentity for usage and error information.
+//
+// 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 GetCallerIdentity method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetCallerIdentityRequest method.
+//    req, resp := client.GetCallerIdentityRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetCallerIdentity
+func (c *STS) GetCallerIdentityRequest(input *GetCallerIdentityInput) (req *request.Request, output *GetCallerIdentityOutput) {
+        op := &request.Operation{
+                Name:       opGetCallerIdentity,
+                HTTPMethod: "POST",
+                HTTPPath:   "/",
+        }
+
+        if input == nil {
+                input = &GetCallerIdentityInput{}
+        }
+
+        output = &GetCallerIdentityOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetCallerIdentity API operation for AWS Security Token Service.
+//
+// Returns details about the IAM identity whose credentials are used to call
+// the API.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Security Token Service's
+// API operation GetCallerIdentity for usage and error information.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetCallerIdentity
+func (c *STS) GetCallerIdentity(input *GetCallerIdentityInput) (*GetCallerIdentityOutput, error) {
+        req, out := c.GetCallerIdentityRequest(input)
+        return out, req.Send()
+}
+
+// GetCallerIdentityWithContext is the same as GetCallerIdentity with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetCallerIdentity for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *STS) GetCallerIdentityWithContext(ctx aws.Context, input *GetCallerIdentityInput, opts ...request.Option) (*GetCallerIdentityOutput, error) {
+        req, out := c.GetCallerIdentityRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetFederationToken = "GetFederationToken"
+
+// GetFederationTokenRequest generates a "aws/request.Request" representing the
+// client's request for the GetFederationToken operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetFederationToken for usage and error information.
+//
+// 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 GetFederationToken method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetFederationTokenRequest method.
+//    req, resp := client.GetFederationTokenRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetFederationToken
+func (c *STS) GetFederationTokenRequest(input *GetFederationTokenInput) (req *request.Request, output *GetFederationTokenOutput) {
+        op := &request.Operation{
+                Name:       opGetFederationToken,
+                HTTPMethod: "POST",
+                HTTPPath:   "/",
+        }
+
+        if input == nil {
+                input = &GetFederationTokenInput{}
+        }
+
+        output = &GetFederationTokenOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetFederationToken API operation for AWS Security Token Service.
+//
+// Returns a set of temporary security credentials (consisting of an access
+// key ID, a secret access key, and a security token) for a federated user.
+// A typical use is in a proxy application that gets temporary security credentials
+// on behalf of distributed applications inside a corporate network. Because
+// you must call the GetFederationToken action using the long-term security
+// credentials of an IAM user, this call is appropriate in contexts where those
+// credentials can be safely stored, usually in a server-based application.
+// For a comparison of GetFederationToken with the other APIs that produce temporary
+// credentials, see Requesting Temporary Security Credentials (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html)
+// and Comparing the AWS STS APIs (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#stsapi_comparison)
+// in the IAM User Guide.
+//
+// If you are creating a mobile-based or browser-based app that can authenticate
+// users using a web identity provider like Login with Amazon, Facebook, Google,
+// or an OpenID Connect-compatible identity provider, we recommend that you
+// use Amazon Cognito (http://aws.amazon.com/cognito/) or AssumeRoleWithWebIdentity.
+// For more information, see Federation Through a Web-based Identity Provider
+// (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_assumerolewithwebidentity).
+//
+// The GetFederationToken action must be called by using the long-term AWS security
+// credentials of an IAM user. You can also call GetFederationToken using the
+// security credentials of an AWS root account, but we do not recommended it.
+// Instead, we recommend that you create an IAM user for the purpose of the
+// proxy application and then attach a policy to the IAM user that limits federated
+// users to only the actions and resources that they need access to. For more
+// information, see IAM Best Practices (http://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html)
+// in the IAM User Guide.
+//
+// The temporary security credentials that are obtained by using the long-term
+// credentials of an IAM user are valid for the specified duration, from 900
+// seconds (15 minutes) up to a maximium of 129600 seconds (36 hours). The default
+// is 43200 seconds (12 hours). Temporary credentials that are obtained by using
+// AWS root account credentials have a maximum duration of 3600 seconds (1 hour).
+//
+// The temporary security credentials created by GetFederationToken can be used
+// to make API calls to any AWS service with the following exceptions:
+//
+//    * You cannot use these credentials to call any IAM APIs.
+//
+//    * You cannot call any STS APIs except GetCallerIdentity.
+//
+// Permissions
+//
+// The permissions for the temporary security credentials returned by GetFederationToken
+// are determined by a combination of the following:
+//
+//    * The policy or policies that are attached to the IAM user whose credentials
+//    are used to call GetFederationToken.
+//
+//    * The policy that is passed as a parameter in the call.
+//
+// The passed policy is attached to the temporary security credentials that
+// result from the GetFederationToken API call--that is, to the federated user.
+// When the federated user makes an AWS request, AWS evaluates the policy attached
+// to the federated user in combination with the policy or policies attached
+// to the IAM user whose credentials were used to call GetFederationToken. AWS
+// allows the federated user's request only when both the federated user and
+// the IAM user are explicitly allowed to perform the requested action. The
+// passed policy cannot grant more permissions than those that are defined in
+// the IAM user policy.
+//
+// A typical use case is that the permissions of the IAM user whose credentials
+// are used to call GetFederationToken are designed to allow access to all the
+// actions and resources that any federated user will need. Then, for individual
+// users, you pass a policy to the operation that scopes down the permissions
+// to a level that's appropriate to that individual user, using a policy that
+// allows only a subset of permissions that are granted to the IAM user.
+//
+// If you do not pass a policy, the resulting temporary security credentials
+// have no effective permissions. The only exception is when the temporary security
+// credentials are used to access a resource that has a resource-based policy
+// that specifically allows the federated user to access the resource.
+//
+// For more information about how permissions work, see Permissions for GetFederationToken
+// (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_getfederationtoken.html).
+// For information about using GetFederationToken to create temporary security
+// credentials, see GetFederationToken—Federation Through a Custom Identity
+// Broker (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_getfederationtoken).
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Security Token Service's
+// API operation GetFederationToken for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeMalformedPolicyDocumentException "MalformedPolicyDocument"
+//   The request was rejected because the policy document was malformed. The error
+//   message describes the specific error.
+//
+//   * ErrCodePackedPolicyTooLargeException "PackedPolicyTooLarge"
+//   The request was rejected because the policy document was too large. The error
+//   message describes how big the policy document is, in packed form, as a percentage
+//   of what the API allows.
+//
+//   * ErrCodeRegionDisabledException "RegionDisabledException"
+//   STS is not activated in the requested region for the account that is being
+//   asked to generate credentials. The account administrator must use the IAM
+//   console to activate STS in that region. For more information, see Activating
+//   and Deactivating AWS STS in an AWS Region (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html)
+//   in the IAM User Guide.
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetFederationToken
+func (c *STS) GetFederationToken(input *GetFederationTokenInput) (*GetFederationTokenOutput, error) {
+        req, out := c.GetFederationTokenRequest(input)
+        return out, req.Send()
+}
+
+// GetFederationTokenWithContext is the same as GetFederationToken with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetFederationToken for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *STS) GetFederationTokenWithContext(ctx aws.Context, input *GetFederationTokenInput, opts ...request.Option) (*GetFederationTokenOutput, error) {
+        req, out := c.GetFederationTokenRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+const opGetSessionToken = "GetSessionToken"
+
+// GetSessionTokenRequest generates a "aws/request.Request" representing the
+// client's request for the GetSessionToken operation. The "output" return
+// value can be used to capture response data after the request's "Send" method
+// is called.
+//
+// See GetSessionToken for usage and error information.
+//
+// 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 GetSessionToken method directly
+// instead.
+//
+// Note: You must call the "Send" method on the returned request object in order
+// to execute the request.
+//
+//    // Example sending a request using the GetSessionTokenRequest method.
+//    req, resp := client.GetSessionTokenRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetSessionToken
+func (c *STS) GetSessionTokenRequest(input *GetSessionTokenInput) (req *request.Request, output *GetSessionTokenOutput) {
+        op := &request.Operation{
+                Name:       opGetSessionToken,
+                HTTPMethod: "POST",
+                HTTPPath:   "/",
+        }
+
+        if input == nil {
+                input = &GetSessionTokenInput{}
+        }
+
+        output = &GetSessionTokenOutput{}
+        req = c.newRequest(op, input, output)
+        return
+}
+
+// GetSessionToken API operation for AWS Security Token Service.
+//
+// Returns a set of temporary credentials for an AWS account or IAM user. The
+// credentials consist of an access key ID, a secret access key, and a security
+// token. Typically, you use GetSessionToken if you want to use MFA to protect
+// programmatic calls to specific AWS APIs like Amazon EC2 StopInstances. MFA-enabled
+// IAM users would need to call GetSessionToken and submit an MFA code that
+// is associated with their MFA device. Using the temporary security credentials
+// that are returned from the call, IAM users can then make programmatic calls
+// to APIs that require MFA authentication. If you do not supply a correct MFA
+// code, then the API returns an access denied error. For a comparison of GetSessionToken
+// with the other APIs that produce temporary credentials, see Requesting Temporary
+// Security Credentials (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html)
+// and Comparing the AWS STS APIs (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#stsapi_comparison)
+// in the IAM User Guide.
+//
+// The GetSessionToken action must be called by using the long-term AWS security
+// credentials of the AWS account or an IAM user. Credentials that are created
+// by IAM users are valid for the duration that you specify, from 900 seconds
+// (15 minutes) up to a maximum of 129600 seconds (36 hours), with a default
+// of 43200 seconds (12 hours); credentials that are created by using account
+// credentials can range from 900 seconds (15 minutes) up to a maximum of 3600
+// seconds (1 hour), with a default of 1 hour.
+//
+// The temporary security credentials created by GetSessionToken can be used
+// to make API calls to any AWS service with the following exceptions:
+//
+//    * You cannot call any IAM APIs unless MFA authentication information is
+//    included in the request.
+//
+//    * You cannot call any STS API exceptAssumeRole or GetCallerIdentity.
+//
+// We recommend that you do not call GetSessionToken with root account credentials.
+// Instead, follow our best practices (http://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#create-iam-users)
+// by creating one or more IAM users, giving them the necessary permissions,
+// and using IAM users for everyday interaction with AWS.
+//
+// The permissions associated with the temporary security credentials returned
+// by GetSessionToken are based on the permissions associated with account or
+// IAM user whose credentials are used to call the action. If GetSessionToken
+// is called using root account credentials, the temporary credentials have
+// root account permissions. Similarly, if GetSessionToken is called using the
+// credentials of an IAM user, the temporary credentials have the same permissions
+// as the IAM user.
+//
+// For more information about using GetSessionToken to create temporary credentials,
+// go to Temporary Credentials for Users in Untrusted Environments (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_getsessiontoken)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Security Token Service's
+// API operation GetSessionToken for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeRegionDisabledException "RegionDisabledException"
+//   STS is not activated in the requested region for the account that is being
+//   asked to generate credentials. The account administrator must use the IAM
+//   console to activate STS in that region. For more information, see Activating
+//   and Deactivating AWS STS in an AWS Region (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html)
+//   in the IAM User Guide.
+//
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetSessionToken
+func (c *STS) GetSessionToken(input *GetSessionTokenInput) (*GetSessionTokenOutput, error) {
+        req, out := c.GetSessionTokenRequest(input)
+        return out, req.Send()
+}
+
+// GetSessionTokenWithContext is the same as GetSessionToken with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetSessionToken for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// 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 *STS) GetSessionTokenWithContext(ctx aws.Context, input *GetSessionTokenInput, opts ...request.Option) (*GetSessionTokenOutput, error) {
+        req, out := c.GetSessionTokenRequest(input)
+        req.SetContext(ctx)
+        req.ApplyOptions(opts...)
+        return out, req.Send()
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRoleRequest
+type AssumeRoleInput struct {
+        _ struct{} `type:"structure"`
+
+        // The duration, in seconds, of the role session. The value can range from 900
+        // seconds (15 minutes) to 3600 seconds (1 hour). By default, the value is set
+        // to 3600 seconds.
+        //
+        // This is separate from the duration of a console session that you might request
+        // using the returned credentials. The request to the federation endpoint for
+        // a console sign-in token takes a SessionDuration parameter that specifies
+        // the maximum length of the console session, separately from the DurationSeconds
+        // parameter on this API. For more information, see Creating a URL that Enables
+        // Federated Users to Access the AWS Management Console (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_enable-console-custom-url.html)
+        // in the IAM User Guide.
+        DurationSeconds *int64 `min:"900" type:"integer"`
+
+        // A unique identifier that is used by third parties when assuming roles in
+        // their customers' accounts. For each role that the third party can assume,
+        // they should instruct their customers to ensure the role's trust policy checks
+        // for the external ID that the third party generated. Each time the third party
+        // assumes the role, they should pass the customer's external ID. The external
+        // ID is useful in order to help third parties bind a role to the customer who
+        // created it. For more information about the external ID, see How to Use an
+        // External ID When Granting Access to Your AWS Resources to a Third Party (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html)
+        // in the IAM User Guide.
+        //
+        // The regex used to validated this parameter is a string of characters consisting
+        // of upper- and lower-case alphanumeric characters with no spaces. You can
+        // also include underscores or any of the following characters: =,.@:\/-
+        ExternalId *string `min:"2" type:"string"`
+
+        // An IAM policy in JSON format.
+        //
+        // This parameter is optional. If you pass a policy, the temporary security
+        // credentials that are returned by the operation have the permissions that
+        // are allowed by both (the intersection of) the access policy of the role that
+        // is being assumed, and the policy that you pass. This gives you a way to further
+        // restrict the permissions for the resulting temporary security credentials.
+        // You cannot use the passed policy to grant permissions that are in excess
+        // of those allowed by the access policy of the role that is being assumed.
+        // For more information, see Permissions for AssumeRole, AssumeRoleWithSAML,
+        // and AssumeRoleWithWebIdentity (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html)
+        // in the IAM User Guide.
+        //
+        // The format for this parameter, as described by its regex pattern, is a string
+        // of characters up to 2048 characters in length. The characters can be any
+        // ASCII character from the space character to the end of the valid character
+        // list (\u0020-\u00FF). It can also include the tab (\u0009), linefeed (\u000A),
+        // and carriage return (\u000D) characters.
+        //
+        // The policy plain text must be 2048 bytes or shorter. However, an internal
+        // conversion compresses it into a packed binary format with a separate limit.
+        // The PackedPolicySize response element indicates by percentage how close to
+        // the upper size limit the policy is, with 100% equaling the maximum allowed
+        // size.
+        Policy *string `min:"1" type:"string"`
+
+        // The Amazon Resource Name (ARN) of the role to assume.
+        //
+        // RoleArn is a required field
+        RoleArn *string `min:"20" type:"string" required:"true"`
+
+        // An identifier for the assumed role session.
+        //
+        // Use the role session name to uniquely identify a session when the same role
+        // is assumed by different principals or for different reasons. In cross-account
+        // scenarios, the role session name is visible to, and can be logged by the
+        // account that owns the role. The role session name is also used in the ARN
+        // of the assumed role principal. This means that subsequent cross-account API
+        // requests using the temporary security credentials will expose the role session
+        // name to the external account in their CloudTrail logs.
+        //
+        // The regex used to validate this parameter is a string of characters consisting
+        // of upper- and lower-case alphanumeric characters with no spaces. You can
+        // also include underscores or any of the following characters: =,.@-
+        //
+        // RoleSessionName is a required field
+        RoleSessionName *string `min:"2" type:"string" required:"true"`
+
+        // The identification number of the MFA device that is associated with the user
+        // who is making the AssumeRole call. Specify this value if the trust policy
+        // of the role being assumed includes a condition that requires MFA authentication.
+        // The value is either the serial number for a hardware device (such as GAHT12345678)
+        // or an Amazon Resource Name (ARN) for a virtual device (such as arn:aws:iam::123456789012:mfa/user).
+        //
+        // The regex used to validate this parameter is a string of characters consisting
+        // of upper- and lower-case alphanumeric characters with no spaces. You can
+        // also include underscores or any of the following characters: =,.@-
+        SerialNumber *string `min:"9" type:"string"`
+
+        // The value provided by the MFA device, if the trust policy of the role being
+        // assumed requires MFA (that is, if the policy includes a condition that tests
+        // for MFA). If the role being assumed requires MFA and if the TokenCode value
+        // is missing or expired, the AssumeRole call returns an "access denied" error.
+        //
+        // The format for this parameter, as described by its regex pattern, is a sequence
+        // of six numeric digits.
+        TokenCode *string `min:"6" type:"string"`
+}
+
+// String returns the string representation
+func (s AssumeRoleInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AssumeRoleInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *AssumeRoleInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "AssumeRoleInput"}
+        if s.DurationSeconds != nil && *s.DurationSeconds < 900 {
+                invalidParams.Add(request.NewErrParamMinValue("DurationSeconds", 900))
+        }
+        if s.ExternalId != nil && len(*s.ExternalId) < 2 {
+                invalidParams.Add(request.NewErrParamMinLen("ExternalId", 2))
+        }
+        if s.Policy != nil && len(*s.Policy) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Policy", 1))
+        }
+        if s.RoleArn == nil {
+                invalidParams.Add(request.NewErrParamRequired("RoleArn"))
+        }
+        if s.RoleArn != nil && len(*s.RoleArn) < 20 {
+                invalidParams.Add(request.NewErrParamMinLen("RoleArn", 20))
+        }
+        if s.RoleSessionName == nil {
+                invalidParams.Add(request.NewErrParamRequired("RoleSessionName"))
+        }
+        if s.RoleSessionName != nil && len(*s.RoleSessionName) < 2 {
+                invalidParams.Add(request.NewErrParamMinLen("RoleSessionName", 2))
+        }
+        if s.SerialNumber != nil && len(*s.SerialNumber) < 9 {
+                invalidParams.Add(request.NewErrParamMinLen("SerialNumber", 9))
+        }
+        if s.TokenCode != nil && len(*s.TokenCode) < 6 {
+                invalidParams.Add(request.NewErrParamMinLen("TokenCode", 6))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetDurationSeconds sets the DurationSeconds field's value.
+func (s *AssumeRoleInput) SetDurationSeconds(v int64) *AssumeRoleInput {
+        s.DurationSeconds = &v
+        return s
+}
+
+// SetExternalId sets the ExternalId field's value.
+func (s *AssumeRoleInput) SetExternalId(v string) *AssumeRoleInput {
+        s.ExternalId = &v
+        return s
+}
+
+// SetPolicy sets the Policy field's value.
+func (s *AssumeRoleInput) SetPolicy(v string) *AssumeRoleInput {
+        s.Policy = &v
+        return s
+}
+
+// SetRoleArn sets the RoleArn field's value.
+func (s *AssumeRoleInput) SetRoleArn(v string) *AssumeRoleInput {
+        s.RoleArn = &v
+        return s
+}
+
+// SetRoleSessionName sets the RoleSessionName field's value.
+func (s *AssumeRoleInput) SetRoleSessionName(v string) *AssumeRoleInput {
+        s.RoleSessionName = &v
+        return s
+}
+
+// SetSerialNumber sets the SerialNumber field's value.
+func (s *AssumeRoleInput) SetSerialNumber(v string) *AssumeRoleInput {
+        s.SerialNumber = &v
+        return s
+}
+
+// SetTokenCode sets the TokenCode field's value.
+func (s *AssumeRoleInput) SetTokenCode(v string) *AssumeRoleInput {
+        s.TokenCode = &v
+        return s
+}
+
+// Contains the response to a successful AssumeRole request, including temporary
+// AWS credentials that can be used to make AWS requests.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRoleResponse
+type AssumeRoleOutput struct {
+        _ struct{} `type:"structure"`
+
+        // The Amazon Resource Name (ARN) and the assumed role ID, which are identifiers
+        // that you can use to refer to the resulting temporary security credentials.
+        // For example, you can reference these credentials as a principal in a resource-based
+        // policy by using the ARN or assumed role ID. The ARN and ID include the RoleSessionName
+        // that you specified when you called AssumeRole.
+        AssumedRoleUser *AssumedRoleUser `type:"structure"`
+
+        // The temporary security credentials, which include an access key ID, a secret
+        // access key, and a security (or session) token.
+        //
+        // Note: The size of the security token that STS APIs return is not fixed. We
+        // strongly recommend that you make no assumptions about the maximum size. As
+        // of this writing, the typical size is less than 4096 bytes, but that can vary.
+        // Also, future updates to AWS might require larger sizes.
+        Credentials *Credentials `type:"structure"`
+
+        // A percentage value that indicates the size of the policy in packed form.
+        // The service rejects any policy with a packed size greater than 100 percent,
+        // which means the policy exceeded the allowed space.
+        PackedPolicySize *int64 `type:"integer"`
+}
+
+// String returns the string representation
+func (s AssumeRoleOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AssumeRoleOutput) GoString() string {
+        return s.String()
+}
+
+// SetAssumedRoleUser sets the AssumedRoleUser field's value.
+func (s *AssumeRoleOutput) SetAssumedRoleUser(v *AssumedRoleUser) *AssumeRoleOutput {
+        s.AssumedRoleUser = v
+        return s
+}
+
+// SetCredentials sets the Credentials field's value.
+func (s *AssumeRoleOutput) SetCredentials(v *Credentials) *AssumeRoleOutput {
+        s.Credentials = v
+        return s
+}
+
+// SetPackedPolicySize sets the PackedPolicySize field's value.
+func (s *AssumeRoleOutput) SetPackedPolicySize(v int64) *AssumeRoleOutput {
+        s.PackedPolicySize = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRoleWithSAMLRequest
+type AssumeRoleWithSAMLInput struct {
+        _ struct{} `type:"structure"`
+
+        // The duration, in seconds, of the role session. The value can range from 900
+        // seconds (15 minutes) to 3600 seconds (1 hour). By default, the value is set
+        // to 3600 seconds. An expiration can also be specified in the SAML authentication
+        // response's SessionNotOnOrAfter value. The actual expiration time is whichever
+        // value is shorter.
+        //
+        // This is separate from the duration of a console session that you might request
+        // using the returned credentials. The request to the federation endpoint for
+        // a console sign-in token takes a SessionDuration parameter that specifies
+        // the maximum length of the console session, separately from the DurationSeconds
+        // parameter on this API. For more information, see Enabling SAML 2.0 Federated
+        // Users to Access the AWS Management Console (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_enable-console-saml.html)
+        // in the IAM User Guide.
+        DurationSeconds *int64 `min:"900" type:"integer"`
+
+        // An IAM policy in JSON format.
+        //
+        // The policy parameter is optional. If you pass a policy, the temporary security
+        // credentials that are returned by the operation have the permissions that
+        // are allowed by both the access policy of the role that is being assumed,
+        // and the policy that you pass. This gives you a way to further restrict the
+        // permissions for the resulting temporary security credentials. You cannot
+        // use the passed policy to grant permissions that are in excess of those allowed
+        // by the access policy of the role that is being assumed. For more information,
+        // Permissions for AssumeRole, AssumeRoleWithSAML, and AssumeRoleWithWebIdentity
+        // (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html)
+        // in the IAM User Guide.
+        //
+        // The format for this parameter, as described by its regex pattern, is a string
+        // of characters up to 2048 characters in length. The characters can be any
+        // ASCII character from the space character to the end of the valid character
+        // list (\u0020-\u00FF). It can also include the tab (\u0009), linefeed (\u000A),
+        // and carriage return (\u000D) characters.
+        //
+        // The policy plain text must be 2048 bytes or shorter. However, an internal
+        // conversion compresses it into a packed binary format with a separate limit.
+        // The PackedPolicySize response element indicates by percentage how close to
+        // the upper size limit the policy is, with 100% equaling the maximum allowed
+        // size.
+        Policy *string `min:"1" type:"string"`
+
+        // The Amazon Resource Name (ARN) of the SAML provider in IAM that describes
+        // the IdP.
+        //
+        // PrincipalArn is a required field
+        PrincipalArn *string `min:"20" type:"string" required:"true"`
+
+        // The Amazon Resource Name (ARN) of the role that the caller is assuming.
+        //
+        // RoleArn is a required field
+        RoleArn *string `min:"20" type:"string" required:"true"`
+
+        // The base-64 encoded SAML authentication response provided by the IdP.
+        //
+        // For more information, see Configuring a Relying Party and Adding Claims (http://docs.aws.amazon.com/IAM/latest/UserGuide/create-role-saml-IdP-tasks.html)
+        // in the Using IAM guide.
+        //
+        // SAMLAssertion is a required field
+        SAMLAssertion *string `min:"4" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s AssumeRoleWithSAMLInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AssumeRoleWithSAMLInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *AssumeRoleWithSAMLInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "AssumeRoleWithSAMLInput"}
+        if s.DurationSeconds != nil && *s.DurationSeconds < 900 {
+                invalidParams.Add(request.NewErrParamMinValue("DurationSeconds", 900))
+        }
+        if s.Policy != nil && len(*s.Policy) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Policy", 1))
+        }
+        if s.PrincipalArn == nil {
+                invalidParams.Add(request.NewErrParamRequired("PrincipalArn"))
+        }
+        if s.PrincipalArn != nil && len(*s.PrincipalArn) < 20 {
+                invalidParams.Add(request.NewErrParamMinLen("PrincipalArn", 20))
+        }
+        if s.RoleArn == nil {
+                invalidParams.Add(request.NewErrParamRequired("RoleArn"))
+        }
+        if s.RoleArn != nil && len(*s.RoleArn) < 20 {
+                invalidParams.Add(request.NewErrParamMinLen("RoleArn", 20))
+        }
+        if s.SAMLAssertion == nil {
+                invalidParams.Add(request.NewErrParamRequired("SAMLAssertion"))
+        }
+        if s.SAMLAssertion != nil && len(*s.SAMLAssertion) < 4 {
+                invalidParams.Add(request.NewErrParamMinLen("SAMLAssertion", 4))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetDurationSeconds sets the DurationSeconds field's value.
+func (s *AssumeRoleWithSAMLInput) SetDurationSeconds(v int64) *AssumeRoleWithSAMLInput {
+        s.DurationSeconds = &v
+        return s
+}
+
+// SetPolicy sets the Policy field's value.
+func (s *AssumeRoleWithSAMLInput) SetPolicy(v string) *AssumeRoleWithSAMLInput {
+        s.Policy = &v
+        return s
+}
+
+// SetPrincipalArn sets the PrincipalArn field's value.
+func (s *AssumeRoleWithSAMLInput) SetPrincipalArn(v string) *AssumeRoleWithSAMLInput {
+        s.PrincipalArn = &v
+        return s
+}
+
+// SetRoleArn sets the RoleArn field's value.
+func (s *AssumeRoleWithSAMLInput) SetRoleArn(v string) *AssumeRoleWithSAMLInput {
+        s.RoleArn = &v
+        return s
+}
+
+// SetSAMLAssertion sets the SAMLAssertion field's value.
+func (s *AssumeRoleWithSAMLInput) SetSAMLAssertion(v string) *AssumeRoleWithSAMLInput {
+        s.SAMLAssertion = &v
+        return s
+}
+
+// Contains the response to a successful AssumeRoleWithSAML request, including
+// temporary AWS credentials that can be used to make AWS requests.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRoleWithSAMLResponse
+type AssumeRoleWithSAMLOutput struct {
+        _ struct{} `type:"structure"`
+
+        // The identifiers for the temporary security credentials that the operation
+        // returns.
+        AssumedRoleUser *AssumedRoleUser `type:"structure"`
+
+        // The value of the Recipient attribute of the SubjectConfirmationData element
+        // of the SAML assertion.
+        Audience *string `type:"string"`
+
+        // The temporary security credentials, which include an access key ID, a secret
+        // access key, and a security (or session) token.
+        //
+        // Note: The size of the security token that STS APIs return is not fixed. We
+        // strongly recommend that you make no assumptions about the maximum size. As
+        // of this writing, the typical size is less than 4096 bytes, but that can vary.
+        // Also, future updates to AWS might require larger sizes.
+        Credentials *Credentials `type:"structure"`
+
+        // The value of the Issuer element of the SAML assertion.
+        Issuer *string `type:"string"`
+
+        // A hash value based on the concatenation of the Issuer response value, the
+        // AWS account ID, and the friendly name (the last part of the ARN) of the SAML
+        // provider in IAM. The combination of NameQualifier and Subject can be used
+        // to uniquely identify a federated user.
+        //
+        // The following pseudocode shows how the hash value is calculated:
+        //
+        // BASE64 ( SHA1 ( "https://example.com/saml" + "123456789012" + "/MySAMLIdP"
+        // ) )
+        NameQualifier *string `type:"string"`
+
+        // A percentage value that indicates the size of the policy in packed form.
+        // The service rejects any policy with a packed size greater than 100 percent,
+        // which means the policy exceeded the allowed space.
+        PackedPolicySize *int64 `type:"integer"`
+
+        // The value of the NameID element in the Subject element of the SAML assertion.
+        Subject *string `type:"string"`
+
+        // The format of the name ID, as defined by the Format attribute in the NameID
+        // element of the SAML assertion. Typical examples of the format are transient
+        // or persistent.
+        //
+        // If the format includes the prefix urn:oasis:names:tc:SAML:2.0:nameid-format,
+        // that prefix is removed. For example, urn:oasis:names:tc:SAML:2.0:nameid-format:transient
+        // is returned as transient. If the format includes any other prefix, the format
+        // is returned with no modifications.
+        SubjectType *string `type:"string"`
+}
+
+// String returns the string representation
+func (s AssumeRoleWithSAMLOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AssumeRoleWithSAMLOutput) GoString() string {
+        return s.String()
+}
+
+// SetAssumedRoleUser sets the AssumedRoleUser field's value.
+func (s *AssumeRoleWithSAMLOutput) SetAssumedRoleUser(v *AssumedRoleUser) *AssumeRoleWithSAMLOutput {
+        s.AssumedRoleUser = v
+        return s
+}
+
+// SetAudience sets the Audience field's value.
+func (s *AssumeRoleWithSAMLOutput) SetAudience(v string) *AssumeRoleWithSAMLOutput {
+        s.Audience = &v
+        return s
+}
+
+// SetCredentials sets the Credentials field's value.
+func (s *AssumeRoleWithSAMLOutput) SetCredentials(v *Credentials) *AssumeRoleWithSAMLOutput {
+        s.Credentials = v
+        return s
+}
+
+// SetIssuer sets the Issuer field's value.
+func (s *AssumeRoleWithSAMLOutput) SetIssuer(v string) *AssumeRoleWithSAMLOutput {
+        s.Issuer = &v
+        return s
+}
+
+// SetNameQualifier sets the NameQualifier field's value.
+func (s *AssumeRoleWithSAMLOutput) SetNameQualifier(v string) *AssumeRoleWithSAMLOutput {
+        s.NameQualifier = &v
+        return s
+}
+
+// SetPackedPolicySize sets the PackedPolicySize field's value.
+func (s *AssumeRoleWithSAMLOutput) SetPackedPolicySize(v int64) *AssumeRoleWithSAMLOutput {
+        s.PackedPolicySize = &v
+        return s
+}
+
+// SetSubject sets the Subject field's value.
+func (s *AssumeRoleWithSAMLOutput) SetSubject(v string) *AssumeRoleWithSAMLOutput {
+        s.Subject = &v
+        return s
+}
+
+// SetSubjectType sets the SubjectType field's value.
+func (s *AssumeRoleWithSAMLOutput) SetSubjectType(v string) *AssumeRoleWithSAMLOutput {
+        s.SubjectType = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRoleWithWebIdentityRequest
+type AssumeRoleWithWebIdentityInput struct {
+        _ struct{} `type:"structure"`
+
+        // The duration, in seconds, of the role session. The value can range from 900
+        // seconds (15 minutes) to 3600 seconds (1 hour). By default, the value is set
+        // to 3600 seconds.
+        //
+        // This is separate from the duration of a console session that you might request
+        // using the returned credentials. The request to the federation endpoint for
+        // a console sign-in token takes a SessionDuration parameter that specifies
+        // the maximum length of the console session, separately from the DurationSeconds
+        // parameter on this API. For more information, see Creating a URL that Enables
+        // Federated Users to Access the AWS Management Console (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_enable-console-custom-url.html)
+        // in the IAM User Guide.
+        DurationSeconds *int64 `min:"900" type:"integer"`
+
+        // An IAM policy in JSON format.
+        //
+        // The policy parameter is optional. If you pass a policy, the temporary security
+        // credentials that are returned by the operation have the permissions that
+        // are allowed by both the access policy of the role that is being assumed,
+        // and the policy that you pass. This gives you a way to further restrict the
+        // permissions for the resulting temporary security credentials. You cannot
+        // use the passed policy to grant permissions that are in excess of those allowed
+        // by the access policy of the role that is being assumed. For more information,
+        // see Permissions for AssumeRoleWithWebIdentity (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html)
+        // in the IAM User Guide.
+        //
+        // The format for this parameter, as described by its regex pattern, is a string
+        // of characters up to 2048 characters in length. The characters can be any
+        // ASCII character from the space character to the end of the valid character
+        // list (\u0020-\u00FF). It can also include the tab (\u0009), linefeed (\u000A),
+        // and carriage return (\u000D) characters.
+        //
+        // The policy plain text must be 2048 bytes or shorter. However, an internal
+        // conversion compresses it into a packed binary format with a separate limit.
+        // The PackedPolicySize response element indicates by percentage how close to
+        // the upper size limit the policy is, with 100% equaling the maximum allowed
+        // size.
+        Policy *string `min:"1" type:"string"`
+
+        // The fully qualified host component of the domain name of the identity provider.
+        //
+        // Specify this value only for OAuth 2.0 access tokens. Currently www.amazon.com
+        // and graph.facebook.com are the only supported identity providers for OAuth
+        // 2.0 access tokens. Do not include URL schemes and port numbers.
+        //
+        // Do not specify this value for OpenID Connect ID tokens.
+        ProviderId *string `min:"4" type:"string"`
+
+        // The Amazon Resource Name (ARN) of the role that the caller is assuming.
+        //
+        // RoleArn is a required field
+        RoleArn *string `min:"20" type:"string" required:"true"`
+
+        // An identifier for the assumed role session. Typically, you pass the name
+        // or identifier that is associated with the user who is using your application.
+        // That way, the temporary security credentials that your application will use
+        // are associated with that user. This session name is included as part of the
+        // ARN and assumed role ID in the AssumedRoleUser response element.
+        //
+        // The regex used to validate this parameter is a string of characters consisting
+        // of upper- and lower-case alphanumeric characters with no spaces. You can
+        // also include underscores or any of the following characters: =,.@-
+        //
+        // RoleSessionName is a required field
+        RoleSessionName *string `min:"2" type:"string" required:"true"`
+
+        // The OAuth 2.0 access token or OpenID Connect ID token that is provided by
+        // the identity provider. Your application must get this token by authenticating
+        // the user who is using your application with a web identity provider before
+        // the application makes an AssumeRoleWithWebIdentity call.
+        //
+        // WebIdentityToken is a required field
+        WebIdentityToken *string `min:"4" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s AssumeRoleWithWebIdentityInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AssumeRoleWithWebIdentityInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *AssumeRoleWithWebIdentityInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "AssumeRoleWithWebIdentityInput"}
+        if s.DurationSeconds != nil && *s.DurationSeconds < 900 {
+                invalidParams.Add(request.NewErrParamMinValue("DurationSeconds", 900))
+        }
+        if s.Policy != nil && len(*s.Policy) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Policy", 1))
+        }
+        if s.ProviderId != nil && len(*s.ProviderId) < 4 {
+                invalidParams.Add(request.NewErrParamMinLen("ProviderId", 4))
+        }
+        if s.RoleArn == nil {
+                invalidParams.Add(request.NewErrParamRequired("RoleArn"))
+        }
+        if s.RoleArn != nil && len(*s.RoleArn) < 20 {
+                invalidParams.Add(request.NewErrParamMinLen("RoleArn", 20))
+        }
+        if s.RoleSessionName == nil {
+                invalidParams.Add(request.NewErrParamRequired("RoleSessionName"))
+        }
+        if s.RoleSessionName != nil && len(*s.RoleSessionName) < 2 {
+                invalidParams.Add(request.NewErrParamMinLen("RoleSessionName", 2))
+        }
+        if s.WebIdentityToken == nil {
+                invalidParams.Add(request.NewErrParamRequired("WebIdentityToken"))
+        }
+        if s.WebIdentityToken != nil && len(*s.WebIdentityToken) < 4 {
+                invalidParams.Add(request.NewErrParamMinLen("WebIdentityToken", 4))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetDurationSeconds sets the DurationSeconds field's value.
+func (s *AssumeRoleWithWebIdentityInput) SetDurationSeconds(v int64) *AssumeRoleWithWebIdentityInput {
+        s.DurationSeconds = &v
+        return s
+}
+
+// SetPolicy sets the Policy field's value.
+func (s *AssumeRoleWithWebIdentityInput) SetPolicy(v string) *AssumeRoleWithWebIdentityInput {
+        s.Policy = &v
+        return s
+}
+
+// SetProviderId sets the ProviderId field's value.
+func (s *AssumeRoleWithWebIdentityInput) SetProviderId(v string) *AssumeRoleWithWebIdentityInput {
+        s.ProviderId = &v
+        return s
+}
+
+// SetRoleArn sets the RoleArn field's value.
+func (s *AssumeRoleWithWebIdentityInput) SetRoleArn(v string) *AssumeRoleWithWebIdentityInput {
+        s.RoleArn = &v
+        return s
+}
+
+// SetRoleSessionName sets the RoleSessionName field's value.
+func (s *AssumeRoleWithWebIdentityInput) SetRoleSessionName(v string) *AssumeRoleWithWebIdentityInput {
+        s.RoleSessionName = &v
+        return s
+}
+
+// SetWebIdentityToken sets the WebIdentityToken field's value.
+func (s *AssumeRoleWithWebIdentityInput) SetWebIdentityToken(v string) *AssumeRoleWithWebIdentityInput {
+        s.WebIdentityToken = &v
+        return s
+}
+
+// Contains the response to a successful AssumeRoleWithWebIdentity request,
+// including temporary AWS credentials that can be used to make AWS requests.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRoleWithWebIdentityResponse
+type AssumeRoleWithWebIdentityOutput struct {
+        _ struct{} `type:"structure"`
+
+        // The Amazon Resource Name (ARN) and the assumed role ID, which are identifiers
+        // that you can use to refer to the resulting temporary security credentials.
+        // For example, you can reference these credentials as a principal in a resource-based
+        // policy by using the ARN or assumed role ID. The ARN and ID include the RoleSessionName
+        // that you specified when you called AssumeRole.
+        AssumedRoleUser *AssumedRoleUser `type:"structure"`
+
+        // The intended audience (also known as client ID) of the web identity token.
+        // This is traditionally the client identifier issued to the application that
+        // requested the web identity token.
+        Audience *string `type:"string"`
+
+        // The temporary security credentials, which include an access key ID, a secret
+        // access key, and a security token.
+        //
+        // Note: The size of the security token that STS APIs return is not fixed. We
+        // strongly recommend that you make no assumptions about the maximum size. As
+        // of this writing, the typical size is less than 4096 bytes, but that can vary.
+        // Also, future updates to AWS might require larger sizes.
+        Credentials *Credentials `type:"structure"`
+
+        // A percentage value that indicates the size of the policy in packed form.
+        // The service rejects any policy with a packed size greater than 100 percent,
+        // which means the policy exceeded the allowed space.
+        PackedPolicySize *int64 `type:"integer"`
+
+        // The issuing authority of the web identity token presented. For OpenID Connect
+        // ID Tokens this contains the value of the iss field. For OAuth 2.0 access
+        // tokens, this contains the value of the ProviderId parameter that was passed
+        // in the AssumeRoleWithWebIdentity request.
+        Provider *string `type:"string"`
+
+        // The unique user identifier that is returned by the identity provider. This
+        // identifier is associated with the WebIdentityToken that was submitted with
+        // the AssumeRoleWithWebIdentity call. The identifier is typically unique to
+        // the user and the application that acquired the WebIdentityToken (pairwise
+        // identifier). For OpenID Connect ID tokens, this field contains the value
+        // returned by the identity provider as the token's sub (Subject) claim.
+        SubjectFromWebIdentityToken *string `min:"6" type:"string"`
+}
+
+// String returns the string representation
+func (s AssumeRoleWithWebIdentityOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AssumeRoleWithWebIdentityOutput) GoString() string {
+        return s.String()
+}
+
+// SetAssumedRoleUser sets the AssumedRoleUser field's value.
+func (s *AssumeRoleWithWebIdentityOutput) SetAssumedRoleUser(v *AssumedRoleUser) *AssumeRoleWithWebIdentityOutput {
+        s.AssumedRoleUser = v
+        return s
+}
+
+// SetAudience sets the Audience field's value.
+func (s *AssumeRoleWithWebIdentityOutput) SetAudience(v string) *AssumeRoleWithWebIdentityOutput {
+        s.Audience = &v
+        return s
+}
+
+// SetCredentials sets the Credentials field's value.
+func (s *AssumeRoleWithWebIdentityOutput) SetCredentials(v *Credentials) *AssumeRoleWithWebIdentityOutput {
+        s.Credentials = v
+        return s
+}
+
+// SetPackedPolicySize sets the PackedPolicySize field's value.
+func (s *AssumeRoleWithWebIdentityOutput) SetPackedPolicySize(v int64) *AssumeRoleWithWebIdentityOutput {
+        s.PackedPolicySize = &v
+        return s
+}
+
+// SetProvider sets the Provider field's value.
+func (s *AssumeRoleWithWebIdentityOutput) SetProvider(v string) *AssumeRoleWithWebIdentityOutput {
+        s.Provider = &v
+        return s
+}
+
+// SetSubjectFromWebIdentityToken sets the SubjectFromWebIdentityToken field's value.
+func (s *AssumeRoleWithWebIdentityOutput) SetSubjectFromWebIdentityToken(v string) *AssumeRoleWithWebIdentityOutput {
+        s.SubjectFromWebIdentityToken = &v
+        return s
+}
+
+// The identifiers for the temporary security credentials that the operation
+// returns.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumedRoleUser
+type AssumedRoleUser struct {
+        _ struct{} `type:"structure"`
+
+        // The ARN of the temporary security credentials that are returned from the
+        // AssumeRole action. For more information about ARNs and how to use them in
+        // policies, see IAM Identifiers (http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html)
+        // in Using IAM.
+        //
+        // Arn is a required field
+        Arn *string `min:"20" type:"string" required:"true"`
+
+        // A unique identifier that contains the role ID and the role session name of
+        // the role that is being assumed. The role ID is generated by AWS when the
+        // role is created.
+        //
+        // AssumedRoleId is a required field
+        AssumedRoleId *string `min:"2" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s AssumedRoleUser) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AssumedRoleUser) GoString() string {
+        return s.String()
+}
+
+// SetArn sets the Arn field's value.
+func (s *AssumedRoleUser) SetArn(v string) *AssumedRoleUser {
+        s.Arn = &v
+        return s
+}
+
+// SetAssumedRoleId sets the AssumedRoleId field's value.
+func (s *AssumedRoleUser) SetAssumedRoleId(v string) *AssumedRoleUser {
+        s.AssumedRoleId = &v
+        return s
+}
+
+// AWS credentials for API authentication.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/Credentials
+type Credentials struct {
+        _ struct{} `type:"structure"`
+
+        // The access key ID that identifies the temporary security credentials.
+        //
+        // AccessKeyId is a required field
+        AccessKeyId *string `min:"16" type:"string" required:"true"`
+
+        // The date on which the current credentials expire.
+        //
+        // Expiration is a required field
+        Expiration *time.Time `type:"timestamp" timestampFormat:"iso8601" required:"true"`
+
+        // The secret access key that can be used to sign requests.
+        //
+        // SecretAccessKey is a required field
+        SecretAccessKey *string `type:"string" required:"true"`
+
+        // The token that users must pass to the service API to use the temporary credentials.
+        //
+        // SessionToken is a required field
+        SessionToken *string `type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s Credentials) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Credentials) GoString() string {
+        return s.String()
+}
+
+// SetAccessKeyId sets the AccessKeyId field's value.
+func (s *Credentials) SetAccessKeyId(v string) *Credentials {
+        s.AccessKeyId = &v
+        return s
+}
+
+// SetExpiration sets the Expiration field's value.
+func (s *Credentials) SetExpiration(v time.Time) *Credentials {
+        s.Expiration = &v
+        return s
+}
+
+// SetSecretAccessKey sets the SecretAccessKey field's value.
+func (s *Credentials) SetSecretAccessKey(v string) *Credentials {
+        s.SecretAccessKey = &v
+        return s
+}
+
+// SetSessionToken sets the SessionToken field's value.
+func (s *Credentials) SetSessionToken(v string) *Credentials {
+        s.SessionToken = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/DecodeAuthorizationMessageRequest
+type DecodeAuthorizationMessageInput struct {
+        _ struct{} `type:"structure"`
+
+        // The encoded message that was returned with the response.
+        //
+        // EncodedMessage is a required field
+        EncodedMessage *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DecodeAuthorizationMessageInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DecodeAuthorizationMessageInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DecodeAuthorizationMessageInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "DecodeAuthorizationMessageInput"}
+        if s.EncodedMessage == nil {
+                invalidParams.Add(request.NewErrParamRequired("EncodedMessage"))
+        }
+        if s.EncodedMessage != nil && len(*s.EncodedMessage) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("EncodedMessage", 1))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetEncodedMessage sets the EncodedMessage field's value.
+func (s *DecodeAuthorizationMessageInput) SetEncodedMessage(v string) *DecodeAuthorizationMessageInput {
+        s.EncodedMessage = &v
+        return s
+}
+
+// A document that contains additional information about the authorization status
+// of a request from an encoded message that is returned in response to an AWS
+// request.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/DecodeAuthorizationMessageResponse
+type DecodeAuthorizationMessageOutput struct {
+        _ struct{} `type:"structure"`
+
+        // An XML document that contains the decoded message.
+        DecodedMessage *string `type:"string"`
+}
+
+// String returns the string representation
+func (s DecodeAuthorizationMessageOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DecodeAuthorizationMessageOutput) GoString() string {
+        return s.String()
+}
+
+// SetDecodedMessage sets the DecodedMessage field's value.
+func (s *DecodeAuthorizationMessageOutput) SetDecodedMessage(v string) *DecodeAuthorizationMessageOutput {
+        s.DecodedMessage = &v
+        return s
+}
+
+// Identifiers for the federated user that is associated with the credentials.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/FederatedUser
+type FederatedUser struct {
+        _ struct{} `type:"structure"`
+
+        // The ARN that specifies the federated user that is associated with the credentials.
+        // For more information about ARNs and how to use them in policies, see IAM
+        // Identifiers (http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html)
+        // in Using IAM.
+        //
+        // Arn is a required field
+        Arn *string `min:"20" type:"string" required:"true"`
+
+        // The string that identifies the federated user associated with the credentials,
+        // similar to the unique ID of an IAM user.
+        //
+        // FederatedUserId is a required field
+        FederatedUserId *string `min:"2" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s FederatedUser) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s FederatedUser) GoString() string {
+        return s.String()
+}
+
+// SetArn sets the Arn field's value.
+func (s *FederatedUser) SetArn(v string) *FederatedUser {
+        s.Arn = &v
+        return s
+}
+
+// SetFederatedUserId sets the FederatedUserId field's value.
+func (s *FederatedUser) SetFederatedUserId(v string) *FederatedUser {
+        s.FederatedUserId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetCallerIdentityRequest
+type GetCallerIdentityInput struct {
+        _ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s GetCallerIdentityInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetCallerIdentityInput) GoString() string {
+        return s.String()
+}
+
+// Contains the response to a successful GetCallerIdentity request, including
+// information about the entity making the request.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetCallerIdentityResponse
+type GetCallerIdentityOutput struct {
+        _ struct{} `type:"structure"`
+
+        // The AWS account ID number of the account that owns or contains the calling
+        // entity.
+        Account *string `type:"string"`
+
+        // The AWS ARN associated with the calling entity.
+        Arn *string `min:"20" type:"string"`
+
+        // The unique identifier of the calling entity. The exact value depends on the
+        // type of entity making the call. The values returned are those listed in the
+        // aws:userid column in the Principal table (http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html#principaltable)
+        // found on the Policy Variables reference page in the IAM User Guide.
+        UserId *string `type:"string"`
+}
+
+// String returns the string representation
+func (s GetCallerIdentityOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetCallerIdentityOutput) GoString() string {
+        return s.String()
+}
+
+// SetAccount sets the Account field's value.
+func (s *GetCallerIdentityOutput) SetAccount(v string) *GetCallerIdentityOutput {
+        s.Account = &v
+        return s
+}
+
+// SetArn sets the Arn field's value.
+func (s *GetCallerIdentityOutput) SetArn(v string) *GetCallerIdentityOutput {
+        s.Arn = &v
+        return s
+}
+
+// SetUserId sets the UserId field's value.
+func (s *GetCallerIdentityOutput) SetUserId(v string) *GetCallerIdentityOutput {
+        s.UserId = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetFederationTokenRequest
+type GetFederationTokenInput struct {
+        _ struct{} `type:"structure"`
+
+        // The duration, in seconds, that the session should last. Acceptable durations
+        // for federation sessions range from 900 seconds (15 minutes) to 129600 seconds
+        // (36 hours), with 43200 seconds (12 hours) as the default. Sessions obtained
+        // using AWS account (root) credentials are restricted to a maximum of 3600
+        // seconds (one hour). If the specified duration is longer than one hour, the
+        // session obtained by using AWS account (root) credentials defaults to one
+        // hour.
+        DurationSeconds *int64 `min:"900" type:"integer"`
+
+        // The name of the federated user. The name is used as an identifier for the
+        // temporary security credentials (such as Bob). For example, you can reference
+        // the federated user name in a resource-based policy, such as in an Amazon
+        // S3 bucket policy.
+        //
+        // The regex used to validate this parameter is a string of characters consisting
+        // of upper- and lower-case alphanumeric characters with no spaces. You can
+        // also include underscores or any of the following characters: =,.@-
+        //
+        // Name is a required field
+        Name *string `min:"2" type:"string" required:"true"`
+
+        // An IAM policy in JSON format that is passed with the GetFederationToken call
+        // and evaluated along with the policy or policies that are attached to the
+        // IAM user whose credentials are used to call GetFederationToken. The passed
+        // policy is used to scope down the permissions that are available to the IAM
+        // user, by allowing only a subset of the permissions that are granted to the
+        // IAM user. The passed policy cannot grant more permissions than those granted
+        // to the IAM user. The final permissions for the federated user are the most
+        // restrictive set based on the intersection of the passed policy and the IAM
+        // user policy.
+        //
+        // If you do not pass a policy, the resulting temporary security credentials
+        // have no effective permissions. The only exception is when the temporary security
+        // credentials are used to access a resource that has a resource-based policy
+        // that specifically allows the federated user to access the resource.
+        //
+        // The format for this parameter, as described by its regex pattern, is a string
+        // of characters up to 2048 characters in length. The characters can be any
+        // ASCII character from the space character to the end of the valid character
+        // list (\u0020-\u00FF). It can also include the tab (\u0009), linefeed (\u000A),
+        // and carriage return (\u000D) characters.
+        //
+        // The policy plain text must be 2048 bytes or shorter. However, an internal
+        // conversion compresses it into a packed binary format with a separate limit.
+        // The PackedPolicySize response element indicates by percentage how close to
+        // the upper size limit the policy is, with 100% equaling the maximum allowed
+        // size.
+        //
+        // For more information about how permissions work, see Permissions for GetFederationToken
+        // (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_getfederationtoken.html).
+        Policy *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s GetFederationTokenInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetFederationTokenInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetFederationTokenInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetFederationTokenInput"}
+        if s.DurationSeconds != nil && *s.DurationSeconds < 900 {
+                invalidParams.Add(request.NewErrParamMinValue("DurationSeconds", 900))
+        }
+        if s.Name == nil {
+                invalidParams.Add(request.NewErrParamRequired("Name"))
+        }
+        if s.Name != nil && len(*s.Name) < 2 {
+                invalidParams.Add(request.NewErrParamMinLen("Name", 2))
+        }
+        if s.Policy != nil && len(*s.Policy) < 1 {
+                invalidParams.Add(request.NewErrParamMinLen("Policy", 1))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetDurationSeconds sets the DurationSeconds field's value.
+func (s *GetFederationTokenInput) SetDurationSeconds(v int64) *GetFederationTokenInput {
+        s.DurationSeconds = &v
+        return s
+}
+
+// SetName sets the Name field's value.
+func (s *GetFederationTokenInput) SetName(v string) *GetFederationTokenInput {
+        s.Name = &v
+        return s
+}
+
+// SetPolicy sets the Policy field's value.
+func (s *GetFederationTokenInput) SetPolicy(v string) *GetFederationTokenInput {
+        s.Policy = &v
+        return s
+}
+
+// Contains the response to a successful GetFederationToken request, including
+// temporary AWS credentials that can be used to make AWS requests.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetFederationTokenResponse
+type GetFederationTokenOutput struct {
+        _ struct{} `type:"structure"`
+
+        // The temporary security credentials, which include an access key ID, a secret
+        // access key, and a security (or session) token.
+        //
+        // Note: The size of the security token that STS APIs return is not fixed. We
+        // strongly recommend that you make no assumptions about the maximum size. As
+        // of this writing, the typical size is less than 4096 bytes, but that can vary.
+        // Also, future updates to AWS might require larger sizes.
+        Credentials *Credentials `type:"structure"`
+
+        // Identifiers for the federated user associated with the credentials (such
+        // as arn:aws:sts::123456789012:federated-user/Bob or 123456789012:Bob). You
+        // can use the federated user's ARN in your resource-based policies, such as
+        // an Amazon S3 bucket policy.
+        FederatedUser *FederatedUser `type:"structure"`
+
+        // A percentage value indicating the size of the policy in packed form. The
+        // service rejects policies for which the packed size is greater than 100 percent
+        // of the allowed value.
+        PackedPolicySize *int64 `type:"integer"`
+}
+
+// String returns the string representation
+func (s GetFederationTokenOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetFederationTokenOutput) GoString() string {
+        return s.String()
+}
+
+// SetCredentials sets the Credentials field's value.
+func (s *GetFederationTokenOutput) SetCredentials(v *Credentials) *GetFederationTokenOutput {
+        s.Credentials = v
+        return s
+}
+
+// SetFederatedUser sets the FederatedUser field's value.
+func (s *GetFederationTokenOutput) SetFederatedUser(v *FederatedUser) *GetFederationTokenOutput {
+        s.FederatedUser = v
+        return s
+}
+
+// SetPackedPolicySize sets the PackedPolicySize field's value.
+func (s *GetFederationTokenOutput) SetPackedPolicySize(v int64) *GetFederationTokenOutput {
+        s.PackedPolicySize = &v
+        return s
+}
+
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetSessionTokenRequest
+type GetSessionTokenInput struct {
+        _ struct{} `type:"structure"`
+
+        // The duration, in seconds, that the credentials should remain valid. Acceptable
+        // durations for IAM user sessions range from 900 seconds (15 minutes) to 129600
+        // seconds (36 hours), with 43200 seconds (12 hours) as the default. Sessions
+        // for AWS account owners are restricted to a maximum of 3600 seconds (one hour).
+        // If the duration is longer than one hour, the session for AWS account owners
+        // defaults to one hour.
+        DurationSeconds *int64 `min:"900" type:"integer"`
+
+        // The identification number of the MFA device that is associated with the IAM
+        // user who is making the GetSessionToken call. Specify this value if the IAM
+        // user has a policy that requires MFA authentication. The value is either the
+        // serial number for a hardware device (such as GAHT12345678) or an Amazon Resource
+        // Name (ARN) for a virtual device (such as arn:aws:iam::123456789012:mfa/user).
+        // You can find the device for an IAM user by going to the AWS Management Console
+        // and viewing the user's security credentials.
+        //
+        // The regex used to validate this parameter is a string of characters consisting
+        // of upper- and lower-case alphanumeric characters with no spaces. You can
+        // also include underscores or any of the following characters: =,.@-
+        SerialNumber *string `min:"9" type:"string"`
+
+        // The value provided by the MFA device, if MFA is required. If any policy requires
+        // the IAM user to submit an MFA code, specify this value. If MFA authentication
+        // is required, and the user does not provide a code when requesting a set of
+        // temporary security credentials, the user will receive an "access denied"
+        // response when requesting resources that require MFA authentication.
+        //
+        // The format for this parameter, as described by its regex pattern, is a sequence
+        // of six numeric digits.
+        TokenCode *string `min:"6" type:"string"`
+}
+
+// String returns the string representation
+func (s GetSessionTokenInput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetSessionTokenInput) GoString() string {
+        return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetSessionTokenInput) Validate() error {
+        invalidParams := request.ErrInvalidParams{Context: "GetSessionTokenInput"}
+        if s.DurationSeconds != nil && *s.DurationSeconds < 900 {
+                invalidParams.Add(request.NewErrParamMinValue("DurationSeconds", 900))
+        }
+        if s.SerialNumber != nil && len(*s.SerialNumber) < 9 {
+                invalidParams.Add(request.NewErrParamMinLen("SerialNumber", 9))
+        }
+        if s.TokenCode != nil && len(*s.TokenCode) < 6 {
+                invalidParams.Add(request.NewErrParamMinLen("TokenCode", 6))
+        }
+
+        if invalidParams.Len() > 0 {
+                return invalidParams
+        }
+        return nil
+}
+
+// SetDurationSeconds sets the DurationSeconds field's value.
+func (s *GetSessionTokenInput) SetDurationSeconds(v int64) *GetSessionTokenInput {
+        s.DurationSeconds = &v
+        return s
+}
+
+// SetSerialNumber sets the SerialNumber field's value.
+func (s *GetSessionTokenInput) SetSerialNumber(v string) *GetSessionTokenInput {
+        s.SerialNumber = &v
+        return s
+}
+
+// SetTokenCode sets the TokenCode field's value.
+func (s *GetSessionTokenInput) SetTokenCode(v string) *GetSessionTokenInput {
+        s.TokenCode = &v
+        return s
+}
+
+// Contains the response to a successful GetSessionToken request, including
+// temporary AWS credentials that can be used to make AWS requests.
+// Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetSessionTokenResponse
+type GetSessionTokenOutput struct {
+        _ struct{} `type:"structure"`
+
+        // The temporary security credentials, which include an access key ID, a secret
+        // access key, and a security (or session) token.
+        //
+        // Note: The size of the security token that STS APIs return is not fixed. We
+        // strongly recommend that you make no assumptions about the maximum size. As
+        // of this writing, the typical size is less than 4096 bytes, but that can vary.
+        // Also, future updates to AWS might require larger sizes.
+        Credentials *Credentials `type:"structure"`
+}
+
+// String returns the string representation
+func (s GetSessionTokenOutput) String() string {
+        return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetSessionTokenOutput) GoString() string {
+        return s.String()
+}
+
+// SetCredentials sets the Credentials field's value.
+func (s *GetSessionTokenOutput) SetCredentials(v *Credentials) *GetSessionTokenOutput {
+        s.Credentials = v
+        return s
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/service/sts/customizations.go b/vendor/github.com/aws/aws-sdk-go/service/sts/customizations.go
new file mode 100644
index 0000000..4010cc7
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/sts/customizations.go
@@ -0,0 +1,12 @@
+package sts
+
+import "github.com/aws/aws-sdk-go/aws/request"
+
+func init() {
+        initRequest = func(r *request.Request) {
+                switch r.Operation.Name {
+                case opAssumeRoleWithSAML, opAssumeRoleWithWebIdentity:
+                        r.Handlers.Sign.Clear() // these operations are unsigned
+                }
+        }
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/service/sts/doc.go b/vendor/github.com/aws/aws-sdk-go/service/sts/doc.go
new file mode 100644
index 0000000..d2af518
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/sts/doc.go
@@ -0,0 +1,124 @@
+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
+
+// Package sts provides the client and types for making API
+// requests to AWS Security Token Service.
+//
+// The AWS Security Token Service (STS) is a web service that enables you to
+// request temporary, limited-privilege credentials for AWS Identity and Access
+// Management (IAM) users or for users that you authenticate (federated users).
+// This guide provides descriptions of the STS API. For more detailed information
+// about using this service, go to Temporary Security Credentials (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html).
+//
+// As an alternative to using the API, you can use one of the AWS SDKs, which
+// consist of libraries and sample code for various programming languages and
+// platforms (Java, Ruby, .NET, iOS, Android, etc.). The SDKs provide a convenient
+// way to create programmatic access to STS. For example, the SDKs take care
+// of cryptographically signing requests, managing errors, and retrying requests
+// automatically. For information about the AWS SDKs, including how to download
+// and install them, see the Tools for Amazon Web Services page (http://aws.amazon.com/tools/).
+//
+// For information about setting up signatures and authorization through the
+// API, go to Signing AWS API Requests (http://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html)
+// in the AWS General Reference. For general information about the Query API,
+// go to Making Query Requests (http://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_UsingQueryAPI.html)
+// in Using IAM. For information about using security tokens with other AWS
+// products, go to AWS Services That Work with IAM (http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html)
+// in the IAM User Guide.
+//
+// If you're new to AWS and need additional technical information about a specific
+// AWS product, you can find the product's technical documentation at http://aws.amazon.com/documentation/
+// (http://aws.amazon.com/documentation/).
+//
+// Endpoints
+//
+// The AWS Security Token Service (STS) has a default endpoint of https://sts.amazonaws.com
+// that maps to the US East (N. Virginia) region. Additional regions are available
+// and are activated by default. For more information, see Activating and Deactivating
+// AWS STS in an AWS Region (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html)
+// in the IAM User Guide.
+//
+// For information about STS endpoints, see Regions and Endpoints (http://docs.aws.amazon.com/general/latest/gr/rande.html#sts_region)
+// in the AWS General Reference.
+//
+// Recording API requests
+//
+// STS supports AWS CloudTrail, which is a service that records AWS calls for
+// your AWS account and delivers log files to an Amazon S3 bucket. By using
+// information collected by CloudTrail, you can determine what requests were
+// successfully made to STS, who made the request, when it was made, and so
+// on. To learn more about CloudTrail, including how to turn it on and find
+// your log files, see the AWS CloudTrail User Guide (http://docs.aws.amazon.com/awscloudtrail/latest/userguide/what_is_cloud_trail_top_level.html).
+//
+// See https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15 for more information on this service.
+//
+// See sts package documentation for more information.
+// https://docs.aws.amazon.com/sdk-for-go/api/service/sts/
+//
+// Using the Client
+//
+// To use the client for AWS Security Token Service you will first need
+// to create a new instance of it.
+//
+// When creating a client for an AWS service you'll first need to have a Session
+// already created. The Session provides configuration that can be shared
+// between multiple service clients. Additional configuration can be applied to
+// the Session and service's client when they are constructed. The aws package's
+// Config type contains several fields such as Region for the AWS Region the
+// client should make API requests too. The optional Config value can be provided
+// as the variadic argument for Sessions and client creation.
+//
+// Once the service's client is created you can use it to make API requests the
+// AWS service. These clients are safe to use concurrently.
+//
+//   // Create a session to share configuration, and load external configuration.
+//   sess := session.Must(session.NewSession())
+//
+//   // Create the service's client with the session.
+//   svc := sts.New(sess)
+//
+// See the SDK's documentation for more information on how to use service clients.
+// https://docs.aws.amazon.com/sdk-for-go/api/
+//
+// See aws package's Config type for more information on configuration options.
+// https://docs.aws.amazon.com/sdk-for-go/api/aws/#Config
+//
+// See the AWS Security Token Service client STS for more
+// information on creating the service's client.
+// https://docs.aws.amazon.com/sdk-for-go/api/service/sts/#New
+//
+// Once the client is created you can make an API request to the service.
+// Each API method takes a input parameter, and returns the service response
+// and an error.
+//
+// The API method will document which error codes the service can be returned
+// by the operation if the service models the API operation's errors. These
+// errors will also be available as const strings prefixed with "ErrCode".
+//
+//   result, err := svc.AssumeRole(params)
+//   if err != nil {
+//       // Cast err to awserr.Error to handle specific error codes.
+//       aerr, ok := err.(awserr.Error)
+//       if ok && aerr.Code() == <error code to check for> {
+//           // Specific error code handling
+//       }
+//       return err
+//   }
+//
+//   fmt.Println("AssumeRole result:")
+//   fmt.Println(result)
+//
+// Using the Client with Context
+//
+// The service's client also provides methods to make API requests with a Context
+// value. This allows you to control the timeout, and cancellation of pending
+// requests. These methods also take request Option as variadic parameter to apply
+// additional configuration to the API request.
+//
+//   ctx := context.Background()
+//
+//   result, err := svc.AssumeRoleWithContext(ctx, params)
+//
+// See the request package documentation for more information on using Context pattern
+// with the SDK.
+// https://docs.aws.amazon.com/sdk-for-go/api/aws/request/
+package sts
diff --git a/vendor/github.com/aws/aws-sdk-go/service/sts/errors.go b/vendor/github.com/aws/aws-sdk-go/service/sts/errors.go
new file mode 100644
index 0000000..e24884e
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/sts/errors.go
@@ -0,0 +1,73 @@
+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
+
+package sts
+
+const (
+
+        // ErrCodeExpiredTokenException for service response error code
+        // "ExpiredTokenException".
+        //
+        // The web identity token that was passed is expired or is not valid. Get a
+        // new identity token from the identity provider and then retry the request.
+        ErrCodeExpiredTokenException = "ExpiredTokenException"
+
+        // ErrCodeIDPCommunicationErrorException for service response error code
+        // "IDPCommunicationError".
+        //
+        // The request could not be fulfilled because the non-AWS identity provider
+        // (IDP) that was asked to verify the incoming identity token could not be reached.
+        // This is often a transient error caused by network conditions. Retry the request
+        // a limited number of times so that you don't exceed the request rate. If the
+        // error persists, the non-AWS identity provider might be down or not responding.
+        ErrCodeIDPCommunicationErrorException = "IDPCommunicationError"
+
+        // ErrCodeIDPRejectedClaimException for service response error code
+        // "IDPRejectedClaim".
+        //
+        // The identity provider (IdP) reported that authentication failed. This might
+        // be because the claim is invalid.
+        //
+        // If this error is returned for the AssumeRoleWithWebIdentity operation, it
+        // can also mean that the claim has expired or has been explicitly revoked.
+        ErrCodeIDPRejectedClaimException = "IDPRejectedClaim"
+
+        // ErrCodeInvalidAuthorizationMessageException for service response error code
+        // "InvalidAuthorizationMessageException".
+        //
+        // The error returned if the message passed to DecodeAuthorizationMessage was
+        // invalid. This can happen if the token contains invalid characters, such as
+        // linebreaks.
+        ErrCodeInvalidAuthorizationMessageException = "InvalidAuthorizationMessageException"
+
+        // ErrCodeInvalidIdentityTokenException for service response error code
+        // "InvalidIdentityToken".
+        //
+        // The web identity token that was passed could not be validated by AWS. Get
+        // a new identity token from the identity provider and then retry the request.
+        ErrCodeInvalidIdentityTokenException = "InvalidIdentityToken"
+
+        // ErrCodeMalformedPolicyDocumentException for service response error code
+        // "MalformedPolicyDocument".
+        //
+        // The request was rejected because the policy document was malformed. The error
+        // message describes the specific error.
+        ErrCodeMalformedPolicyDocumentException = "MalformedPolicyDocument"
+
+        // ErrCodePackedPolicyTooLargeException for service response error code
+        // "PackedPolicyTooLarge".
+        //
+        // The request was rejected because the policy document was too large. The error
+        // message describes how big the policy document is, in packed form, as a percentage
+        // of what the API allows.
+        ErrCodePackedPolicyTooLargeException = "PackedPolicyTooLarge"
+
+        // ErrCodeRegionDisabledException for service response error code
+        // "RegionDisabledException".
+        //
+        // STS is not activated in the requested region for the account that is being
+        // asked to generate credentials. The account administrator must use the IAM
+        // console to activate STS in that region. For more information, see Activating
+        // and Deactivating AWS STS in an AWS Region (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html)
+        // in the IAM User Guide.
+        ErrCodeRegionDisabledException = "RegionDisabledException"
+)
diff --git a/vendor/github.com/aws/aws-sdk-go/service/sts/service.go b/vendor/github.com/aws/aws-sdk-go/service/sts/service.go
new file mode 100644
index 0000000..1ee5839
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/sts/service.go
@@ -0,0 +1,93 @@
+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
+
+package sts
+
+import (
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/client"
+        "github.com/aws/aws-sdk-go/aws/client/metadata"
+        "github.com/aws/aws-sdk-go/aws/request"
+        "github.com/aws/aws-sdk-go/aws/signer/v4"
+        "github.com/aws/aws-sdk-go/private/protocol/query"
+)
+
+// STS provides the API operation methods for making requests to
+// AWS Security Token Service. See this package's package overview docs
+// for details on the service.
+//
+// STS methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
+type STS struct {
+        *client.Client
+}
+
+// Used for custom client initialization logic
+var initClient func(*client.Client)
+
+// Used for custom request initialization logic
+var initRequest func(*request.Request)
+
+// Service information constants
+const (
+        ServiceName = "sts"       // Service endpoint prefix API calls made to.
+        EndpointsID = ServiceName // Service ID for Regions and Endpoints metadata.
+)
+
+// New creates a new instance of the STS client with a session.
+// If additional configuration is needed for the client instance use the optional
+// aws.Config parameter to add your extra config.
+//
+// Example:
+//     // Create a STS client from just a session.
+//     svc := sts.New(mySession)
+//
+//     // Create a STS client with additional configuration
+//     svc := sts.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
+func New(p client.ConfigProvider, cfgs ...*aws.Config) *STS {
+        c := p.ClientConfig(EndpointsID, cfgs...)
+        return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName)
+}
+
+// newClient creates, initializes and returns a new service client instance.
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *STS {
+        svc := &STS{
+                Client: client.New(
+                        cfg,
+                        metadata.ClientInfo{
+                                ServiceName:   ServiceName,
+                                SigningName:   signingName,
+                                SigningRegion: signingRegion,
+                                Endpoint:      endpoint,
+                                APIVersion:    "2011-06-15",
+                        },
+                        handlers,
+                ),
+        }
+
+        // Handlers
+        svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler)
+        svc.Handlers.Build.PushBackNamed(query.BuildHandler)
+        svc.Handlers.Unmarshal.PushBackNamed(query.UnmarshalHandler)
+        svc.Handlers.UnmarshalMeta.PushBackNamed(query.UnmarshalMetaHandler)
+        svc.Handlers.UnmarshalError.PushBackNamed(query.UnmarshalErrorHandler)
+
+        // Run custom client initialization if present
+        if initClient != nil {
+                initClient(svc.Client)
+        }
+
+        return svc
+}
+
+// newRequest creates a new request for a STS operation and runs any
+// custom request initialization.
+func (c *STS) newRequest(op *request.Operation, params, data interface{}) *request.Request {
+        req := c.NewRequest(op, params, data)
+
+        // Run custom request initialization if present
+        if initRequest != nil {
+                initRequest(req)
+        }
+
+        return req
+}