provider/aws: Bump SDK to 1.6.2 (#10724)

vendor/github.com/aws/aws-sdk-go/CHANGELOG.md

@@ -1,32 +1,70 @@
+Release v1.6.2 (2016-12-08)
+===
+
+Service Client Updates
+---
+* `service/cloudfront`: Add lambda function associations to cache behaviors
+* `service/codepipeline`: This is a doc-only update request to incorporate some recent minor revisions to the doc content.
+* `service/rds`: Updates service API and documentation
+* `service/wafregional`: With this new feature, customers can use AWS WAF directly on Application Load Balancers in a VPC within available regions to protect their websites and web services from malicious attacks such as SQL injection, Cross Site Scripting, bad bots, etc.
+
+Release v1.6.1 (2016-12-07)
+===
+
+Service Client Updates
+---
+* `service/config`: Updates service API
+* `service/s3`: Updates service API
+* `service/sqs`: Updates service API and documentation
+
+Release v1.6.0 (2016-12-06)
+===
+
+Service Client Updates
+---
+* `service/config`: Updates service API and documentation
+* `service/ec2`: Updates service API
+* `service/sts`: Updates service API, documentation, and examples
+
+SDK Bug Fixes
+---
+* private/protocol/xml/xmlutil: Fix SDK XML unmarshaler #975
+  * Fixes GetBucketACL Grantee required type always nil. #916
+
+SDK Feature
+---
+* aws/endpoints: Add endpoint metadata to SDK #961
+  * Adds Region and Endpoint metadata to the SDK. This allows you to enumerate regions and endpoint metadata based on a defined model embedded in the SDK.
+
 Release v1.5.13 (2016-12-01)
 ===
 
 Service Client Updates
 ---
-`service/apigateway`: Updates service API and documentation
+* `service/apigateway`: Updates service API and documentation
-`service/appstream`: Adds new service
+* `service/appstream`: Adds new service
-`service/codebuild`: Adds new service
+* `service/codebuild`: Adds new service
-`service/directconnect`: Updates service API and documentation
+* `service/directconnect`: Updates service API and documentation
-`service/ec2`: Adds new service
+* `service/ec2`: Adds new service
-`service/elasticbeanstalk`: Updates service API and documentation
+* `service/elasticbeanstalk`: Updates service API and documentation
-`service/health`: Adds new service
+* `service/health`: Adds new service
-`service/lambda`: Updates service API and documentation
+* `service/lambda`: Updates service API and documentation
-`service/opsworkscm`: Adds new service
+* `service/opsworkscm`: Adds new service
-`service/pinpoint`: Adds new service
+* `service/pinpoint`: Adds new service
-`service/shield`: Adds new service
+* `service/shield`: Adds new service
-`service/ssm`: Updates service API and documentation
+* `service/ssm`: Updates service API and documentation
-`service/states`: Adds new service
+* `service/states`: Adds new service
-`service/xray`: Adds new service
+* `service/xray`: Adds new service
 
 Release v1.5.12 (2016-11-30)
 ===
 
 Service Client Updates
 ---
-`service/lightsail`: Adds new service
+* `service/lightsail`: Adds new service
-`service/polly`: Adds new service
+* `service/polly`: Adds new service
-`service/rekognition`: Adds new service
+* `service/rekognition`: Adds new service
-`service/snowball`: Updates service API and documentation
+* `service/snowball`: Updates service API and documentation
 
 Release v1.5.11 (2016-11-29)
 ===
@@ -40,10 +78,10 @@ Release v1.5.10 (2016-11-22)
 
 Service Client Updates
 ---
-`service/cloudformation`: Updates service API and documentation
+* `service/cloudformation`: Updates service API and documentation
-`service/glacier`: Updates service API, documentation, and examples
+* `service/glacier`: Updates service API, documentation, and examples
-`service/route53`: Updates service API and documentation
+* `service/route53`: Updates service API and documentation
-`service/s3`: Updates service API and documentation
+* `service/s3`: Updates service API and documentation
 
 SDK Bug Fixes
 ---
@@ -56,29 +94,29 @@ Release v1.5.9 (2016-11-22)
 
 Service Client Updates
 ---
-`service/cloudtrail`: Updates service API and documentation
+* `service/cloudtrail`: Updates service API and documentation
-`service/ecs`: Updates service API and documentation
+* `service/ecs`: Updates service API and documentation
 
 Release v1.5.8 (2016-11-18)
 ===
 
 Service Client Updates
 ---
-`service/application-autoscaling`: Updates service API and documentation
+* `service/application-autoscaling`: Updates service API and documentation
-`service/elasticmapreduce`: Updates service API and documentation
+* `service/elasticmapreduce`: Updates service API and documentation
-`service/elastictranscoder`: Updates service API, documentation, and examples
+* `service/elastictranscoder`: Updates service API, documentation, and examples
-`service/gamelift`: Updates service API and documentation
+* `service/gamelift`: Updates service API and documentation
-`service/lambda`: Updates service API and documentation
+* `service/lambda`: Updates service API and documentation
 
 Release v1.5.7 (2016-11-18)
 ===
 
 Service Client Updates
 ---
-`service/apigateway`: Updates service API and documentation
+* `service/apigateway`: Updates service API and documentation
-`service/meteringmarketplace`: Updates service API and documentation
+* `service/meteringmarketplace`: Updates service API and documentation
-`service/monitoring`: Updates service API and documentation
+* `service/monitoring`: Updates service API and documentation
-`service/sqs`: Updates service API, documentation, and examples
+* `service/sqs`: Updates service API, documentation, and examples
 
 Release v1.5.6 (2016-11-16)
 ===
@@ -93,46 +131,46 @@ Release v1.5.5 (2016-11-15)
 
 Service Client Updates
 ---
-`service/ds`: Updates service API and documentation
+* `service/ds`: Updates service API and documentation
-`service/elasticache`: Updates service API and documentation
+* `service/elasticache`: Updates service API and documentation
-`service/kinesis`: Updates service API and documentation
+* `service/kinesis`: Updates service API and documentation
 
 Release v1.5.4 (2016-11-15)
 ===
 
 Service Client Updates
 ---
-`service/cognito-idp`: Updates service API and documentation
+* `service/cognito-idp`: Updates service API and documentation
 
 Release v1.5.3 (2016-11-11)
 ===
 
 Service Client Updates
 ---
-`service/cloudformation`: Updates service documentation and examples
+* `service/cloudformation`: Updates service documentation and examples
-`service/logs`: Updates service API and documentation
+* `service/logs`: Updates service API and documentation
 
 Release v1.5.2 (2016-11-03)
 ===
 
 Service Client Updates
 ---
-`service/directconnect`: Updates service API and documentation
+* `service/directconnect`: Updates service API and documentation
 
 Release v1.5.1 (2016-11-02)
 ===
 
 Service Client Updates
 ---
-`service/email`: Updates service API and documentation
+* `service/email`: Updates service API and documentation
 
 Release v1.5.0 (2016-11-01)
 ===
 
 Service Client Updates
 ---
-`service/cloudformation`: Updates service API and documentation
+* `service/cloudformation`: Updates service API and documentation
-`service/ecr`: Updates service paginators
+* `service/ecr`: Updates service paginators
 
 SDK Feature Updates
 ---

vendor/github.com/aws/aws-sdk-go/Makefile

@@ -45,7 +45,7 @@ gen-protocol-test:
 	go generate ./private/protocol/...
 
 gen-endpoints:
-	go generate ./private/endpoints
+	go generate ./models/endpoints/
 
 build:
 	@echo "go build SDK and vendor packages"
@@ -70,35 +70,60 @@ smoke-tests: get-deps-tests
 performance: get-deps-tests
 	AWS_TESTING_LOG_RESULTS=${log-detailed} AWS_TESTING_REGION=$(region) AWS_TESTING_DB_TABLE=$(table) gucumber -go-tags "integration" ./awstesting/performance
 
-sandbox-tests: sandbox-test-go14 sandbox-test-go15 sandbox-test-go15-novendorexp sandbox-test-go16 sandbox-test-go17 sandbox-test-gotip
+sandbox-tests: sandbox-test-go14 sandbox-test-go15 sandbox-test-go15-novendorexp sandbox-test-go16 sandbox-test-go17 sandbox-test-go18 sandbox-test-gotip
 
-sandbox-test-go14:
+sandbox-build-go14:
 	docker build -f ./awstesting/sandbox/Dockerfile.test.go1.4 -t "aws-sdk-go-1.4" .
+sandbox-go14: sandbox-build-go14
+	docker run -i -t aws-sdk-go-1.4 bash
+sandbox-test-go14: sandbox-build-go14
 	docker run -t aws-sdk-go-1.4
 
-sandbox-test-go15:
+sandbox-build-go15:
 	docker build -f ./awstesting/sandbox/Dockerfile.test.go1.5 -t "aws-sdk-go-1.5" .
+sandbox-go15: sandbox-build-go15
+	docker run -i -t aws-sdk-go-1.5 bash
+sandbox-test-go15: sandbox-build-go15
 	docker run -t aws-sdk-go-1.5
 
-sandbox-test-go15-novendorexp:
+sandbox-build-go15-novendorexp:
 	docker build -f ./awstesting/sandbox/Dockerfile.test.go1.5-novendorexp -t "aws-sdk-go-1.5-novendorexp" .
+sandbox-go15-novendorexp: sandbox-build-go15-novendorexp
+	docker run -i -t aws-sdk-go-1.5-novendorexp bash
+sandbox-test-go15-novendorexp: sandbox-build-go15-novendorexp
 	docker run -t aws-sdk-go-1.5-novendorexp
 
-sandbox-test-go16:
+sandbox-build-go16:
 	docker build -f ./awstesting/sandbox/Dockerfile.test.go1.6 -t "aws-sdk-go-1.6" .
+sandbox-go16: sandbox-build-go16
+	docker run -i -t aws-sdk-go-1.6 bash
+sandbox-test-go16: sandbox-build-go16
 	docker run -t aws-sdk-go-1.6
 
-sandbox-test-go17:
+sandbox-build-go17:
 	docker build -f ./awstesting/sandbox/Dockerfile.test.go1.7 -t "aws-sdk-go-1.7" .
+sandbox-go17: sandbox-build-go17
+	docker run -i -t aws-sdk-go-1.7 bash
+sandbox-test-go17: sandbox-build-go17
 	docker run -t aws-sdk-go-1.7
 
-sandbox-test-gotip:
+sandbox-build-go18:
+	docker build -f ./awstesting/sandbox/Dockerfile.test.go1.8 -t "aws-sdk-go-1.8" .
+sandbox-go18: sandbox-build-go18
+	docker run -i -t aws-sdk-go-1.8 bash
+sandbox-test-go18: sandbox-build-go18
+	docker run -t aws-sdk-go-1.8
+
+sandbox-build-gotip:
 	@echo "Run make update-aws-golang-tip, if this test fails because missing aws-golang:tip container"
 	docker build -f ./awstesting/sandbox/Dockerfile.test.gotip -t "aws-sdk-go-tip" .
+sandbox-gotip: sandbox-build-gotip
+	docker run -i -t aws-sdk-go-tip bash
+sandbox-test-gotip: sandbox-build-gotip
 	docker run -t aws-sdk-go-tip
 
 update-aws-golang-tip:
-	docker build -f ./awstesting/sandbox/Dockerfile.golang-tip -t "aws-golang:tip" .
+	docker build --no-cache=true -f ./awstesting/sandbox/Dockerfile.golang-tip -t "aws-golang:tip" .
 
 verify: get-deps-verify lint vet
 

vendor/github.com/aws/aws-sdk-go/aws/client/client.go

@@ -13,7 +13,9 @@ import (
 type Config struct {
 	Config        *aws.Config
 	Handlers      request.Handlers
-	Endpoint, SigningRegion string
+	Endpoint      string
+	SigningRegion string
+	SigningName   string
 }
 
 // ConfigProvider provides a generic way for a service client to receive

vendor/github.com/aws/aws-sdk-go/aws/config.go

@@ -5,6 +5,7 @@ import (
 	"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
@@ -48,6 +49,10 @@ type Config struct {
 	//   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
+
 	// 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"
@@ -235,6 +240,13 @@ func (c *Config) WithEndpoint(endpoint string) *Config {
 	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 {
@@ -357,6 +369,10 @@ func mergeInConfig(dst *Config, other *Config) {
 		dst.Endpoint = other.Endpoint
 	}
 
+	if other.EndpointResolver != nil {
+		dst.EndpointResolver = other.EndpointResolver
+	}
+
 	if other.Region != nil {
 		dst.Region = other.Region
 	}

vendor/github.com/aws/aws-sdk-go/aws/defaults/defaults.go

@@ -19,8 +19,8 @@ import (
 	"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"
-	"github.com/aws/aws-sdk-go/private/endpoints"
 )
 
 // A Defaults provides a collection of default values for SDK clients.
@@ -56,7 +56,8 @@ func Config() *aws.Config {
 		WithMaxRetries(aws.UseServiceDefaultRetries).
 		WithLogger(aws.NewDefaultLogger()).
 		WithLogLevel(aws.LogOff).
-		WithSleepDelay(time.Sleep)
+		WithSleepDelay(time.Sleep).
+		WithEndpointResolver(endpoints.DefaultResolver())
 }
 
 // Handlers returns the default request handlers.
@@ -120,11 +121,14 @@ func ecsCredProvider(cfg aws.Config, handlers request.Handlers, uri string) cred
 }
 
 func ec2RoleProvider(cfg aws.Config, handlers request.Handlers) credentials.Provider {
-	endpoint, signingRegion := endpoints.EndpointForRegion(ec2metadata.ServiceName,
+	resolver := cfg.EndpointResolver
-		aws.StringValue(cfg.Region), true, false)
+	if resolver == nil {
+		resolver = endpoints.DefaultResolver()
+	}
 
+	e, _ := resolver.EndpointFor(endpoints.Ec2metadataServiceID, "")
 	return &ec2rolecreds.EC2RoleProvider{
-		Client:       ec2metadata.NewClient(cfg, handlers, endpoint, signingRegion),
+		Client:       ec2metadata.NewClient(cfg, handlers, e.URL, e.SigningRegion),
 		ExpiryWindow: 5 * time.Minute,
 	}
 }

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),
+	}
+}

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

vendor/github.com/aws/aws-sdk-go/aws/endpoints/endpoints.go

@@ -0,0 +1,369 @@
+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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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.
+//
+// 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 enpoint 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 expantions.
+//
+// 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...)
+}
+
+// Endpoints returns a map of Endpoints indexed by their ID for all known
+// endpoints for 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
+}
+
+//// NewEndpointNotFoundError builds and returns NewEndpointNotFoundError.
+//func NewEndpointNotFoundError(p, s, r string) EndpointNotFoundError {
+//	return EndpointNotFoundError{
+//		awsError:  awserr.New("EndpointNotFoundError", "unable to find endpoint", nil),
+//		Partition: p,
+//		Service:   s,
+//		Region:    r,
+//	}
+//}
+//
+//// Error returns string representation of the error.
+//func (e EndpointNotFoundError) Error() string {
+//	extra := fmt.Sprintf("partition: %q, service: %q, region: %q",
+//		e.Partition, e.Service, e.Region)
+//	return awserr.SprintError(e.Code(), e.Message(), extra, e.OrigErr())
+//}
+//
+//// String returns the string representation of the error.
+//func (e EndpointNotFoundError) String() string {
+//	return e.Error()
+//}
+
+// 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()
+}

vendor/github.com/aws/aws-sdk-go/aws/endpoints/v3model.go

@@ -0,0 +1,301 @@
+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 {
+		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
+)

vendor/github.com/aws/aws-sdk-go/aws/endpoints/v3model_codegen.go

@@ -0,0 +1,334 @@
+// +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" -}}
+// THIS FILE IS AUTOMATICALLY GENERATED. 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 . }}.
+	//
+	// 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 := endpoints.DefaultResolver()
+	//    partitions := resolver.(endpoints.EnumPartitions).Partitions()
+	//    for _, p := range partitions {
+	//        // ... inspect partitions
+	//    }
+	func DefaultResolver() Resolver {
+		return defaultPartitions
+	}
+
+	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 }}
+`

vendor/github.com/aws/aws-sdk-go/aws/session/session.go

@@ -10,8 +10,8 @@ import (
 	"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"
-	"github.com/aws/aws-sdk-go/private/endpoints"
 )
 
 // A Session provides a central location to create service clients from and
@@ -44,7 +44,7 @@ type Session struct {
 // shared config, and shared credentials will be taken from the shared
 // credentials file.
 //
-// Deprecated: Use NewSession functiions to create sessions instead. NewSession
+// 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 {
@@ -222,6 +222,11 @@ func oldNewSession(cfgs ...*aws.Config) *Session {
 	// 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
@@ -375,19 +380,39 @@ func (s *Session) Copy(cfgs ...*aws.Config) *Session {
 // 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...)
-	endpoint, signingRegion := endpoints.NormalizeEndpoint(
+
-		aws.StringValue(s.Config.Endpoint),
+	var resolved endpoints.ResolvedEndpoint
-		serviceName,
+	var err error
-		aws.StringValue(s.Config.Region),
+
-		aws.BoolValue(s.Config.DisableSSL),
+	region := aws.StringValue(s.Config.Region)
-		aws.BoolValue(s.Config.UseDualStack),
+
+	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)
+			},
 		)
+	}
 
 	return client.Config{
 		Config:        s.Config,
 		Handlers:      s.Handlers,
-		Endpoint:      endpoint,
+		Endpoint:      resolved.URL,
-		SigningRegion: signingRegion,
+		SigningRegion: resolved.SigningRegion,
-	}
+		SigningName:   resolved.SigningName,
+	}, err
 }

vendor/github.com/aws/aws-sdk-go/aws/version.go

@@ -5,4 +5,4 @@ package aws
 const SDKName = "aws-sdk-go"
 
 // SDKVersion is the version of this SDK
-const SDKVersion = "1.5.13"
+const SDKVersion = "1.6.2"

vendor/github.com/aws/aws-sdk-go/private/endpoints/endpoints.go

@@ -1,70 +0,0 @@
-// Package endpoints validates regional endpoints for services.
-package endpoints
-
-//go:generate go run -tags codegen ../model/cli/gen-endpoints/main.go endpoints.json endpoints_map.go
-//go:generate gofmt -s -w endpoints_map.go
-
-import (
-	"fmt"
-	"regexp"
-	"strings"
-)
-
-// NormalizeEndpoint takes and endpoint and service API information to return a
-// normalized endpoint and signing region.  If the endpoint is not an empty string
-// the service name and region will be used to look up the service's API endpoint.
-// If the endpoint is provided the scheme will be added if it is not present.
-func NormalizeEndpoint(endpoint, serviceName, region string, disableSSL, useDualStack bool) (normEndpoint, signingRegion string) {
-	if endpoint == "" {
-		return EndpointForRegion(serviceName, region, disableSSL, useDualStack)
-	}
-
-	return AddScheme(endpoint, disableSSL), ""
-}
-
-// EndpointForRegion returns an endpoint and its signing region for a service and region.
-// if the service and region pair are not found endpoint and signingRegion will be empty.
-func EndpointForRegion(svcName, region string, disableSSL, useDualStack bool) (endpoint, signingRegion string) {
-	dualStackField := ""
-	if useDualStack {
-		dualStackField = "/dualstack"
-	}
-
-	derivedKeys := []string{
-		region + "/" + svcName + dualStackField,
-		region + "/*" + dualStackField,
-		"*/" + svcName + dualStackField,
-		"*/*" + dualStackField,
-	}
-
-	for _, key := range derivedKeys {
-		if val, ok := endpointsMap.Endpoints[key]; ok {
-			ep := val.Endpoint
-			ep = strings.Replace(ep, "{region}", region, -1)
-			ep = strings.Replace(ep, "{service}", svcName, -1)
-
-			endpoint = ep
-			signingRegion = val.SigningRegion
-			break
-		}
-	}
-
-	return AddScheme(endpoint, disableSSL), signingRegion
-}
-
-// Regular expression to determine if the endpoint string is prefixed with a scheme.
-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 be added instead of the default HTTPS.
-func AddScheme(endpoint string, disableSSL bool) string {
-	if endpoint != "" && !schemeRE.MatchString(endpoint) {
-		scheme := "https"
-		if disableSSL {
-			scheme = "http"
-		}
-		endpoint = fmt.Sprintf("%s://%s", scheme, endpoint)
-	}
-
-	return endpoint
-}

vendor/github.com/aws/aws-sdk-go/private/endpoints/endpoints.json

@@ -1,82 +0,0 @@
-{
-  "version": 2,
-  "endpoints": {
-    "*/*": {
-      "endpoint": "{service}.{region}.amazonaws.com"
-    },
-    "cn-north-1/*": {
-      "endpoint": "{service}.{region}.amazonaws.com.cn",
-      "signatureVersion": "v4"
-    },
-    "cn-north-1/ec2metadata": {
-      "endpoint": "http://169.254.169.254/latest"
-    },
-    "us-gov-west-1/iam": {
-      "endpoint": "iam.us-gov.amazonaws.com"
-    },
-    "us-gov-west-1/sts": {
-      "endpoint": "sts.us-gov-west-1.amazonaws.com"
-    },
-    "us-gov-west-1/s3": {
-      "endpoint": "s3-{region}.amazonaws.com"
-    },
-    "us-gov-west-1/ec2metadata": {
-      "endpoint": "http://169.254.169.254/latest"
-    },
-    "*/budgets": {
-      "endpoint": "budgets.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "*/cloudfront": {
-      "endpoint": "cloudfront.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "*/cloudsearchdomain": {
-      "endpoint": "",
-      "signingRegion": "us-east-1"
-    },
-    "*/data.iot": {
-      "endpoint": "",
-      "signingRegion": "us-east-1"
-    },
-    "*/ec2metadata": {
-      "endpoint": "http://169.254.169.254/latest"
-    },
-    "*/iam": {
-      "endpoint": "iam.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "*/importexport": {
-      "endpoint": "importexport.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "*/route53": {
-      "endpoint": "route53.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "*/sts": {
-      "endpoint": "sts.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "*/waf": {
-      "endpoint": "waf.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "us-east-1/sdb": {
-      "endpoint": "sdb.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "*/s3": {
-      "endpoint": "s3-{region}.amazonaws.com"
-    },
-    "*/s3/dualstack": {
-      "endpoint": "s3.dualstack.{region}.amazonaws.com"
-    },
-    "us-east-1/s3": {
-      "endpoint": "s3.amazonaws.com"
-    },
-    "eu-central-1/s3": {
-      "endpoint": "{service}.{region}.amazonaws.com"
-    }
-  }
-}

vendor/github.com/aws/aws-sdk-go/private/endpoints/endpoints_map.go

@@ -1,95 +0,0 @@
-package endpoints
-
-// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
-
-type endpointStruct struct {
-	Version   int
-	Endpoints map[string]endpointEntry
-}
-
-type endpointEntry struct {
-	Endpoint      string
-	SigningRegion string
-}
-
-var endpointsMap = endpointStruct{
-	Version: 2,
-	Endpoints: map[string]endpointEntry{
-		"*/*": {
-			Endpoint: "{service}.{region}.amazonaws.com",
-		},
-		"*/budgets": {
-			Endpoint:      "budgets.amazonaws.com",
-			SigningRegion: "us-east-1",
-		},
-		"*/cloudfront": {
-			Endpoint:      "cloudfront.amazonaws.com",
-			SigningRegion: "us-east-1",
-		},
-		"*/cloudsearchdomain": {
-			Endpoint:      "",
-			SigningRegion: "us-east-1",
-		},
-		"*/data.iot": {
-			Endpoint:      "",
-			SigningRegion: "us-east-1",
-		},
-		"*/ec2metadata": {
-			Endpoint: "http://169.254.169.254/latest",
-		},
-		"*/iam": {
-			Endpoint:      "iam.amazonaws.com",
-			SigningRegion: "us-east-1",
-		},
-		"*/importexport": {
-			Endpoint:      "importexport.amazonaws.com",
-			SigningRegion: "us-east-1",
-		},
-		"*/route53": {
-			Endpoint:      "route53.amazonaws.com",
-			SigningRegion: "us-east-1",
-		},
-		"*/s3": {
-			Endpoint: "s3-{region}.amazonaws.com",
-		},
-		"*/s3/dualstack": {
-			Endpoint: "s3.dualstack.{region}.amazonaws.com",
-		},
-		"*/sts": {
-			Endpoint:      "sts.amazonaws.com",
-			SigningRegion: "us-east-1",
-		},
-		"*/waf": {
-			Endpoint:      "waf.amazonaws.com",
-			SigningRegion: "us-east-1",
-		},
-		"cn-north-1/*": {
-			Endpoint: "{service}.{region}.amazonaws.com.cn",
-		},
-		"cn-north-1/ec2metadata": {
-			Endpoint: "http://169.254.169.254/latest",
-		},
-		"eu-central-1/s3": {
-			Endpoint: "{service}.{region}.amazonaws.com",
-		},
-		"us-east-1/s3": {
-			Endpoint: "s3.amazonaws.com",
-		},
-		"us-east-1/sdb": {
-			Endpoint:      "sdb.amazonaws.com",
-			SigningRegion: "us-east-1",
-		},
-		"us-gov-west-1/ec2metadata": {
-			Endpoint: "http://169.254.169.254/latest",
-		},
-		"us-gov-west-1/iam": {
-			Endpoint: "iam.us-gov.amazonaws.com",
-		},
-		"us-gov-west-1/s3": {
-			Endpoint: "s3-{region}.amazonaws.com",
-		},
-		"us-gov-west-1/sts": {
-			Endpoint: "sts.us-gov-west-1.amazonaws.com",
-		},
-	},
-}

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

@@ -111,11 +111,8 @@ func parseStruct(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
 		elems := node.Children[name]
 
 		if elems == nil { // try to find the field in attributes
-			for _, a := range node.Attr {
+			if val, ok := node.findElem(name); ok {
-				if name == strings.Join([]string{a.Name.Space, a.Name.Local}, ":") {
+				elems = []*XMLNode{{Text: val}}
-					// turn this into a text node for de-serializing
-					elems = []*XMLNode{{Text: a.Value}}
-				}
 			}
 		}
 

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

@@ -2,6 +2,7 @@ package xmlutil
 
 import (
 	"encoding/xml"
+	"fmt"
 	"io"
 	"sort"
 )
@@ -12,6 +13,9 @@ type XMLNode struct {
 	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.
@@ -59,41 +63,52 @@ func XMLToStruct(d *xml.Decoder, s *xml.StartElement) (*XMLNode, error) {
 				slice = []*XMLNode{}
 			}
 			node, e := XMLToStruct(d, &el)
+			out.findNamespaces()
 			if e != nil {
 				return out, e
 			}
 			node.Name = typed.Name
-			node.Attr = out.Attr
+			node.findNamespaces()
-			node = adaptNode(node)
+			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 adaptNode(node *XMLNode) *XMLNode {
+func (n *XMLNode) findNamespaces() {
 	ns := map[string]string{}
-	for _, a := range node.Attr {
+	for _, a := range n.Attr {
 		if a.Name.Space == "xmlns" {
 			ns[a.Value] = a.Name.Local
-			break
 		}
 	}
 
-	for i, a := range node.Attr {
+	n.namespaces = ns
-		if a.Name.Space == "xmlns" {
+}
-			continue
+
+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 v, ok := ns[node.Attr[i].Name.Space]; ok {
+			if name == fmt.Sprintf("%s:%s", namespace, a.Name.Local) {
-			node.Attr[i].Name.Space = v
+				return a.Value, true
 			}
 		}
-	return node
+	}
+	return "", false
 }
 
 // StructToXML writes an XMLNode to a xml.Encoder as tokens.

vendor/github.com/aws/aws-sdk-go/service/acm/service.go

@@ -43,16 +43,17 @@ const ServiceName = "acm"
 //     svc := acm.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *ACM {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *ACM {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *ACM {
 	svc := &ACM{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2015-12-08",

vendor/github.com/aws/aws-sdk-go/service/apigateway/service.go

@@ -43,16 +43,17 @@ const ServiceName = "apigateway"
 //     svc := apigateway.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *APIGateway {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *APIGateway {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *APIGateway {
 	svc := &APIGateway{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2015-07-09",

vendor/github.com/aws/aws-sdk-go/service/applicationautoscaling/service.go

@@ -65,17 +65,20 @@ const ServiceName = "autoscaling"
 //     svc := applicationautoscaling.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *ApplicationAutoScaling {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *ApplicationAutoScaling {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *ApplicationAutoScaling {
+	if len(signingName) == 0 {
+		signingName = "application-autoscaling"
+	}
 	svc := &ApplicationAutoScaling{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
-				SigningName:   "application-autoscaling",
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2016-02-06",

vendor/github.com/aws/aws-sdk-go/service/autoscaling/service.go

@@ -41,16 +41,17 @@ const ServiceName = "autoscaling"
 //     svc := autoscaling.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *AutoScaling {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *AutoScaling {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *AutoScaling {
 	svc := &AutoScaling{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2011-01-01",

vendor/github.com/aws/aws-sdk-go/service/cloudformation/service.go

@@ -57,16 +57,17 @@ const ServiceName = "cloudformation"
 //     svc := cloudformation.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *CloudFormation {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *CloudFormation {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *CloudFormation {
 	svc := &CloudFormation{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2010-05-15",

vendor/github.com/aws/aws-sdk-go/service/cloudfront/api.go

@@ -13,7 +13,7 @@ import (
 	"github.com/aws/aws-sdk-go/private/protocol/restxml"
 )
 
-const opCreateCloudFrontOriginAccessIdentity = "CreateCloudFrontOriginAccessIdentity2016_09_29"
+const opCreateCloudFrontOriginAccessIdentity = "CreateCloudFrontOriginAccessIdentity2016_11_25"
 
 // CreateCloudFrontOriginAccessIdentityRequest generates a "aws/request.Request" representing the
 // client's request for the CreateCloudFrontOriginAccessIdentity operation. The "output" return
@@ -43,7 +43,7 @@ func (c *CloudFront) CreateCloudFrontOriginAccessIdentityRequest(input *CreateCl
 	op := &request.Operation{
 		Name:       opCreateCloudFrontOriginAccessIdentity,
 		HTTPMethod: "POST",
-		HTTPPath:   "/2016-09-29/origin-access-identity/cloudfront",
+		HTTPPath:   "/2016-11-25/origin-access-identity/cloudfront",
 	}
 
 	if input == nil {
@@ -99,7 +99,7 @@ func (c *CloudFront) CreateCloudFrontOriginAccessIdentity(input *CreateCloudFron
 	return out, err
 }
 
-const opCreateDistribution = "CreateDistribution2016_09_29"
+const opCreateDistribution = "CreateDistribution2016_11_25"
 
 // CreateDistributionRequest generates a "aws/request.Request" representing the
 // client's request for the CreateDistribution operation. The "output" return
@@ -129,7 +129,7 @@ func (c *CloudFront) CreateDistributionRequest(input *CreateDistributionInput) (
 	op := &request.Operation{
 		Name:       opCreateDistribution,
 		HTTPMethod: "POST",
-		HTTPPath:   "/2016-09-29/distribution",
+		HTTPPath:   "/2016-11-25/distribution",
 	}
 
 	if input == nil {
@@ -271,6 +271,17 @@ func (c *CloudFront) CreateDistributionRequest(input *CreateDistributionInput) (
 //
 //   * InvalidQueryStringParameters
 
+//
+//   * TooManyDistributionsWithLambdaAssociations
+//   Processing your request would cause the maximum number of distributions with
+//   Lambda function associations per owner to be exceeded.
+//
+//   * TooManyLambdaFunctionAssociations
+//   Your request contains more Lambda function associations than are allowed
+//   per distribution.
+//
+//   * InvalidLambdaFunctionAssociation
+//   The specified Lambda function association is invalid.
 //
 func (c *CloudFront) CreateDistribution(input *CreateDistributionInput) (*CreateDistributionOutput, error) {
 	req, out := c.CreateDistributionRequest(input)
@@ -278,7 +289,7 @@ func (c *CloudFront) CreateDistribution(input *CreateDistributionInput) (*Create
 	return out, err
 }
 
-const opCreateDistributionWithTags = "CreateDistributionWithTags2016_09_29"
+const opCreateDistributionWithTags = "CreateDistributionWithTags2016_11_25"
 
 // CreateDistributionWithTagsRequest generates a "aws/request.Request" representing the
 // client's request for the CreateDistributionWithTags operation. The "output" return
@@ -308,7 +319,7 @@ func (c *CloudFront) CreateDistributionWithTagsRequest(input *CreateDistribution
 	op := &request.Operation{
 		Name:       opCreateDistributionWithTags,
 		HTTPMethod: "POST",
-		HTTPPath:   "/2016-09-29/distribution?WithTags",
+		HTTPPath:   "/2016-11-25/distribution?WithTags",
 	}
 
 	if input == nil {
@@ -452,6 +463,17 @@ func (c *CloudFront) CreateDistributionWithTagsRequest(input *CreateDistribution
 //
 //   * InvalidQueryStringParameters
 
+//
+//   * TooManyDistributionsWithLambdaAssociations
+//   Processing your request would cause the maximum number of distributions with
+//   Lambda function associations per owner to be exceeded.
+//
+//   * TooManyLambdaFunctionAssociations
+//   Your request contains more Lambda function associations than are allowed
+//   per distribution.
+//
+//   * InvalidLambdaFunctionAssociation
+//   The specified Lambda function association is invalid.
 //
 func (c *CloudFront) CreateDistributionWithTags(input *CreateDistributionWithTagsInput) (*CreateDistributionWithTagsOutput, error) {
 	req, out := c.CreateDistributionWithTagsRequest(input)
@@ -459,7 +481,7 @@ func (c *CloudFront) CreateDistributionWithTags(input *CreateDistributionWithTag
 	return out, err
 }
 
-const opCreateInvalidation = "CreateInvalidation2016_09_29"
+const opCreateInvalidation = "CreateInvalidation2016_11_25"
 
 // CreateInvalidationRequest generates a "aws/request.Request" representing the
 // client's request for the CreateInvalidation operation. The "output" return
@@ -489,7 +511,7 @@ func (c *CloudFront) CreateInvalidationRequest(input *CreateInvalidationInput) (
 	op := &request.Operation{
 		Name:       opCreateInvalidation,
 		HTTPMethod: "POST",
-		HTTPPath:   "/2016-09-29/distribution/{DistributionId}/invalidation",
+		HTTPPath:   "/2016-11-25/distribution/{DistributionId}/invalidation",
 	}
 
 	if input == nil {
@@ -543,7 +565,7 @@ func (c *CloudFront) CreateInvalidation(input *CreateInvalidationInput) (*Create
 	return out, err
 }
 
-const opCreateStreamingDistribution = "CreateStreamingDistribution2016_09_29"
+const opCreateStreamingDistribution = "CreateStreamingDistribution2016_11_25"
 
 // CreateStreamingDistributionRequest generates a "aws/request.Request" representing the
 // client's request for the CreateStreamingDistribution operation. The "output" return
@@ -573,7 +595,7 @@ func (c *CloudFront) CreateStreamingDistributionRequest(input *CreateStreamingDi
 	op := &request.Operation{
 		Name:       opCreateStreamingDistribution,
 		HTTPMethod: "POST",
-		HTTPPath:   "/2016-09-29/streaming-distribution",
+		HTTPPath:   "/2016-11-25/streaming-distribution",
 	}
 
 	if input == nil {
@@ -670,7 +692,7 @@ func (c *CloudFront) CreateStreamingDistribution(input *CreateStreamingDistribut
 	return out, err
 }
 
-const opCreateStreamingDistributionWithTags = "CreateStreamingDistributionWithTags2016_09_29"
+const opCreateStreamingDistributionWithTags = "CreateStreamingDistributionWithTags2016_11_25"
 
 // CreateStreamingDistributionWithTagsRequest generates a "aws/request.Request" representing the
 // client's request for the CreateStreamingDistributionWithTags operation. The "output" return
@@ -700,7 +722,7 @@ func (c *CloudFront) CreateStreamingDistributionWithTagsRequest(input *CreateStr
 	op := &request.Operation{
 		Name:       opCreateStreamingDistributionWithTags,
 		HTTPMethod: "POST",
-		HTTPPath:   "/2016-09-29/streaming-distribution?WithTags",
+		HTTPPath:   "/2016-11-25/streaming-distribution?WithTags",
 	}
 
 	if input == nil {
@@ -773,7 +795,7 @@ func (c *CloudFront) CreateStreamingDistributionWithTags(input *CreateStreamingD
 	return out, err
 }
 
-const opDeleteCloudFrontOriginAccessIdentity = "DeleteCloudFrontOriginAccessIdentity2016_09_29"
+const opDeleteCloudFrontOriginAccessIdentity = "DeleteCloudFrontOriginAccessIdentity2016_11_25"
 
 // DeleteCloudFrontOriginAccessIdentityRequest generates a "aws/request.Request" representing the
 // client's request for the DeleteCloudFrontOriginAccessIdentity operation. The "output" return
@@ -803,7 +825,7 @@ func (c *CloudFront) DeleteCloudFrontOriginAccessIdentityRequest(input *DeleteCl
 	op := &request.Operation{
 		Name:       opDeleteCloudFrontOriginAccessIdentity,
 		HTTPMethod: "DELETE",
-		HTTPPath:   "/2016-09-29/origin-access-identity/cloudfront/{Id}",
+		HTTPPath:   "/2016-11-25/origin-access-identity/cloudfront/{Id}",
 	}
 
 	if input == nil {
@@ -852,7 +874,7 @@ func (c *CloudFront) DeleteCloudFrontOriginAccessIdentity(input *DeleteCloudFron
 	return out, err
 }
 
-const opDeleteDistribution = "DeleteDistribution2016_09_29"
+const opDeleteDistribution = "DeleteDistribution2016_11_25"
 
 // DeleteDistributionRequest generates a "aws/request.Request" representing the
 // client's request for the DeleteDistribution operation. The "output" return
@@ -882,7 +904,7 @@ func (c *CloudFront) DeleteDistributionRequest(input *DeleteDistributionInput) (
 	op := &request.Operation{
 		Name:       opDeleteDistribution,
 		HTTPMethod: "DELETE",
-		HTTPPath:   "/2016-09-29/distribution/{Id}",
+		HTTPPath:   "/2016-11-25/distribution/{Id}",
 	}
 
 	if input == nil {
@@ -931,7 +953,7 @@ func (c *CloudFront) DeleteDistribution(input *DeleteDistributionInput) (*Delete
 	return out, err
 }
 
-const opDeleteStreamingDistribution = "DeleteStreamingDistribution2016_09_29"
+const opDeleteStreamingDistribution = "DeleteStreamingDistribution2016_11_25"
 
 // DeleteStreamingDistributionRequest generates a "aws/request.Request" representing the
 // client's request for the DeleteStreamingDistribution operation. The "output" return
@@ -961,7 +983,7 @@ func (c *CloudFront) DeleteStreamingDistributionRequest(input *DeleteStreamingDi
 	op := &request.Operation{
 		Name:       opDeleteStreamingDistribution,
 		HTTPMethod: "DELETE",
-		HTTPPath:   "/2016-09-29/streaming-distribution/{Id}",
+		HTTPPath:   "/2016-11-25/streaming-distribution/{Id}",
 	}
 
 	if input == nil {
@@ -1045,7 +1067,7 @@ func (c *CloudFront) DeleteStreamingDistribution(input *DeleteStreamingDistribut
 	return out, err
 }
 
-const opGetCloudFrontOriginAccessIdentity = "GetCloudFrontOriginAccessIdentity2016_09_29"
+const opGetCloudFrontOriginAccessIdentity = "GetCloudFrontOriginAccessIdentity2016_11_25"
 
 // GetCloudFrontOriginAccessIdentityRequest generates a "aws/request.Request" representing the
 // client's request for the GetCloudFrontOriginAccessIdentity operation. The "output" return
@@ -1075,7 +1097,7 @@ func (c *CloudFront) GetCloudFrontOriginAccessIdentityRequest(input *GetCloudFro
 	op := &request.Operation{
 		Name:       opGetCloudFrontOriginAccessIdentity,
 		HTTPMethod: "GET",
-		HTTPPath:   "/2016-09-29/origin-access-identity/cloudfront/{Id}",
+		HTTPPath:   "/2016-11-25/origin-access-identity/cloudfront/{Id}",
 	}
 
 	if input == nil {
@@ -1112,7 +1134,7 @@ func (c *CloudFront) GetCloudFrontOriginAccessIdentity(input *GetCloudFrontOrigi
 	return out, err
 }
 
-const opGetCloudFrontOriginAccessIdentityConfig = "GetCloudFrontOriginAccessIdentityConfig2016_09_29"
+const opGetCloudFrontOriginAccessIdentityConfig = "GetCloudFrontOriginAccessIdentityConfig2016_11_25"
 
 // GetCloudFrontOriginAccessIdentityConfigRequest generates a "aws/request.Request" representing the
 // client's request for the GetCloudFrontOriginAccessIdentityConfig operation. The "output" return
@@ -1142,7 +1164,7 @@ func (c *CloudFront) GetCloudFrontOriginAccessIdentityConfigRequest(input *GetCl
 	op := &request.Operation{
 		Name:       opGetCloudFrontOriginAccessIdentityConfig,
 		HTTPMethod: "GET",
-		HTTPPath:   "/2016-09-29/origin-access-identity/cloudfront/{Id}/config",
+		HTTPPath:   "/2016-11-25/origin-access-identity/cloudfront/{Id}/config",
 	}
 
 	if input == nil {
@@ -1179,7 +1201,7 @@ func (c *CloudFront) GetCloudFrontOriginAccessIdentityConfig(input *GetCloudFron
 	return out, err
 }
 
-const opGetDistribution = "GetDistribution2016_09_29"
+const opGetDistribution = "GetDistribution2016_11_25"
 
 // GetDistributionRequest generates a "aws/request.Request" representing the
 // client's request for the GetDistribution operation. The "output" return
@@ -1209,7 +1231,7 @@ func (c *CloudFront) GetDistributionRequest(input *GetDistributionInput) (req *r
 	op := &request.Operation{
 		Name:       opGetDistribution,
 		HTTPMethod: "GET",
-		HTTPPath:   "/2016-09-29/distribution/{Id}",
+		HTTPPath:   "/2016-11-25/distribution/{Id}",
 	}
 
 	if input == nil {
@@ -1246,7 +1268,7 @@ func (c *CloudFront) GetDistribution(input *GetDistributionInput) (*GetDistribut
 	return out, err
 }
 
-const opGetDistributionConfig = "GetDistributionConfig2016_09_29"
+const opGetDistributionConfig = "GetDistributionConfig2016_11_25"
 
 // GetDistributionConfigRequest generates a "aws/request.Request" representing the
 // client's request for the GetDistributionConfig operation. The "output" return
@@ -1276,7 +1298,7 @@ func (c *CloudFront) GetDistributionConfigRequest(input *GetDistributionConfigIn
 	op := &request.Operation{
 		Name:       opGetDistributionConfig,
 		HTTPMethod: "GET",
-		HTTPPath:   "/2016-09-29/distribution/{Id}/config",
+		HTTPPath:   "/2016-11-25/distribution/{Id}/config",
 	}
 
 	if input == nil {
@@ -1313,7 +1335,7 @@ func (c *CloudFront) GetDistributionConfig(input *GetDistributionConfigInput) (*
 	return out, err
 }
 
-const opGetInvalidation = "GetInvalidation2016_09_29"
+const opGetInvalidation = "GetInvalidation2016_11_25"
 
 // GetInvalidationRequest generates a "aws/request.Request" representing the
 // client's request for the GetInvalidation operation. The "output" return
@@ -1343,7 +1365,7 @@ func (c *CloudFront) GetInvalidationRequest(input *GetInvalidationInput) (req *r
 	op := &request.Operation{
 		Name:       opGetInvalidation,
 		HTTPMethod: "GET",
-		HTTPPath:   "/2016-09-29/distribution/{DistributionId}/invalidation/{Id}",
+		HTTPPath:   "/2016-11-25/distribution/{DistributionId}/invalidation/{Id}",
 	}
 
 	if input == nil {
@@ -1383,7 +1405,7 @@ func (c *CloudFront) GetInvalidation(input *GetInvalidationInput) (*GetInvalidat
 	return out, err
 }
 
-const opGetStreamingDistribution = "GetStreamingDistribution2016_09_29"
+const opGetStreamingDistribution = "GetStreamingDistribution2016_11_25"
 
 // GetStreamingDistributionRequest generates a "aws/request.Request" representing the
 // client's request for the GetStreamingDistribution operation. The "output" return
@@ -1413,7 +1435,7 @@ func (c *CloudFront) GetStreamingDistributionRequest(input *GetStreamingDistribu
 	op := &request.Operation{
 		Name:       opGetStreamingDistribution,
 		HTTPMethod: "GET",
-		HTTPPath:   "/2016-09-29/streaming-distribution/{Id}",
+		HTTPPath:   "/2016-11-25/streaming-distribution/{Id}",
 	}
 
 	if input == nil {
@@ -1451,7 +1473,7 @@ func (c *CloudFront) GetStreamingDistribution(input *GetStreamingDistributionInp
 	return out, err
 }
 
-const opGetStreamingDistributionConfig = "GetStreamingDistributionConfig2016_09_29"
+const opGetStreamingDistributionConfig = "GetStreamingDistributionConfig2016_11_25"
 
 // GetStreamingDistributionConfigRequest generates a "aws/request.Request" representing the
 // client's request for the GetStreamingDistributionConfig operation. The "output" return
@@ -1481,7 +1503,7 @@ func (c *CloudFront) GetStreamingDistributionConfigRequest(input *GetStreamingDi
 	op := &request.Operation{
 		Name:       opGetStreamingDistributionConfig,
 		HTTPMethod: "GET",
-		HTTPPath:   "/2016-09-29/streaming-distribution/{Id}/config",
+		HTTPPath:   "/2016-11-25/streaming-distribution/{Id}/config",
 	}
 
 	if input == nil {
@@ -1518,7 +1540,7 @@ func (c *CloudFront) GetStreamingDistributionConfig(input *GetStreamingDistribut
 	return out, err
 }
 
-const opListCloudFrontOriginAccessIdentities = "ListCloudFrontOriginAccessIdentities2016_09_29"
+const opListCloudFrontOriginAccessIdentities = "ListCloudFrontOriginAccessIdentities2016_11_25"
 
 // ListCloudFrontOriginAccessIdentitiesRequest generates a "aws/request.Request" representing the
 // client's request for the ListCloudFrontOriginAccessIdentities operation. The "output" return
@@ -1548,7 +1570,7 @@ func (c *CloudFront) ListCloudFrontOriginAccessIdentitiesRequest(input *ListClou
 	op := &request.Operation{
 		Name:       opListCloudFrontOriginAccessIdentities,
 		HTTPMethod: "GET",
-		HTTPPath:   "/2016-09-29/origin-access-identity/cloudfront",
+		HTTPPath:   "/2016-11-25/origin-access-identity/cloudfront",
 		Paginator: &request.Paginator{
 			InputTokens:     []string{"Marker"},
 			OutputTokens:    []string{"CloudFrontOriginAccessIdentityList.NextMarker"},
@@ -1613,7 +1635,7 @@ func (c *CloudFront) ListCloudFrontOriginAccessIdentitiesPages(input *ListCloudF
 	})
 }
 
-const opListDistributions = "ListDistributions2016_09_29"
+const opListDistributions = "ListDistributions2016_11_25"
 
 // ListDistributionsRequest generates a "aws/request.Request" representing the
 // client's request for the ListDistributions operation. The "output" return
@@ -1643,7 +1665,7 @@ func (c *CloudFront) ListDistributionsRequest(input *ListDistributionsInput) (re
 	op := &request.Operation{
 		Name:       opListDistributions,
 		HTTPMethod: "GET",
-		HTTPPath:   "/2016-09-29/distribution",
+		HTTPPath:   "/2016-11-25/distribution",
 		Paginator: &request.Paginator{
 			InputTokens:     []string{"Marker"},
 			OutputTokens:    []string{"DistributionList.NextMarker"},
@@ -1708,7 +1730,7 @@ func (c *CloudFront) ListDistributionsPages(input *ListDistributionsInput, fn fu
 	})
 }
 
-const opListDistributionsByWebACLId = "ListDistributionsByWebACLId2016_09_29"
+const opListDistributionsByWebACLId = "ListDistributionsByWebACLId2016_11_25"
 
 // ListDistributionsByWebACLIdRequest generates a "aws/request.Request" representing the
 // client's request for the ListDistributionsByWebACLId operation. The "output" return
@@ -1738,7 +1760,7 @@ func (c *CloudFront) ListDistributionsByWebACLIdRequest(input *ListDistributions
 	op := &request.Operation{
 		Name:       opListDistributionsByWebACLId,
 		HTTPMethod: "GET",
-		HTTPPath:   "/2016-09-29/distributionsByWebACLId/{WebACLId}",
+		HTTPPath:   "/2016-11-25/distributionsByWebACLId/{WebACLId}",
 	}
 
 	if input == nil {
@@ -1775,7 +1797,7 @@ func (c *CloudFront) ListDistributionsByWebACLId(input *ListDistributionsByWebAC
 	return out, err
 }
 
-const opListInvalidations = "ListInvalidations2016_09_29"
+const opListInvalidations = "ListInvalidations2016_11_25"
 
 // ListInvalidationsRequest generates a "aws/request.Request" representing the
 // client's request for the ListInvalidations operation. The "output" return
@@ -1805,7 +1827,7 @@ func (c *CloudFront) ListInvalidationsRequest(input *ListInvalidationsInput) (re
 	op := &request.Operation{
 		Name:       opListInvalidations,
 		HTTPMethod: "GET",
-		HTTPPath:   "/2016-09-29/distribution/{DistributionId}/invalidation",
+		HTTPPath:   "/2016-11-25/distribution/{DistributionId}/invalidation",
 		Paginator: &request.Paginator{
 			InputTokens:     []string{"Marker"},
 			OutputTokens:    []string{"InvalidationList.NextMarker"},
@@ -1876,7 +1898,7 @@ func (c *CloudFront) ListInvalidationsPages(input *ListInvalidationsInput, fn fu
 	})
 }
 
-const opListStreamingDistributions = "ListStreamingDistributions2016_09_29"
+const opListStreamingDistributions = "ListStreamingDistributions2016_11_25"
 
 // ListStreamingDistributionsRequest generates a "aws/request.Request" representing the
 // client's request for the ListStreamingDistributions operation. The "output" return
@@ -1906,7 +1928,7 @@ func (c *CloudFront) ListStreamingDistributionsRequest(input *ListStreamingDistr
 	op := &request.Operation{
 		Name:       opListStreamingDistributions,
 		HTTPMethod: "GET",
-		HTTPPath:   "/2016-09-29/streaming-distribution",
+		HTTPPath:   "/2016-11-25/streaming-distribution",
 		Paginator: &request.Paginator{
 			InputTokens:     []string{"Marker"},
 			OutputTokens:    []string{"StreamingDistributionList.NextMarker"},
@@ -1971,7 +1993,7 @@ func (c *CloudFront) ListStreamingDistributionsPages(input *ListStreamingDistrib
 	})
 }
 
-const opListTagsForResource = "ListTagsForResource2016_09_29"
+const opListTagsForResource = "ListTagsForResource2016_11_25"
 
 // ListTagsForResourceRequest generates a "aws/request.Request" representing the
 // client's request for the ListTagsForResource operation. The "output" return
@@ -2001,7 +2023,7 @@ func (c *CloudFront) ListTagsForResourceRequest(input *ListTagsForResourceInput)
 	op := &request.Operation{
 		Name:       opListTagsForResource,
 		HTTPMethod: "GET",
-		HTTPPath:   "/2016-09-29/tagging",
+		HTTPPath:   "/2016-11-25/tagging",
 	}
 
 	if input == nil {
@@ -2044,7 +2066,7 @@ func (c *CloudFront) ListTagsForResource(input *ListTagsForResourceInput) (*List
 	return out, err
 }
 
-const opTagResource = "TagResource2016_09_29"
+const opTagResource = "TagResource2016_11_25"
 
 // TagResourceRequest generates a "aws/request.Request" representing the
 // client's request for the TagResource operation. The "output" return
@@ -2074,7 +2096,7 @@ func (c *CloudFront) TagResourceRequest(input *TagResourceInput) (req *request.R
 	op := &request.Operation{
 		Name:       opTagResource,
 		HTTPMethod: "POST",
-		HTTPPath:   "/2016-09-29/tagging?Operation=Tag",
+		HTTPPath:   "/2016-11-25/tagging?Operation=Tag",
 	}
 
 	if input == nil {
@@ -2119,7 +2141,7 @@ func (c *CloudFront) TagResource(input *TagResourceInput) (*TagResourceOutput, e
 	return out, err
 }
 
-const opUntagResource = "UntagResource2016_09_29"
+const opUntagResource = "UntagResource2016_11_25"
 
 // UntagResourceRequest generates a "aws/request.Request" representing the
 // client's request for the UntagResource operation. The "output" return
@@ -2149,7 +2171,7 @@ func (c *CloudFront) UntagResourceRequest(input *UntagResourceInput) (req *reque
 	op := &request.Operation{
 		Name:       opUntagResource,
 		HTTPMethod: "POST",
-		HTTPPath:   "/2016-09-29/tagging?Operation=Untag",
+		HTTPPath:   "/2016-11-25/tagging?Operation=Untag",
 	}
 
 	if input == nil {
@@ -2194,7 +2216,7 @@ func (c *CloudFront) UntagResource(input *UntagResourceInput) (*UntagResourceOut
 	return out, err
 }
 
-const opUpdateCloudFrontOriginAccessIdentity = "UpdateCloudFrontOriginAccessIdentity2016_09_29"
+const opUpdateCloudFrontOriginAccessIdentity = "UpdateCloudFrontOriginAccessIdentity2016_11_25"
 
 // UpdateCloudFrontOriginAccessIdentityRequest generates a "aws/request.Request" representing the
 // client's request for the UpdateCloudFrontOriginAccessIdentity operation. The "output" return
@@ -2224,7 +2246,7 @@ func (c *CloudFront) UpdateCloudFrontOriginAccessIdentityRequest(input *UpdateCl
 	op := &request.Operation{
 		Name:       opUpdateCloudFrontOriginAccessIdentity,
 		HTTPMethod: "PUT",
-		HTTPPath:   "/2016-09-29/origin-access-identity/cloudfront/{Id}/config",
+		HTTPPath:   "/2016-11-25/origin-access-identity/cloudfront/{Id}/config",
 	}
 
 	if input == nil {
@@ -2281,7 +2303,7 @@ func (c *CloudFront) UpdateCloudFrontOriginAccessIdentity(input *UpdateCloudFron
 	return out, err
 }
 
-const opUpdateDistribution = "UpdateDistribution2016_09_29"
+const opUpdateDistribution = "UpdateDistribution2016_11_25"
 
 // UpdateDistributionRequest generates a "aws/request.Request" representing the
 // client's request for the UpdateDistribution operation. The "output" return
@@ -2311,7 +2333,7 @@ func (c *CloudFront) UpdateDistributionRequest(input *UpdateDistributionInput) (
 	op := &request.Operation{
 		Name:       opUpdateDistribution,
 		HTTPMethod: "PUT",
-		HTTPPath:   "/2016-09-29/distribution/{Id}/config",
+		HTTPPath:   "/2016-11-25/distribution/{Id}/config",
 	}
 
 	if input == nil {
@@ -2449,6 +2471,17 @@ func (c *CloudFront) UpdateDistributionRequest(input *UpdateDistributionInput) (
 //
 //   * InvalidQueryStringParameters
 
+//
+//   * TooManyDistributionsWithLambdaAssociations
+//   Processing your request would cause the maximum number of distributions with
+//   Lambda function associations per owner to be exceeded.
+//
+//   * TooManyLambdaFunctionAssociations
+//   Your request contains more Lambda function associations than are allowed
+//   per distribution.
+//
+//   * InvalidLambdaFunctionAssociation
+//   The specified Lambda function association is invalid.
 //
 func (c *CloudFront) UpdateDistribution(input *UpdateDistributionInput) (*UpdateDistributionOutput, error) {
 	req, out := c.UpdateDistributionRequest(input)
@@ -2456,7 +2489,7 @@ func (c *CloudFront) UpdateDistribution(input *UpdateDistributionInput) (*Update
 	return out, err
 }
 
-const opUpdateStreamingDistribution = "UpdateStreamingDistribution2016_09_29"
+const opUpdateStreamingDistribution = "UpdateStreamingDistribution2016_11_25"
 
 // UpdateStreamingDistributionRequest generates a "aws/request.Request" representing the
 // client's request for the UpdateStreamingDistribution operation. The "output" return
@@ -2486,7 +2519,7 @@ func (c *CloudFront) UpdateStreamingDistributionRequest(input *UpdateStreamingDi
 	op := &request.Operation{
 		Name:       opUpdateStreamingDistribution,
 		HTTPMethod: "PUT",
-		HTTPPath:   "/2016-09-29/streaming-distribution/{Id}/config",
+		HTTPPath:   "/2016-11-25/streaming-distribution/{Id}/config",
 	}
 
 	if input == nil {
@@ -2835,6 +2868,10 @@ type CacheBehavior struct {
 	// ForwardedValues is a required field
 	ForwardedValues *ForwardedValues `type:"structure" required:"true"`
 
+	// A complex type that contains zero or more Lambda function associations for
+	// a cache behavior.
+	LambdaFunctionAssociations *LambdaFunctionAssociations `type:"structure"`
+
 	// The maximum amount of time that you want objects to stay in CloudFront caches
 	// before CloudFront forwards another request to your origin to determine whether
 	// the object has been updated. The value that you specify applies only when
@@ -2982,6 +3019,11 @@ func (s *CacheBehavior) Validate() error {
 			invalidParams.AddNested("ForwardedValues", err.(request.ErrInvalidParams))
 		}
 	}
+	if s.LambdaFunctionAssociations != nil {
+		if err := s.LambdaFunctionAssociations.Validate(); err != nil {
+			invalidParams.AddNested("LambdaFunctionAssociations", err.(request.ErrInvalidParams))
+		}
+	}
 	if s.TrustedSigners != nil {
 		if err := s.TrustedSigners.Validate(); err != nil {
 			invalidParams.AddNested("TrustedSigners", err.(request.ErrInvalidParams))
@@ -3018,6 +3060,12 @@ func (s *CacheBehavior) SetForwardedValues(v *ForwardedValues) *CacheBehavior {
 	return s
 }
 
+// SetLambdaFunctionAssociations sets the LambdaFunctionAssociations field's value.
+func (s *CacheBehavior) SetLambdaFunctionAssociations(v *LambdaFunctionAssociations) *CacheBehavior {
+	s.LambdaFunctionAssociations = v
+	return s
+}
+
 // SetMaxTTL sets the MaxTTL field's value.
 func (s *CacheBehavior) SetMaxTTL(v int64) *CacheBehavior {
 	s.MaxTTL = &v
@@ -4221,6 +4269,10 @@ type DefaultCacheBehavior struct {
 	// ForwardedValues is a required field
 	ForwardedValues *ForwardedValues `type:"structure" required:"true"`
 
+	// A complex type that contains zero or more Lambda function associations for
+	// a cache behavior.
+	LambdaFunctionAssociations *LambdaFunctionAssociations `type:"structure"`
+
 	MaxTTL *int64 `type:"long"`
 
 	// The minimum amount of time that you want objects to stay in CloudFront caches
@@ -4338,6 +4390,11 @@ func (s *DefaultCacheBehavior) Validate() error {
 			invalidParams.AddNested("ForwardedValues", err.(request.ErrInvalidParams))
 		}
 	}
+	if s.LambdaFunctionAssociations != nil {
+		if err := s.LambdaFunctionAssociations.Validate(); err != nil {
+			invalidParams.AddNested("LambdaFunctionAssociations", err.(request.ErrInvalidParams))
+		}
+	}
 	if s.TrustedSigners != nil {
 		if err := s.TrustedSigners.Validate(); err != nil {
 			invalidParams.AddNested("TrustedSigners", err.(request.ErrInvalidParams))
@@ -4374,6 +4431,12 @@ func (s *DefaultCacheBehavior) SetForwardedValues(v *ForwardedValues) *DefaultCa
 	return s
 }
 
+// SetLambdaFunctionAssociations sets the LambdaFunctionAssociations field's value.
+func (s *DefaultCacheBehavior) SetLambdaFunctionAssociations(v *LambdaFunctionAssociations) *DefaultCacheBehavior {
+	s.LambdaFunctionAssociations = v
+	return s
+}
+
 // SetMaxTTL sets the MaxTTL field's value.
 func (s *DefaultCacheBehavior) SetMaxTTL(v int64) *DefaultCacheBehavior {
 	s.MaxTTL = &v
@@ -6603,6 +6666,107 @@ func (s *KeyPairIds) SetQuantity(v int64) *KeyPairIds {
 	return s
 }
 
+// A complex type that contains a Lambda function association.
+type LambdaFunctionAssociation struct {
+	_ struct{} `type:"structure"`
+
+	// Specifies the event type that triggers a Lambda function invocation. Valid
+	// values are:
+	//
+	//    * viewer-request
+	//
+	//    * origin-request
+	//
+	//    * viewer-response
+	//
+	//    * origin-response
+	EventType *string `type:"string" enum:"EventType"`
+
+	// The ARN of the Lambda function.
+	LambdaFunctionARN *string `type:"string"`
+}
+
+// String returns the string representation
+func (s LambdaFunctionAssociation) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s LambdaFunctionAssociation) GoString() string {
+	return s.String()
+}
+
+// SetEventType sets the EventType field's value.
+func (s *LambdaFunctionAssociation) SetEventType(v string) *LambdaFunctionAssociation {
+	s.EventType = &v
+	return s
+}
+
+// SetLambdaFunctionARN sets the LambdaFunctionARN field's value.
+func (s *LambdaFunctionAssociation) SetLambdaFunctionARN(v string) *LambdaFunctionAssociation {
+	s.LambdaFunctionARN = &v
+	return s
+}
+
+// A complex type that specifies a list of Lambda functions associations for
+// a cache behavior.
+//
+// If you want to invoke one or more Lambda functions triggered by requests
+// that match the PathPattern of the cache behavior, specify the applicable
+// values for Quantity and Items. Note that there can be up to 4 LambdaFunctionAssociation
+// items in this list (one for each possible value of EventType) and each EventType
+// can be associated with the Lambda function only once.
+//
+// If you don't want to invoke any Lambda functions for the requests that match
+// PathPattern, specify 0 for Quantity and omit Items.
+type LambdaFunctionAssociations struct {
+	_ struct{} `type:"structure"`
+
+	// Optional: A complex type that contains LambdaFunctionAssociation items for
+	// this cache behavior. If Quantity is 0, you can omit Items.
+	Items []*LambdaFunctionAssociation `locationNameList:"LambdaFunctionAssociation" type:"list"`
+
+	// The number of Lambda function associations for this cache behavior.
+	//
+	// Quantity is a required field
+	Quantity *int64 `type:"integer" required:"true"`
+}
+
+// String returns the string representation
+func (s LambdaFunctionAssociations) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s LambdaFunctionAssociations) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *LambdaFunctionAssociations) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "LambdaFunctionAssociations"}
+	if s.Quantity == nil {
+		invalidParams.Add(request.NewErrParamRequired("Quantity"))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetItems sets the Items field's value.
+func (s *LambdaFunctionAssociations) SetItems(v []*LambdaFunctionAssociation) *LambdaFunctionAssociations {
+	s.Items = v
+	return s
+}
+
+// SetQuantity sets the Quantity field's value.
+func (s *LambdaFunctionAssociations) SetQuantity(v int64) *LambdaFunctionAssociations {
+	s.Quantity = &v
+	return s
+}
+
 // The request to list origin access identities.
 type ListCloudFrontOriginAccessIdentitiesInput struct {
 	_ struct{} `type:"structure"`
@@ -9332,10 +9496,6 @@ func (s *UpdateStreamingDistributionOutput) SetStreamingDistribution(v *Streamin
 type ViewerCertificate struct {
 	_ struct{} `type:"structure"`
 
-	// If you want viewers to use HTTPS to request your objects and you're using
-	// an alternate domain name in your object URLs (for example, https://example.com/logo.jpg),
-	// specify the ACM certificate ARN of the custom viewer certificate for this
-	// distribution. Specify either this value, IAMCertificateId, or CloudFrontDefaultCertificate.
 	ACMCertificateArn *string `type:"string"`
 
 	// Include one of these values to specify the following:
@@ -9423,16 +9583,8 @@ type ViewerCertificate struct {
 	// IAMCertificateId, or CloudFrontDefaultCertificate].
 	CertificateSource *string `deprecated:"true" type:"string" enum:"CertificateSource"`
 
-	// If you want viewers to use HTTPS to request your objects and you're using
-	// the CloudFront domain name of your distribution in your object URLs (for
-	// example, https://d111111abcdef8.cloudfront.net/logo.jpg), set to true. Omit
-	// this value if you are setting an ACMCertificateArn or IAMCertificateId.
 	CloudFrontDefaultCertificate *bool `type:"boolean"`
 
-	// If you want viewers to use HTTPS to request your objects and you're using
-	// an alternate domain name in your object URLs (for example, https://example.com/logo.jpg),
-	// specify the IAM certificate identifier of the custom viewer certificate for
-	// this distribution. Specify either this value, ACMCertificateArn, or CloudFrontDefaultCertificate.
 	IAMCertificateId *string `type:"string"`
 
 	// Specify the minimum version of the SSL/TLS protocol that you want CloudFront
@@ -9544,6 +9696,20 @@ const (
 	CertificateSourceAcm = "acm"
 )
 
+const (
+	// EventTypeViewerRequest is a EventType enum value
+	EventTypeViewerRequest = "viewer-request"
+
+	// EventTypeViewerResponse is a EventType enum value
+	EventTypeViewerResponse = "viewer-response"
+
+	// EventTypeOriginRequest is a EventType enum value
+	EventTypeOriginRequest = "origin-request"
+
+	// EventTypeOriginResponse is a EventType enum value
+	EventTypeOriginResponse = "origin-response"
+)
+
 const (
 	// GeoRestrictionTypeBlacklist is a GeoRestrictionType enum value
 	GeoRestrictionTypeBlacklist = "blacklist"

vendor/github.com/aws/aws-sdk-go/service/cloudfront/service.go

@@ -42,19 +42,20 @@ const ServiceName = "cloudfront"
 //     svc := cloudfront.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *CloudFront {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *CloudFront {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *CloudFront {
 	svc := &CloudFront{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
-				APIVersion:    "2016-09-29",
+				APIVersion:    "2016-11-25",
 			},
 			handlers,
 		),

vendor/github.com/aws/aws-sdk-go/service/cloudtrail/service.go

@@ -59,16 +59,17 @@ const ServiceName = "cloudtrail"
 //     svc := cloudtrail.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *CloudTrail {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *CloudTrail {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *CloudTrail {
 	svc := &CloudTrail{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2013-11-01",

vendor/github.com/aws/aws-sdk-go/service/cloudwatch/service.go

@@ -53,16 +53,17 @@ const ServiceName = "monitoring"
 //     svc := cloudwatch.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *CloudWatch {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *CloudWatch {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *CloudWatch {
 	svc := &CloudWatch{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2010-08-01",

vendor/github.com/aws/aws-sdk-go/service/cloudwatchevents/service.go

@@ -54,16 +54,17 @@ const ServiceName = "events"
 //     svc := cloudwatchevents.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *CloudWatchEvents {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *CloudWatchEvents {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *CloudWatchEvents {
 	svc := &CloudWatchEvents{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2015-10-07",

vendor/github.com/aws/aws-sdk-go/service/cloudwatchlogs/service.go

@@ -68,16 +68,17 @@ const ServiceName = "logs"
 //     svc := cloudwatchlogs.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *CloudWatchLogs {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *CloudWatchLogs {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *CloudWatchLogs {
 	svc := &CloudWatchLogs{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2014-03-28",

vendor/github.com/aws/aws-sdk-go/service/codecommit/service.go

@@ -76,16 +76,17 @@ const ServiceName = "codecommit"
 //     svc := codecommit.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *CodeCommit {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *CodeCommit {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *CodeCommit {
 	svc := &CodeCommit{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2015-04-13",

vendor/github.com/aws/aws-sdk-go/service/codedeploy/service.go

@@ -91,16 +91,17 @@ const ServiceName = "codedeploy"
 //     svc := codedeploy.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *CodeDeploy {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *CodeDeploy {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *CodeDeploy {
 	svc := &CodeDeploy{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2014-10-06",

vendor/github.com/aws/aws-sdk-go/service/directoryservice/service.go

@@ -41,16 +41,17 @@ const ServiceName = "ds"
 //     svc := directoryservice.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *DirectoryService {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *DirectoryService {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *DirectoryService {
 	svc := &DirectoryService{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2015-04-16",

vendor/github.com/aws/aws-sdk-go/service/dynamodb/service.go

@@ -151,16 +151,17 @@ const ServiceName = "dynamodb"
 //     svc := dynamodb.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *DynamoDB {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *DynamoDB {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *DynamoDB {
 	svc := &DynamoDB{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2012-08-10",

vendor/github.com/aws/aws-sdk-go/service/ec2/api.go

@@ -51052,6 +51052,12 @@ const (
 	// InstanceTypeT2Large is a InstanceType enum value
 	InstanceTypeT2Large = "t2.large"
 
+	// InstanceTypeT2Xlarge is a InstanceType enum value
+	InstanceTypeT2Xlarge = "t2.xlarge"
+
+	// InstanceTypeT22xlarge is a InstanceType enum value
+	InstanceTypeT22xlarge = "t2.2xlarge"
+
 	// InstanceTypeM1Small is a InstanceType enum value
 	InstanceTypeM1Small = "m1.small"
 
@@ -51121,6 +51127,24 @@ const (
 	// InstanceTypeR38xlarge is a InstanceType enum value
 	InstanceTypeR38xlarge = "r3.8xlarge"
 
+	// InstanceTypeR4Large is a InstanceType enum value
+	InstanceTypeR4Large = "r4.large"
+
+	// InstanceTypeR4Xlarge is a InstanceType enum value
+	InstanceTypeR4Xlarge = "r4.xlarge"
+
+	// InstanceTypeR42xlarge is a InstanceType enum value
+	InstanceTypeR42xlarge = "r4.2xlarge"
+
+	// InstanceTypeR44xlarge is a InstanceType enum value
+	InstanceTypeR44xlarge = "r4.4xlarge"
+
+	// InstanceTypeR48xlarge is a InstanceType enum value
+	InstanceTypeR48xlarge = "r4.8xlarge"
+
+	// InstanceTypeR416xlarge is a InstanceType enum value
+	InstanceTypeR416xlarge = "r4.16xlarge"
+
 	// InstanceTypeX116xlarge is a InstanceType enum value
 	InstanceTypeX116xlarge = "x1.16xlarge"
 

vendor/github.com/aws/aws-sdk-go/service/ec2/customizations.go

@@ -5,8 +5,8 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awsutil"
+	"github.com/aws/aws-sdk-go/aws/endpoints"
 	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/private/endpoints"
 )
 
 func init() {
@@ -39,12 +39,20 @@ func fillPresignedURL(r *request.Request) {
 		WithRegion(aws.StringValue(origParams.SourceRegion)))
 
 	clientInfo := r.ClientInfo
-	clientInfo.Endpoint, clientInfo.SigningRegion = endpoints.EndpointForRegion(
+	resolved, err := r.Config.EndpointResolver.EndpointFor(
-		clientInfo.ServiceName,
+		clientInfo.ServiceName, aws.StringValue(cfg.Region),
-		aws.StringValue(cfg.Region),
+		func(opt *endpoints.Options) {
-		aws.BoolValue(cfg.DisableSSL),
+			opt.DisableSSL = aws.BoolValue(cfg.DisableSSL)
-		aws.BoolValue(cfg.UseDualStack),
+			opt.UseDualStack = aws.BoolValue(cfg.UseDualStack)
+		},
 	)
+	if err != nil {
+		r.Error = err
+		return
+	}
+
+	clientInfo.Endpoint = resolved.URL
+	clientInfo.SigningRegion = resolved.SigningRegion
 
 	// Presign a CopySnapshot request with modified params
 	req := request.New(*cfg, clientInfo, r.Handlers, r.Retryer, r.Operation, newParams, r.Data)

vendor/github.com/aws/aws-sdk-go/service/ec2/service.go

@@ -42,16 +42,17 @@ const ServiceName = "ec2"
 //     svc := ec2.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *EC2 {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *EC2 {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *EC2 {
 	svc := &EC2{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2016-11-15",

vendor/github.com/aws/aws-sdk-go/service/ecr/service.go

@@ -44,16 +44,17 @@ const ServiceName = "ecr"
 //     svc := ecr.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *ECR {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *ECR {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *ECR {
 	svc := &ECR{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2015-09-21",

vendor/github.com/aws/aws-sdk-go/service/ecs/service.go

@@ -50,16 +50,17 @@ const ServiceName = "ecs"
 //     svc := ecs.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *ECS {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *ECS {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *ECS {
 	svc := &ECS{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2014-11-13",

vendor/github.com/aws/aws-sdk-go/service/efs/service.go

@@ -43,16 +43,17 @@ const ServiceName = "elasticfilesystem"
 //     svc := efs.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *EFS {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *EFS {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *EFS {
 	svc := &EFS{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2015-02-01",

vendor/github.com/aws/aws-sdk-go/service/elasticache/service.go

@@ -49,16 +49,17 @@ const ServiceName = "elasticache"
 //     svc := elasticache.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *ElastiCache {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *ElastiCache {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *ElastiCache {
 	svc := &ElastiCache{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2015-02-02",

vendor/github.com/aws/aws-sdk-go/service/elasticbeanstalk/service.go

@@ -55,16 +55,17 @@ const ServiceName = "elasticbeanstalk"
 //     svc := elasticbeanstalk.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *ElasticBeanstalk {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *ElasticBeanstalk {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *ElasticBeanstalk {
 	svc := &ElasticBeanstalk{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2010-12-01",

vendor/github.com/aws/aws-sdk-go/service/elasticsearchservice/service.go

@@ -44,16 +44,17 @@ const ServiceName = "es"
 //     svc := elasticsearchservice.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *ElasticsearchService {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *ElasticsearchService {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *ElasticsearchService {
 	svc := &ElasticsearchService{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2015-01-01",

vendor/github.com/aws/aws-sdk-go/service/elastictranscoder/service.go

@@ -39,16 +39,17 @@ const ServiceName = "elastictranscoder"
 //     svc := elastictranscoder.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *ElasticTranscoder {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *ElasticTranscoder {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *ElasticTranscoder {
 	svc := &ElasticTranscoder{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2012-09-25",

vendor/github.com/aws/aws-sdk-go/service/elb/service.go

@@ -65,16 +65,17 @@ const ServiceName = "elasticloadbalancing"
 //     svc := elb.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *ELB {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *ELB {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *ELB {
 	svc := &ELB{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2012-06-01",

vendor/github.com/aws/aws-sdk-go/service/elbv2/service.go

@@ -84,16 +84,17 @@ const ServiceName = "elasticloadbalancing"
 //     svc := elbv2.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *ELBV2 {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *ELBV2 {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *ELBV2 {
 	svc := &ELBV2{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2015-12-01",

vendor/github.com/aws/aws-sdk-go/service/emr/service.go

@@ -42,16 +42,17 @@ const ServiceName = "elasticmapreduce"
 //     svc := emr.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *EMR {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *EMR {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *EMR {
 	svc := &EMR{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2009-03-31",

vendor/github.com/aws/aws-sdk-go/service/firehose/service.go

@@ -41,16 +41,17 @@ const ServiceName = "firehose"
 //     svc := firehose.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *Firehose {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *Firehose {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *Firehose {
 	svc := &Firehose{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2015-08-04",

vendor/github.com/aws/aws-sdk-go/service/glacier/service.go

@@ -69,16 +69,17 @@ const ServiceName = "glacier"
 //     svc := glacier.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *Glacier {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *Glacier {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *Glacier {
 	svc := &Glacier{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2012-06-01",

vendor/github.com/aws/aws-sdk-go/service/iam/service.go

@@ -91,16 +91,17 @@ const ServiceName = "iam"
 //     svc := iam.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *IAM {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *IAM {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *IAM {
 	svc := &IAM{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2010-05-08",

vendor/github.com/aws/aws-sdk-go/service/kinesis/service.go

@@ -40,16 +40,17 @@ const ServiceName = "kinesis"
 //     svc := kinesis.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *Kinesis {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *Kinesis {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *Kinesis {
 	svc := &Kinesis{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2013-12-02",

vendor/github.com/aws/aws-sdk-go/service/kms/service.go

@@ -109,16 +109,17 @@ const ServiceName = "kms"
 //     svc := kms.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *KMS {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *KMS {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *KMS {
 	svc := &KMS{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2014-11-01",

vendor/github.com/aws/aws-sdk-go/service/lambda/service.go

@@ -45,16 +45,17 @@ const ServiceName = "lambda"
 //     svc := lambda.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *Lambda {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *Lambda {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *Lambda {
 	svc := &Lambda{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2015-03-31",

vendor/github.com/aws/aws-sdk-go/service/lightsail/service.go

@@ -51,16 +51,17 @@ const ServiceName = "lightsail"
 //     svc := lightsail.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *Lightsail {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *Lightsail {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *Lightsail {
 	svc := &Lightsail{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2016-11-28",

vendor/github.com/aws/aws-sdk-go/service/opsworks/service.go

@@ -104,16 +104,17 @@ const ServiceName = "opsworks"
 //     svc := opsworks.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *OpsWorks {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *OpsWorks {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *OpsWorks {
 	svc := &OpsWorks{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2013-02-18",

vendor/github.com/aws/aws-sdk-go/service/rds/api.go

@@ -227,6 +227,9 @@ func (c *RDS) AddTagsToResourceRequest(input *AddTagsToResourceInput) (req *requ
 //   * DBSnapshotNotFound
 //   DBSnapshotIdentifier does not refer to an existing DB snapshot.
 //
+//   * DBClusterNotFoundFault
+//   DBClusterIdentifier does not refer to an existing DB cluster.
+//
 func (c *RDS) AddTagsToResource(input *AddTagsToResourceInput) (*AddTagsToResourceOutput, error) {
 	req, out := c.AddTagsToResourceRequest(input)
 	err := req.Send()
@@ -655,8 +658,10 @@ func (c *RDS) CopyDBSnapshotRequest(input *CopyDBSnapshotInput) (req *request.Re
 // Copies the specified DB snapshot. The source DB snapshot must be in the "available"
 // state.
 //
-// If you are copying from a shared manual DB snapshot, the SourceDBSnapshotIdentifier
+// To copy a DB snapshot from a shared manual DB snapshot, SourceDBSnapshotIdentifier
-// must be the ARN of the shared DB snapshot.
+// must be the Amazon Resource Name (ARN) of the shared DB snapshot.
+//
+// You can not copy an encrypted DB snapshot from another AWS region.
 //
 // 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
@@ -851,6 +856,9 @@ func (c *RDS) CreateDBClusterRequest(input *CreateDBClusterInput) (req *request.
 //   The requested subnet is invalid, or multiple subnets were requested that
 //   are not all in a common VPC.
 //
+//   * InvalidDBInstanceState
+//   The specified DB instance is not in the available state.
+//
 //   * DBClusterParameterGroupNotFound
 //   DBClusterParameterGroupName does not refer to an existing DB Cluster parameter
 //   group.
@@ -4982,13 +4990,12 @@ func (c *RDS) FailoverDBClusterRequest(input *FailoverDBClusterInput) (req *requ
 //
 // Forces a failover for a DB cluster.
 //
-// A failover for a DB cluster promotes one of the read-only instances in the
+// A failover for a DB cluster promotes one of the Aurora Replicas (read-only
-// DB cluster to the master DB instance (the cluster writer) and deletes the
+// instances) in the DB cluster to be the primary instance (the cluster writer).
-// current primary instance.
 //
-// Amazon Aurora will automatically fail over to a read-only instance, if one
+// Amazon Aurora will automatically fail over to an Aurora Replica, if one exists,
-// exists, when the primary instance fails. You can force a failover when you
+// when the primary instance fails. You can force a failover when you want to
-// want to simulate a failure of a DB instance for testing. Because each instance
+// simulate a failure of a primary instance for testing. Because each instance
 // in a DB cluster has its own endpoint address, you will need to clean up and
 // re-establish any existing connections that use those endpoint addresses when
 // the failover is complete.
@@ -5083,6 +5090,9 @@ func (c *RDS) ListTagsForResourceRequest(input *ListTagsForResourceInput) (req *
 //   * DBSnapshotNotFound
 //   DBSnapshotIdentifier does not refer to an existing DB snapshot.
 //
+//   * DBClusterNotFoundFault
+//   DBClusterIdentifier does not refer to an existing DB cluster.
+//
 func (c *RDS) ListTagsForResource(input *ListTagsForResourceInput) (*ListTagsForResourceOutput, error) {
 	req, out := c.ListTagsForResourceRequest(input)
 	err := req.Send()
@@ -6386,6 +6396,9 @@ func (c *RDS) RemoveTagsFromResourceRequest(input *RemoveTagsFromResourceInput)
 //   * DBSnapshotNotFound
 //   DBSnapshotIdentifier does not refer to an existing DB snapshot.
 //
+//   * DBClusterNotFoundFault
+//   DBClusterIdentifier does not refer to an existing DB cluster.
+//
 func (c *RDS) RemoveTagsFromResource(input *RemoveTagsFromResourceInput) (*RemoveTagsFromResourceOutput, error) {
 	req, out := c.RemoveTagsFromResourceRequest(input)
 	err := req.Send()
@@ -8256,9 +8269,9 @@ type CopyDBSnapshotInput struct {
 	// otherwise false. The default is false.
 	CopyTags *bool `type:"boolean"`
 
-	// The AWS Key Management Service (AWS KMS) key identifier for an encrypted
+	// The AWS KMS key ID for an encrypted DB snapshot. The KMS key ID is the Amazon
-	// DB snapshot. The KMS key identifier is the Amazon Resource Name (ARN) or
+	// Resource Name (ARN), KMS key identifier, or the KMS key alias for the KMS
-	// the KMS key alias for the KMS encryption key.
+	// encryption key.
 	//
 	// If you copy an unencrypted DB snapshot and specify a value for the KmsKeyId
 	// parameter, Amazon RDS encrypts the target DB snapshot using the specified
@@ -8266,8 +8279,8 @@ type CopyDBSnapshotInput struct {
 	//
 	// If you copy an encrypted DB snapshot from your AWS account, you can specify
 	// a value for KmsKeyId to encrypt the copy with a new KMS encryption key. If
-	// you don't specify a value for KmsKeyId then the copy of the DB snapshot is
+	// you don't specify a value for KmsKeyId, then the copy of the DB snapshot
-	// encrypted with the same KMS key as the source DB snapshot.
+	// is encrypted with the same KMS key as the source DB snapshot.
 	//
 	// If you copy an encrypted DB snapshot that is shared from another AWS account,
 	// then you must specify a value for KmsKeyId.
@@ -8278,6 +8291,8 @@ type CopyDBSnapshotInput struct {
 	// If you are copying from a shared manual DB snapshot, this must be the ARN
 	// of the shared DB snapshot.
 	//
+	// You cannot copy an encrypted, shared DB snapshot from one AWS region to another.
+	//
 	// Constraints:
 	//
 	//    * Must specify a valid system snapshot in the "available" state.
@@ -8291,7 +8306,7 @@ type CopyDBSnapshotInput struct {
 	//
 	// Example: rds:mydb-2012-04-02-00-01
 	//
-	// Example: arn:aws:rds:rr-regn-1:123456789012:snapshot:mysql-instance1-snapshot-20130805
+	// Example: arn:aws:rds:us-west-2:123456789012:snapshot:mysql-instance1-snapshot-20130805
 	//
 	// SourceDBSnapshotIdentifier is a required field
 	SourceDBSnapshotIdentifier *string `type:"string" required:"true"`
@@ -9325,21 +9340,69 @@ type CreateDBInstanceInput struct {
 	// Amazon Aurora
 	//
 	//    * Version 5.6 (available in these AWS regions: ap-northeast-1, ap-northeast-2,
-	//    ap-south-1, ap-southeast-2, eu-west-1, us-east-1, us-west-2): 5.6.10a
+	//    ap-south-1, ap-southeast-2, eu-west-1, us-east-1, us-east-2, us-west-2):
+	//    5.6.10a
 	//
 	// MariaDB
 	//
+	//    * Version 10.1 (available in these AWS regions: us-east-2): 10.1.16
+	//
 	//    * Version 10.1 (available in these AWS regions: ap-northeast-1, ap-northeast-2,
 	//    ap-south-1, ap-southeast-1, ap-southeast-2, eu-central-1, eu-west-1, sa-east-1,
 	//    us-east-1, us-west-1, us-west-2): 10.1.14
 	//
-	//    * Version 10.0 (available in all AWS regions): 10.0.17 | 10.0.24
+	//    * Version 10.0 (available in all AWS regions): 10.0.24
+	//
+	//    * Version 10.0 (available in these AWS regions: ap-northeast-1, ap-northeast-2,
+	//    ap-south-1, ap-southeast-1, ap-southeast-2, eu-central-1, eu-west-1, sa-east-1,
+	//    us-east-1, us-gov-west-1, us-west-1, us-west-2): 10.0.17
+	//
+	// Microsoft SQL Server 2016
+	//
+	//    * 13.00.2164.0.v1 (supported for all editions, and all AWS regions except
+	//    sa-east-1)
+	//
+	// Microsoft SQL Server 2014
+	//
+	//    * 12.00.5000.0.v1 (supported for all editions, and all AWS regions)
+	//
+	//    * 12.00.4422.0.v1 (supported for all editions except Enterprise Edition,
+	//    and all AWS regions except us-east-2)
+	//
+	// Microsoft SQL Server 2012
+	//
+	//    * 11.00.6020.0.v1 (supported for all editions, and all AWS regions)
+	//
+	//    * 11.00.5058.0.v1 (supported for all editions, and all AWS regions except
+	//    us-east-2)
+	//
+	//    * 11.00.2100.60.v1 (supported for all editions, and all AWS regions except
+	//    us-east-2)
+	//
+	// Microsoft SQL Server 2008 R2
+	//
+	//    * 10.50.6529.0.v1 (supported for all editions, and all AWS regions except
+	//    us-east-2)
+	//
+	//    * 10.50.6000.34.v1 (supported for all editions, and all AWS regions except
+	//    us-east-2)
+	//
+	//    * 10.50.2789.0.v1 (supported for all editions, and all AWS regions except
+	//    us-east-2)
 	//
 	// MySQL
 	//
-	//    * Version 5.7 (available in all AWS regions): 5.7.10 | 5.7.11
+	//    * Version 5.7 (available in all AWS regions): 5.7.11
 	//
-	//    * Version 5.6 (available in all AWS regions): 5.6.27 | 5.6.29
+	//    * Version 5.7 (available in these AWS regions: ap-northeast-1, ap-northeast-2,
+	//    ap-south-1, ap-southeast-1, ap-southeast-2, eu-central-1, eu-west-1, sa-east-1,
+	//    us-east-1, us-gov-west-1, us-west-1, us-west-2): 5.7.10
+	//
+	//    * Version 5.6 (available in all AWS regions): 5.6.29
+	//
+	//    * Version 5.6 (available in these AWS regions: ap-northeast-1, ap-northeast-2,
+	//    ap-south-1, ap-southeast-1, ap-southeast-2, eu-central-1, eu-west-1, sa-east-1,
+	//    us-east-1, us-gov-west-1, us-west-1, us-west-2): 5.6.27
 	//
 	//    * Version 5.6 (available in these AWS regions: ap-northeast-1, ap-northeast-2,
 	//    ap-southeast-1, ap-southeast-2, eu-central-1, eu-west-1, sa-east-1, us-east-1,
@@ -9363,150 +9426,98 @@ type CreateDBInstanceInput struct {
 	//    ap-southeast-2, eu-west-1, sa-east-1, us-east-1, us-gov-west-1, us-west-1,
 	//    us-west-2): 5.5.40 | 5.5.40a
 	//
-	// Oracle Database Enterprise Edition (oracle-ee)
+	// Oracle 12c
 	//
-	//    * Version 12.1.0.2 (available in these AWS regions: ap-northeast-1, ap-northeast-2,
+	// 12.1.0.2.v5 (supported for EE in all AWS regions, and SE2 in all AWS regions
-	//    ap-south-1, ap-southeast-1, ap-southeast-2, eu-central-1, eu-west-1, sa-east-1,
+	// except us-gov-west-1)
-	//    us-east-1, us-west-1, us-west-2): 12.1.0.2.v5
 	//
-	//    * Version 12.1.0.2 (available in all AWS regions): 12.1.0.2.v1 | 12.1.0.2.v2
+	//    * 12.1.0.2.v4 (supported for EE in all AWS regions, and SE2 in all AWS
-	//    | 12.1.0.2.v3 | 12.1.0.2.v4
+	//    regions except us-gov-west-1)
 	//
-	//    * Version 12.1.0.1 (available in these AWS regions: ap-northeast-1, ap-southeast-1,
+	//    * 12.1.0.2.v3 (supported for EE in all AWS regions, and SE2 in all AWS
-	//    ap-southeast-2, eu-central-1, eu-west-1, sa-east-1, us-east-1, us-west-1,
+	//    regions except us-gov-west-1)
-	//    us-west-2): 12.1.0.1.v6
 	//
-	//    * Version 12.1.0.1 (available in these AWS regions: ap-northeast-1, ap-southeast-1,
+	//    * 12.1.0.2.v2 (supported for EE in all AWS regions, and SE2 in all AWS
-	//    ap-southeast-2, eu-central-1, eu-west-1, sa-east-1, us-east-1, us-gov-west-1,
+	//    regions except us-gov-west-1)
-	//    us-west-1, us-west-2): 12.1.0.1.v3 | 12.1.0.1.v4 | 12.1.0.1.v5
 	//
-	//    * Version 12.1.0.1 (available in these AWS regions: ap-northeast-1, ap-southeast-1,
+	//    * 12.1.0.2.v1 (supported for EE in all AWS regions, and SE2 in all AWS
-	//    ap-southeast-2, eu-central-1, eu-west-1, sa-east-1, us-east-1, us-gov-west-1,
+	//    regions except us-gov-west-1)
-	//    us-gov-west-1, us-west-1, us-west-2): 12.1.0.1.v1 | 12.1.0.1.v2
 	//
-	//    * Version 11.2.0.4 (available in these AWS regions: ap-northeast-1, ap-northeast-2,
+	//    * 12.1.0.1.v6 (supported for EE, SE1, and SE, in all AWS regions except
-	//    ap-south-1, ap-southeast-1, ap-southeast-2, eu-central-1, eu-west-1, sa-east-1,
+	//    ap-south-1, ap-northeast-2)
-	//    us-east-1, us-west-1, us-west-2): 11.2.0.4.v6 | 11.2.0.4.v9
 	//
-	//    * Version 11.2.0.4 (available in all AWS regions): 11.2.0.4.v1 | 11.2.0.4.v3
+	//    * 12.1.0.1.v5 (supported for EE, SE1, and SE, in all AWS regions except
-	//    | 11.2.0.4.v4 | 11.2.0.4.v5 | 11.2.0.4.v7 | 11.2.0.4.v8
+	//    ap-south-1, ap-northeast-2)
 	//
-	// Oracle Database Standard Edition Two (oracle-se2)
+	//    * 12.1.0.1.v4 (supported for EE, SE1, and SE, in all AWS regions except
+	//    ap-south-1, ap-northeast-2)
 	//
-	//    * Version 12.1.0.2 (available in these AWS regions: ap-northeast-1, ap-northeast-2,
+	//    * 12.1.0.1.v3 (supported for EE, SE1, and SE, in all AWS regions except
-	//    ap-south-1, ap-southeast-1, ap-southeast-2, eu-central-1, eu-west-1, sa-east-1,
+	//    ap-south-1, ap-northeast-2)
-	//    us-east-1, us-west-1, us-west-2): 12.1.0.2.v5
 	//
-	//    * Version 12.1.0.2 (available in all AWS regions): 12.1.0.2.v2 | 12.1.0.2.v3
+	//    * 12.1.0.1.v2 (supported for EE, SE1, and SE, in all AWS regions except
-	//    | 12.1.0.2.v4
+	//    ap-south-1, ap-northeast-2)
 	//
-	// Oracle Database Standard Edition One (oracle-se1)
+	//    * 12.1.0.1.v1 (supported for EE, SE1, and SE, in all AWS regions except
+	//    ap-south-1, ap-northeast-2)
 	//
-	//    * Version 12.1.0.1 (available in these AWS regions: ap-northeast-1, ap-southeast-1,
+	// Oracle 11g
-	//    ap-southeast-2, eu-central-1, eu-west-1, sa-east-1, us-east-1, us-west-1,
-	//    us-west-2): 12.1.0.1.v6
 	//
-	//    * Version 12.1.0.1 (available in these AWS regions: ap-northeast-1, ap-southeast-1,
+	//    * 11.2.0.4.v9 (supported for EE, SE1, and SE, in all AWS regions)
-	//    ap-southeast-2, eu-central-1, eu-west-1, sa-east-1, us-east-1, us-gov-west-1,
-	//    us-west-1, us-west-2): 12.1.0.1.v3 | 12.1.0.1.v4 | 12.1.0.1.v5
 	//
-	//    * Version 12.1.0.1 (available in these AWS regions: ap-northeast-1, ap-southeast-1,
+	//    * 11.2.0.4.v8 (supported for EE, SE1, and SE, in all AWS regions)
-	//    ap-southeast-2, eu-central-1, eu-west-1, sa-east-1, us-east-1, us-gov-west-1,
-	//    us-gov-west-1, us-west-1, us-west-2): 12.1.0.1.v1 | 12.1.0.1.v2
 	//
-	//    * Version 11.2.0.4 (available in these AWS regions: ap-northeast-1, ap-northeast-2,
+	//    * 11.2.0.4.v7 (supported for EE, SE1, and SE, in all AWS regions)
-	//    ap-south-1, ap-southeast-1, ap-southeast-2, eu-central-1, eu-west-1, sa-east-1,
-	//    us-east-1, us-west-1, us-west-2): 11.2.0.4.v6 | 11.2.0.4.v9
 	//
-	//    * Version 11.2.0.4 (available in all AWS regions): 11.2.0.4.v1 | 11.2.0.4.v3
+	//    * 11.2.0.4.v6 (supported for EE, SE1, and SE, in all AWS regions)
-	//    | 11.2.0.4.v4 | 11.2.0.4.v5 | 11.2.0.4.v7 | 11.2.0.4.v8
 	//
-	// Oracle Database Standard Edition (oracle-se)
+	//    * 11.2.0.4.v5 (supported for EE, SE1, and SE, in all AWS regions)
 	//
-	//    * Version 12.1.0.1 (available in these AWS regions: ap-northeast-1, ap-southeast-1,
+	//    * 11.2.0.4.v4 (supported for EE, SE1, and SE, in all AWS regions)
-	//    ap-southeast-2, eu-central-1, eu-west-1, sa-east-1, us-east-1, us-west-1,
-	//    us-west-2): 12.1.0.1.v6
 	//
-	//    * Version 12.1.0.1 (available in these AWS regions: ap-northeast-1, ap-southeast-1,
+	//    * 11.2.0.4.v3 (supported for EE, SE1, and SE, in all AWS regions)
-	//    ap-southeast-2, eu-central-1, eu-west-1, sa-east-1, us-east-1, us-gov-west-1,
-	//    us-west-1, us-west-2): 12.1.0.1.v3 | 12.1.0.1.v4 | 12.1.0.1.v5
 	//
-	//    * Version 12.1.0.1 (available in these AWS regions: ap-northeast-1, ap-southeast-1,
+	//    * 11.2.0.4.v1 (supported for EE, SE1, and SE, in all AWS regions)
-	//    ap-southeast-2, eu-central-1, eu-west-1, sa-east-1, us-east-1, us-gov-west-1,
-	//    us-gov-west-1, us-west-1, us-west-2): 12.1.0.1.v1 | 12.1.0.1.v2
-	//
-	//    * Version 11.2.0.4 (available in these AWS regions: ap-northeast-1, ap-northeast-2,
-	//    ap-south-1, ap-southeast-1, ap-southeast-2, eu-central-1, eu-west-1, sa-east-1,
-	//    us-east-1, us-west-1, us-west-2): 11.2.0.4.v6 | 11.2.0.4.v9
-	//
-	//    * Version 11.2.0.4 (available in all AWS regions): 11.2.0.4.v1 | 11.2.0.4.v3
-	//    | 11.2.0.4.v4 | 11.2.0.4.v5 | 11.2.0.4.v7 | 11.2.0.4.v8
 	//
 	// PostgreSQL
 	//
 	//    * Version 9.5 (available in these AWS regions: ap-northeast-1, ap-northeast-2,
 	//    ap-south-1, ap-southeast-1, ap-southeast-2, eu-central-1, eu-west-1, sa-east-1,
-	//    us-east-1, us-west-1, us-west-2): 9.5.2 | 9.5.4
+	//    us-east-1, us-west-1, us-west-2):   *  9.5.4
+	//
+	//    * Version 9.5 (available in these AWS regions: ap-northeast-1, ap-northeast-2,
+	//    ap-south-1, ap-southeast-1, ap-southeast-2, eu-central-1, eu-west-1, sa-east-1,
+	//    us-east-1, us-east-2, us-west-1, us-west-2):   *  9.5.2
 	//
 	//    * Version 9.4 (available in these AWS regions: ap-northeast-1, ap-northeast-2,
 	//    ap-south-1, ap-southeast-1, ap-southeast-2, eu-central-1, eu-west-1, sa-east-1,
-	//    us-east-1, us-west-1, us-west-2): 9.4.7 | 9.4.9
+	//    us-east-1, us-west-1, us-west-2):   *  9.4.9
 	//
-	//    * Version 9.4 (available in all AWS regions): 9.4.5
+	//    * Version 9.4 (available in these AWS regions: ap-northeast-1, ap-northeast-2,
+	//    ap-south-1, ap-southeast-1, ap-southeast-2, eu-central-1, eu-west-1, sa-east-1,
+	//    us-east-1, us-east-2, us-west-1, us-west-2):   *  9.4.7
+	//
+	//    * Version 9.4 (available in all AWS regions):   *  9.4.5
 	//
 	//    * Version 9.4 (available in these AWS regions: ap-northeast-1, ap-northeast-2,
 	//    ap-southeast-1, ap-southeast-2, eu-central-1, eu-west-1, sa-east-1, us-east-1,
-	//    us-gov-west-1, us-west-1, us-west-2): 9.4.1 | 9.4.4
+	//    us-gov-west-1, us-west-1, us-west-2):   *  9.4.4
+	//
+	//    * Version 9.4 (available in these AWS regions: ap-northeast-1, ap-northeast-2,
+	//    ap-southeast-1, ap-southeast-2, eu-central-1, eu-west-1, sa-east-1, us-east-1,
+	//    us-east-2, us-gov-west-1, us-west-1, us-west-2):   *  9.4.1
 	//
 	//    * Version 9.3 (available in these AWS regions: ap-northeast-1, ap-southeast-1,
 	//    ap-southeast-2, eu-central-1, eu-west-1, sa-east-1, us-east-1, us-gov-west-1,
-	//    us-west-1, us-west-2): 9.3.10 | 9.3.3 | 9.3.5 | 9.3.6 | 9.3.9
+	//    us-west-1, us-west-2):   *  9.3.10 | 9.3.3 | 9.3.5 | 9.3.6 | 9.3.9
 	//
 	//    * Version 9.3 (available in these AWS regions: ap-northeast-1, ap-southeast-1,
 	//    ap-southeast-2, eu-west-1, sa-east-1, us-east-1, us-gov-west-1, us-west-1,
-	//    us-west-2): 9.3.1 | 9.3.2
+	//    us-west-2):   *  9.3.1 | 9.3.2
 	//
 	//    * Version 9.3 (available in these AWS regions: ap-northeast-1, ap-southeast-1,
 	//    ap-southeast-2, eu-central-1, eu-west-1, sa-east-1, us-east-1, us-west-1,
-	//    us-west-2): 9.3.12 | 9.3.14
+	//    us-west-2):   *  9.3.12 | 9.3.14
-	//
-	// Microsoft SQL Server Enterprise Edition (sqlserver-ee)
-	//
-	//    * Version 11.00 (available in all AWS regions): 11.00.2100.60.v1 | 11.00.5058.0.v1
-	//    | 11.00.6020.0.v1
-	//
-	//    * Version 10.50 (available in all AWS regions): 10.50.2789.0.v1 | 10.50.6000.34.v1
-	//    | 10.50.6529.0.v1
-	//
-	// Microsoft SQL Server Express Edition (sqlserver-ex)
-	//
-	//    * Version 12.00 (available in all AWS regions): 12.00.4422.0.v1
-	//
-	//    * Version 11.00 (available in all AWS regions): 11.00.2100.60.v1 | 11.00.5058.0.v1
-	//    | 11.00.6020.0.v1
-	//
-	//    * Version 10.50 (available in all AWS regions): 10.50.2789.0.v1 | 10.50.6000.34.v1
-	//    | 10.50.6529.0.v1
-	//
-	// Microsoft SQL Server Standard Edition (sqlserver-se)
-	//
-	//    * Version 12.00 (available in all AWS regions): 12.00.4422.0.v1
-	//
-	//    * Version 11.00 (available in all AWS regions): 11.00.2100.60.v1 | 11.00.5058.0.v1
-	//    | 11.00.6020.0.v1
-	//
-	//    * Version 10.50 (available in all AWS regions): 10.50.2789.0.v1 | 10.50.6000.34.v1
-	//    | 10.50.6529.0.v1
-	//
-	// Microsoft SQL Server Web Edition (sqlserver-web)
-	//
-	//    * Version 12.00 (available in all AWS regions): 12.00.4422.0.v1
-	//
-	//    * Version 11.00 (available in all AWS regions): 11.00.2100.60.v1 | 11.00.5058.0.v1
-	//    | 11.00.6020.0.v1
-	//
-	//    * Version 10.50 (available in all AWS regions): 10.50.2789.0.v1 | 10.50.6000.34.v1
-	//    | 10.50.6529.0.v1
 	EngineVersion *string `type:"string"`
 
 	// The amount of Provisioned IOPS (input/output operations per second) to be
@@ -11149,6 +11160,10 @@ type DBCluster struct {
 	// associated with.
 	CharacterSetName *string `type:"string"`
 
+	// Specifies the time when the DB cluster was created, in Universal Coordinated
+	// Time (UTC).
+	ClusterCreateTime *time.Time `type:"timestamp" timestampFormat:"iso8601"`
+
 	// The Amazon Resource Name (ARN) for the DB cluster.
 	DBClusterArn *string `type:"string"`
 
@@ -11206,6 +11221,9 @@ type DBCluster struct {
 	// Contains the master username for the DB cluster.
 	MasterUsername *string `type:"string"`
 
+	// Specifies whether the DB cluster has instances in multiple Availability Zones.
+	MultiAZ *bool `type:"boolean"`
+
 	// Specifies the progress of the operation as a percentage.
 	PercentProgress *string `type:"string"`
 
@@ -11291,6 +11309,12 @@ func (s *DBCluster) SetCharacterSetName(v string) *DBCluster {
 	return s
 }
 
+// SetClusterCreateTime sets the ClusterCreateTime field's value.
+func (s *DBCluster) SetClusterCreateTime(v time.Time) *DBCluster {
+	s.ClusterCreateTime = &v
+	return s
+}
+
 // SetDBClusterArn sets the DBClusterArn field's value.
 func (s *DBCluster) SetDBClusterArn(v string) *DBCluster {
 	s.DBClusterArn = &v
@@ -11387,6 +11411,12 @@ func (s *DBCluster) SetMasterUsername(v string) *DBCluster {
 	return s
 }
 
+// SetMultiAZ sets the MultiAZ field's value.
+func (s *DBCluster) SetMultiAZ(v bool) *DBCluster {
+	s.MultiAZ = &v
+	return s
+}
+
 // SetPercentProgress sets the PercentProgress field's value.
 func (s *DBCluster) SetPercentProgress(v string) *DBCluster {
 	s.PercentProgress = &v
@@ -14736,7 +14766,13 @@ type DescribeDBClustersInput struct {
 	//    * Cannot end with a hyphen or contain two consecutive hyphens
 	DBClusterIdentifier *string `type:"string"`
 
-	// This parameter is not currently supported.
+	// A filter that specifies one or more DB clusters to describe.
+	//
+	// Supported filters:
+	//
+	//    * db-cluster-id - Accepts DB cluster identifiers and DB cluster Amazon
+	//    Resource Names (ARNs). The results list will only include information
+	//    about the DB clusters identified by these ARNs.
 	Filters []*Filter `locationNameList:"Filter" type:"list"`
 
 	// An optional pagination token provided by a previous DescribeDBClusters request.
@@ -15031,7 +15067,13 @@ type DescribeDBInstancesInput struct {
 	//    * Cannot end with a hyphen or contain two consecutive hyphens
 	DBInstanceIdentifier *string `type:"string"`
 
-	// This parameter is not currently supported.
+	// A filter that specifies one or more DB instances to describe.
+	//
+	// Supported filters:
+	//
+	//    * db-instance-id - Accepts DB instance identifiers and DB instance Amazon
+	//    Resource Names (ARNs). The results list will only include information
+	//    about the DB instances identified by these ARNs.
 	Filters []*Filter `locationNameList:"Filter" type:"list"`
 
 	// An optional pagination token provided by a previous DescribeDBInstances request.
@@ -17117,9 +17159,13 @@ type DescribePendingMaintenanceActionsInput struct {
 	//
 	// Supported filters:
 	//
-	//    * db-instance-id - Accepts DB instance identifiers and DB instance Amazon
+	//    * db-cluster-id - Accepts DB cluster identifiers and DB cluster Amazon
 	//    Resource Names (ARNs). The results list will only include pending maintenance
-	//    actions for the DB instances identified by these ARNs.
+	//    actions for the DB clusters identified by these ARNs.
+	//
+	//    * db-instance-id - Accepts DB instance identifiers and DB instance ARNs.
+	//    The results list will only include pending maintenance actions for the
+	//    DB instances identified by these ARNs.
 	Filters []*Filter `locationNameList:"Filter" type:"list"`
 
 	// An optional pagination token provided by a previous DescribePendingMaintenanceActions

vendor/github.com/aws/aws-sdk-go/service/rds/service.go

@@ -81,16 +81,17 @@ const ServiceName = "rds"
 //     svc := rds.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *RDS {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *RDS {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *RDS {
 	svc := &RDS{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2014-10-31",

vendor/github.com/aws/aws-sdk-go/service/redshift/service.go

@@ -62,16 +62,17 @@ const ServiceName = "redshift"
 //     svc := redshift.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *Redshift {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *Redshift {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *Redshift {
 	svc := &Redshift{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2012-12-01",

vendor/github.com/aws/aws-sdk-go/service/route53/service.go

@@ -39,16 +39,17 @@ const ServiceName = "route53"
 //     svc := route53.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *Route53 {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *Route53 {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *Route53 {
 	svc := &Route53{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2013-04-01",

vendor/github.com/aws/aws-sdk-go/service/s3/api.go

@@ -9740,8 +9740,7 @@ type GetObjectTaggingInput struct {
 	// Key is a required field
 	Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`
 
-	// VersionId is a required field
+	VersionId *string `location:"querystring" locationName:"versionId" type:"string"`
-	VersionId *string `location:"uri" locationName:"VersionId" type:"string" required:"true"`
 }
 
 // String returns the string representation
@@ -9766,9 +9765,6 @@ func (s *GetObjectTaggingInput) Validate() error {
 	if s.Key != nil && len(*s.Key) < 1 {
 		invalidParams.Add(request.NewErrParamMinLen("Key", 1))
 	}
-	if s.VersionId == nil {
-		invalidParams.Add(request.NewErrParamRequired("VersionId"))
-	}
 
 	if invalidParams.Len() > 0 {
 		return invalidParams
@@ -15453,8 +15449,7 @@ type PutObjectTaggingInput struct {
 	// Tagging is a required field
 	Tagging *Tagging `locationName:"Tagging" type:"structure" required:"true"`
 
-	// VersionId is a required field
+	VersionId *string `location:"querystring" locationName:"versionId" type:"string"`
-	VersionId *string `location:"uri" locationName:"VersionId" type:"string" required:"true"`
 }
 
 // String returns the string representation
@@ -15482,9 +15477,6 @@ func (s *PutObjectTaggingInput) Validate() error {
 	if s.Tagging == nil {
 		invalidParams.Add(request.NewErrParamRequired("Tagging"))
 	}
-	if s.VersionId == nil {
-		invalidParams.Add(request.NewErrParamRequired("VersionId"))
-	}
 	if s.Tagging != nil {
 		if err := s.Tagging.Validate(); err != nil {
 			invalidParams.AddNested("Tagging", err.(request.ErrInvalidParams))

vendor/github.com/aws/aws-sdk-go/service/s3/host_style_bucket.go

@@ -1,7 +1,6 @@
 package s3
 
 import (
-	"bytes"
 	"fmt"
 	"net/url"
 	"regexp"
@@ -88,23 +87,25 @@ func updateEndpointForAccelerate(r *request.Request) {
 		return
 	}
 
-	// Change endpoint from s3(-[a-z0-1-])?.amazonaws.com to s3-accelerate.amazonaws.com
+	parts := strings.Split(r.HTTPRequest.URL.Host, ".")
-	r.HTTPRequest.URL.Host = replaceHostRegion(r.HTTPRequest.URL.Host, "accelerate")
+	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 aws.BoolValue(r.Config.UseDualStack) {
+	if parts[0] == "s3" || strings.HasPrefix(parts[0], "s3-") {
-		host := []byte(r.HTTPRequest.URL.Host)
+		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
+		}
+	}
 
-		// Strip region from hostname
+	r.HTTPRequest.URL.Host = strings.Join(parts, ".")
-		if idx := bytes.Index(host, accelElem); idx >= 0 {
-			start := idx + len(accelElem)
-			if end := bytes.IndexByte(host[start:], '.'); end >= 0 {
-				end += start + 1
-				copy(host[start:], host[end:])
-				host = host[:len(host)-(end-start)]
-				r.HTTPRequest.URL.Host = string(host)
-			}
-		}
-	}
 
 	moveBucketToHost(r.HTTPRequest.URL, bucket)
 }
@@ -159,28 +160,3 @@ func moveBucketToHost(u *url.URL, bucket string) {
 		u.Path = "/"
 	}
 }
-
-const s3HostPrefix = "s3"
-
-// replaceHostRegion replaces the S3 region string in the host with the
-// value provided. If v is empty the host prefix returned will be s3.
-func replaceHostRegion(host, v string) string {
-	if !strings.HasPrefix(host, s3HostPrefix) {
-		return host
-	}
-
-	suffix := host[len(s3HostPrefix):]
-	for i := len(s3HostPrefix); i < len(host); i++ {
-		if host[i] == '.' {
-			// Trim until '.' leave the it in place.
-			suffix = host[i:]
-			break
-		}
-	}
-
-	if len(v) == 0 {
-		return fmt.Sprintf("s3%s", suffix)
-	}
-
-	return fmt.Sprintf("s3-%s%s", v, suffix)
-}

vendor/github.com/aws/aws-sdk-go/service/s3/service.go

@@ -39,16 +39,17 @@ const ServiceName = "s3"
 //     svc := s3.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *S3 {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *S3 {
+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",

vendor/github.com/aws/aws-sdk-go/service/ses/service.go

@@ -45,17 +45,20 @@ const ServiceName = "email"
 //     svc := ses.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *SES {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *SES {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *SES {
+	if len(signingName) == 0 {
+		signingName = "ses"
+	}
 	svc := &SES{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
-				SigningName:   "ses",
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2010-12-01",

vendor/github.com/aws/aws-sdk-go/service/simpledb/service.go

@@ -54,16 +54,17 @@ const ServiceName = "sdb"
 //     svc := simpledb.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *SimpleDB {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *SimpleDB {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *SimpleDB {
 	svc := &SimpleDB{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2009-04-15",

vendor/github.com/aws/aws-sdk-go/service/sns/service.go

@@ -51,16 +51,17 @@ const ServiceName = "sns"
 //     svc := sns.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *SNS {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *SNS {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *SNS {
 	svc := &SNS{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2010-03-31",

vendor/github.com/aws/aws-sdk-go/service/sqs/api.go

@@ -151,7 +151,7 @@ func (c *SQS) ChangeMessageVisibilityRequest(input *ChangeMessageVisibilityInput
 // value. The maximum allowed timeout value you can set the value to is 12 hours.
 // This means you can't extend the timeout of a message in an existing queue
 // to more than a total visibility timeout of 12 hours. (For more information
-// visibility timeout, see Visibility Timeout (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AboutVT.html)
+// visibility timeout, see Visibility Timeout (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html)
 // in the Amazon SQS Developer Guide.)
 //
 // For example, let's say you have a message and its default message visibility
@@ -162,13 +162,17 @@ func (c *SQS) ChangeMessageVisibilityRequest(input *ChangeMessageVisibilityInput
 // to call ChangeMessageVisibility to extend the visibility timeout to a maximum
 // of 12 hours. If you try to extend beyond 12 hours, the request will be rejected.
 //
-// There is a 120,000 limit for the number of inflight messages per queue. Messages
+// A message is considered to be in flight after it's received from a queue
-// are inflight after they have been received from the queue by a consuming
+// by a consumer, but not yet deleted from the queue.
-// component, but have not yet been deleted from the queue. If you reach the
+//
-// 120,000 limit, you will receive an OverLimit error message from Amazon SQS.
+// For standard queues, there can be a maximum of 120,000 inflight messages
-// To help avoid reaching the limit, you should delete the messages from the
+// per queue. If you reach this limit, Amazon SQS returns the OverLimit error
-// queue after they have been processed. You can also increase the number of
+// message. To avoid reaching the limit, you should delete messages from the
-// queues you use to process the messages.
+// queue after they're processed. You can also increase the number of queues
+// you use to process your messages.
+//
+// For FIFO queues, there can be a maximum of 20,000 inflight messages per queue.
+// If you reach this limit, Amazon SQS returns no error messages.
 //
 // If you attempt to set the VisibilityTimeout to an amount more than the maximum
 // time left, Amazon SQS returns an error. It will not automatically recalculate
@@ -344,7 +348,7 @@ func (c *SQS) CreateQueueRequest(input *CreateQueueInput) (req *request.Request,
 //    an existing standard queue into a FIFO queue. You must either create a
 //    new FIFO queue for your application or delete your existing standard queue
 //    and recreate it as a FIFO queue. For more information, see  Moving From
-//    a Standard Queue to a FIFO Queue (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues-moving.html)
+//    a Standard Queue to a FIFO Queue (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html#FIFO-queues-moving)
 //    in the Amazon SQS Developer Guide.
 //
 //    * If you don't provide a value for an attribute, the queue is created
@@ -633,7 +637,7 @@ func (c *SQS) DeleteQueueRequest(input *DeleteQueueInput) (req *request.Request,
 // you must wait at least 60 seconds before creating a queue with the same name.
 //
 // We reserve the right to delete queues that have had no activity for more
-// than 30 days. For more information, see How Amazon SQS Queues Work (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSConcepts.html)
+// than 30 days. For more information, see How Amazon SQS Queues Work (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html)
 // in the Amazon SQS Developer Guide.
 //
 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
@@ -840,7 +844,7 @@ func (c *SQS) ListDeadLetterSourceQueuesRequest(input *ListDeadLetterSourceQueue
 // configured with a dead letter queue.
 //
 // For more information about using dead letter queues, see Using Amazon SQS
-// Dead Letter Queues (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSDeadLetterQueue.html)
+// Dead Letter Queues (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html)
 // in the Amazon SQS Developer Guide.
 //
 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
@@ -1048,7 +1052,7 @@ func (c *SQS) ReceiveMessageRequest(input *ReceiveMessageInput) (req *request.Re
 //
 // Retrieves one or more messages, with a maximum limit of 10 messages, from
 // the specified queue. Long poll support is enabled by using the WaitTimeSeconds
-// parameter. For more information, see Amazon SQS Long Poll (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html)
+// parameter. For more information, see Amazon SQS Long Polling (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html)
 // in the Amazon SQS Developer Guide.
 //
 // Short poll is the default behavior where a weighted random set of machines
@@ -1075,14 +1079,14 @@ func (c *SQS) ReceiveMessageRequest(input *ReceiveMessageInput) (req *request.Re
 //    * MD5 digest of the message attributes.
 //
 // The receipt handle is the identifier you must provide when deleting the message.
-// For more information, see Queue and Message Identifiers (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/ImportantIdentifiers.html)
+// For more information, see Queue and Message Identifiers (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-queue-message-identifiers.html)
 // in the Amazon SQS Developer Guide.
 //
 // You can provide the VisibilityTimeout parameter in your request, which will
 // be applied to the messages that Amazon SQS returns in the response. If you
 // don't include the parameter, the overall visibility timeout for the queue
 // is used for the returned messages. For more information, see Visibility Timeout
-// (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AboutVT.html)
+// (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html)
 // in the Amazon SQS Developer Guide.
 //
 // A message that is not deleted or a message whose visibility is not extended
@@ -1922,7 +1926,7 @@ type CreateQueueInput struct {
 	//
 	//    * RedrivePolicy - The parameters for the dead letter queue functionality
 	//    of the source queue. For more information about the redrive policy and
-	//    dead letter queues, see Using Amazon SQS Dead Letter Queues (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSDeadLetterQueue.html)
+	//    dead letter queues, see Using Amazon SQS Dead Letter Queues (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html)
 	//    in the Amazon SQS Developer Guide.
 	//
 	// The dead letter queue of a FIFO queue must also be a FIFO queue. Similarly,
@@ -1930,7 +1934,7 @@ type CreateQueueInput struct {
 	//
 	//    * VisibilityTimeout - The visibility timeout for the queue. An integer
 	//    from 0 to 43200 (12 hours). The default is 30. For more information about
-	//    the visibility timeout, see Visibility Timeout (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AboutVT.html)
+	//    the visibility timeout, see Visibility Timeout (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html)
 	//    in the Amazon SQS Developer Guide.
 	//
 	// The following attributes apply only to FIFO (first-in-first-out) queues (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html):
@@ -2373,7 +2377,7 @@ type GetQueueAttributesInput struct {
 	//
 	//    * ApproximateNumberOfMessages - Returns the approximate number of visible
 	//    messages in a queue. For more information, see Resources Required to Process
-	//    Messages (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/ApproximateNumber.html)
+	//    Messages (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-resources-required-process-messages.html)
 	//    in the Amazon SQS Developer Guide.
 	//
 	//    * ApproximateNumberOfMessagesDelayed - Returns the approximate number
@@ -2381,7 +2385,7 @@ type GetQueueAttributesInput struct {
 	//
 	//    * ApproximateNumberOfMessagesNotVisible - Returns the approximate number
 	//    of messages that have not timed-out and are not deleted. For more information,
-	//    see Resources Required to Process Messages (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/ApproximateNumber.html)
+	//    see Resources Required to Process Messages (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-resources-required-process-messages.html)
 	//    in the Amazon SQS Developer Guide.
 	//
 	//    * CreatedTimestamp - Returns the time when the queue was created in seconds
@@ -2407,12 +2411,12 @@ type GetQueueAttributesInput struct {
 	//
 	//    * RedrivePolicy - Returns the parameters for dead letter queue functionality
 	//    of the source queue. For more information about the redrive policy and
-	//    dead letter queues, see Using Amazon SQS Dead Letter Queues (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSDeadLetterQueue.html)
+	//    dead letter queues, see Using Amazon SQS Dead Letter Queues (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html)
 	//    in the Amazon SQS Developer Guide.
 	//
 	//    * VisibilityTimeout - Returns the visibility timeout for the queue. For
 	//    more information about the visibility timeout, see Visibility Timeout
-	//    (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AboutVT.html)
+	//    (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html)
 	//    in the Amazon SQS Developer Guide.
 	//
 	// The following attributes apply only to FIFO (first-in-first-out) queues (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html):
@@ -2709,7 +2713,7 @@ type Message struct {
 	MD5OfMessageAttributes *string `type:"string"`
 
 	// Each message attribute consists of a Name, Type, and Value. For more information,
-	// see Message Attribute Items (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSMessageAttributes.html#SQSMessageAttributesNTV)
+	// see Message Attribute Items and Validation (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-attributes.html#message-attributes-items-validation)
 	// in the Amazon SQS Developer Guide.
 	MessageAttributes map[string]*MessageAttributeValue `locationName:"MessageAttribute" locationNameKey:"Name" locationNameValue:"Value" type:"map" flattened:"true"`
 
@@ -2799,7 +2803,7 @@ type MessageAttributeValue struct {
 	// Binary. For the Number data type, you must use StringValue.
 	//
 	// You can also append custom labels. For more information, see Message Attribute
-	// Data Types (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSMessageAttributes.html#SQSMessageAttributes.DataTypes)
+	// Data Types and Validation (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-attributes.html#message-attributes-data-types-validation)
 	// in the Amazon SQS Developer Guide.
 	//
 	// DataType is a required field
@@ -3040,7 +3044,7 @@ type ReceiveMessageInput struct {
 	//    * During a visibility timeout, subsequent calls with the same ReceiveRequestAttemptId
 	//    return the same messages and receipt handles. If a retry occurs within
 	//    the deduplication interval, it resets the visibility timeout. For more
-	//    information, see Visibility Timeout (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AboutVT.html)
+	//    information, see Visibility Timeout (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html)
 	//    in the Amazon Simple Queue Service Developer Guide.
 	//
 	// If a caller of the ReceiveMessage action is still processing messages when
@@ -3365,7 +3369,7 @@ type SendMessageBatchRequestEntry struct {
 	Id *string `type:"string" required:"true"`
 
 	// Each message attribute consists of a Name, Type, and Value. For more information,
-	// see Message Attribute Items (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSMessageAttributes.html#SQSMessageAttributesNTV)
+	// see Message Attribute Items and Validation (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-attributes.html#message-attributes-items-validation)
 	// in the Amazon SQS Developer Guide.
 	MessageAttributes map[string]*MessageAttributeValue `locationName:"MessageAttribute" locationNameKey:"Name" locationNameValue:"Value" type:"map" flattened:"true"`
 
@@ -3613,7 +3617,7 @@ type SendMessageInput struct {
 	DelaySeconds *int64 `type:"integer"`
 
 	// Each message attribute consists of a Name, Type, and Value. For more information,
-	// see Message Attribute Items (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSMessageAttributes.html#SQSMessageAttributesNTV)
+	// see Message Attribute Items and Validation (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-attributes.html#message-attributes-items-validation)
 	// in the Amazon SQS Developer Guide.
 	MessageAttributes map[string]*MessageAttributeValue `locationName:"MessageAttribute" locationNameKey:"Name" locationNameValue:"Value" type:"map" flattened:"true"`
 
@@ -3796,7 +3800,7 @@ type SendMessageOutput struct {
 	MD5OfMessageBody *string `type:"string"`
 
 	// An element containing the message ID of the message sent to the queue. For
-	// more information, see Queue and Message Identifiers (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/ImportantIdentifiers.html)
+	// more information, see Queue and Message Identifiers (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-queue-message-identifiers.html)
 	// in the Amazon SQS Developer Guide.
 	MessageId *string `type:"string"`
 
@@ -3873,7 +3877,7 @@ type SetQueueAttributesInput struct {
 	//
 	//    * RedrivePolicy - The parameters for the dead letter queue functionality
 	//    of the source queue. For more information about the redrive policy and
-	//    dead letter queues, see Using Amazon SQS Dead Letter Queues (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSDeadLetterQueue.html)
+	//    dead letter queues, see Using Amazon SQS Dead Letter Queues (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html)
 	//    in the Amazon SQS Developer Guide.
 	//
 	// The dead letter queue of a FIFO queue must also be a FIFO queue. Similarly,
@@ -3881,7 +3885,7 @@ type SetQueueAttributesInput struct {
 	//
 	//    * VisibilityTimeout - The visibility timeout for the queue. An integer
 	//    from 0 to 43200 (12 hours). The default is 30. For more information about
-	//    the visibility timeout, see Visibility Timeout (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AboutVT.html)
+	//    the visibility timeout, see Visibility Timeout (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html)
 	//    in the Amazon SQS Developer Guide.
 	//
 	// The following attribute applies only to FIFO (first-in-first-out) queues

vendor/github.com/aws/aws-sdk-go/service/sqs/service.go

@@ -20,25 +20,15 @@ import (
 // between distributed components of your applications that perform different
 // tasks without losing messages or requiring each component to be always available.
 //
-// Topics
-//
-//    *
-//
-//    *
-//
-//    * CommonParameters
-//
-//    * CommonErrors
-//
 // Helpful Links
 //
 //    * Making API Requests (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/MakingRequestsArticle.html)
 //
 //    * Amazon SQS product page (http://aws.amazon.com/sqs/)
 //
-//    * Using Amazon SQS Message Attributes (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSMessageAttributes.html)
+//    * Using Amazon SQS Message Attributes (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-attributes.html)
 //
-//    * Using Amazon SQS Dead Letter Queues (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSDeadLetterQueue.html)
+//    * Using Amazon SQS Dead Letter Queues (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html)
 //
 //    * Regions and Endpoints (http://docs.aws.amazon.com/general/latest/gr/rande.html#sqs_region)
 //
@@ -80,16 +70,17 @@ const ServiceName = "sqs"
 //     svc := sqs.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *SQS {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *SQS {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *SQS {
 	svc := &SQS{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2012-11-05",

vendor/github.com/aws/aws-sdk-go/service/ssm/service.go

@@ -53,16 +53,17 @@ const ServiceName = "ssm"
 //     svc := ssm.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *SSM {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *SSM {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *SSM {
 	svc := &SSM{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2014-11-06",

vendor/github.com/aws/aws-sdk-go/service/sts/api.go

@@ -447,7 +447,7 @@ func (c *STS) AssumeRoleWithWebIdentityRequest(input *AssumeRoleWithWebIdentityI
 // 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)
+//    * 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).
 //
 //
@@ -761,7 +761,7 @@ func (c *STS) GetFederationTokenRequest(input *GetFederationTokenInput) (req *re
 //
 //    * You cannot use these credentials to call any IAM APIs.
 //
-//    * You cannot call any STS APIs.
+//    * You cannot call any STS APIs except GetCallerIdentity.
 //
 // Permissions
 //
@@ -904,7 +904,7 @@ func (c *STS) GetSessionTokenRequest(input *GetSessionTokenInput) (req *request.
 //    * You cannot call any IAM APIs unless MFA authentication information is
 //    included in the request.
 //
-//    * You cannot call any STS API exceptAssumeRole.
+//    * 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)

vendor/github.com/aws/aws-sdk-go/service/sts/service.go

@@ -83,16 +83,17 @@ const ServiceName = "sts"
 //     svc := sts.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *STS {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *STS {
+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",

vendor/github.com/aws/aws-sdk-go/service/waf/api.go

@@ -121,6 +121,9 @@ func (c *WAF) CreateByteMatchSetRequest(input *CreateByteMatchSetInput) (req *re
 //      * You tried to update a ByteMatchSet with a Field of HEADER but no value
 //      for Data.
 //
+//      * Your request references an ARN that is malformed, or corresponds to
+//      a resource with which a web ACL cannot be associated.
+//
 //   * StaleDataException
 //   The operation failed because you tried to create, update, or delete an object
 //   by using a change token that has already been used.
@@ -251,6 +254,9 @@ func (c *WAF) CreateIPSetRequest(input *CreateIPSetInput) (req *request.Request,
 //      * You tried to update a ByteMatchSet with a Field of HEADER but no value
 //      for Data.
 //
+//      * Your request references an ARN that is malformed, or corresponds to
+//      a resource with which a web ACL cannot be associated.
+//
 //   * LimitsExceededException
 //   The operation exceeds a resource limit, for example, the maximum number of
 //   WebACL objects that you can create for an AWS account. For more information,
@@ -387,6 +393,9 @@ func (c *WAF) CreateRuleRequest(input *CreateRuleInput) (req *request.Request, o
 //      * You tried to update a ByteMatchSet with a Field of HEADER but no value
 //      for Data.
 //
+//      * Your request references an ARN that is malformed, or corresponds to
+//      a resource with which a web ACL cannot be associated.
+//
 //   * LimitsExceededException
 //   The operation exceeds a resource limit, for example, the maximum number of
 //   WebACL objects that you can create for an AWS account. For more information,
@@ -514,6 +523,9 @@ func (c *WAF) CreateSizeConstraintSetRequest(input *CreateSizeConstraintSetInput
 //      * You tried to update a ByteMatchSet with a Field of HEADER but no value
 //      for Data.
 //
+//      * Your request references an ARN that is malformed, or corresponds to
+//      a resource with which a web ACL cannot be associated.
+//
 //   * LimitsExceededException
 //   The operation exceeds a resource limit, for example, the maximum number of
 //   WebACL objects that you can create for an AWS account. For more information,
@@ -633,6 +645,9 @@ func (c *WAF) CreateSqlInjectionMatchSetRequest(input *CreateSqlInjectionMatchSe
 //      * You tried to update a ByteMatchSet with a Field of HEADER but no value
 //      for Data.
 //
+//      * Your request references an ARN that is malformed, or corresponds to
+//      a resource with which a web ACL cannot be associated.
+//
 //   * StaleDataException
 //   The operation failed because you tried to create, update, or delete an object
 //   by using a change token that has already been used.
@@ -772,6 +787,9 @@ func (c *WAF) CreateWebACLRequest(input *CreateWebACLInput) (req *request.Reques
 //      * You tried to update a ByteMatchSet with a Field of HEADER but no value
 //      for Data.
 //
+//      * Your request references an ARN that is malformed, or corresponds to
+//      a resource with which a web ACL cannot be associated.
+//
 //   * LimitsExceededException
 //   The operation exceeds a resource limit, for example, the maximum number of
 //   WebACL objects that you can create for an AWS account. For more information,
@@ -892,6 +910,9 @@ func (c *WAF) CreateXssMatchSetRequest(input *CreateXssMatchSetInput) (req *requ
 //      * You tried to update a ByteMatchSet with a Field of HEADER but no value
 //      for Data.
 //
+//      * Your request references an ARN that is malformed, or corresponds to
+//      a resource with which a web ACL cannot be associated.
+//
 //   * StaleDataException
 //   The operation failed because you tried to create, update, or delete an object
 //   by using a change token that has already been used.
@@ -3053,6 +3074,9 @@ func (c *WAF) UpdateByteMatchSetRequest(input *UpdateByteMatchSetInput) (req *re
 //      * You tried to update a ByteMatchSet with a Field of HEADER but no value
 //      for Data.
 //
+//      * Your request references an ARN that is malformed, or corresponds to
+//      a resource with which a web ACL cannot be associated.
+//
 //   * NonexistentContainerException
 //   The operation failed because you tried to add an object to or delete an object
 //   from another object that doesn't exist. For example:
@@ -3140,15 +3164,25 @@ func (c *WAF) UpdateIPSetRequest(input *UpdateIPSetInput) (req *request.Request,
 //    change an IPSetDescriptor object, you delete the existing object and add
 //    a new one.
 //
-//    * The IP address version, IPv4.
+//    * The IP address version, IPv4 or IPv6.
 //
 //    * The IP address in CIDR notation, for example, 192.0.2.0/24 (for the
 //    range of IP addresses from 192.0.2.0 to 192.0.2.255) or 192.0.2.44/32
 //    (for the individual IP address 192.0.2.44).
 //
-// AWS WAF supports /8, /16, /24, and /32 IP address ranges. For more information
+// AWS WAF supports /8, /16, /24, and /32 IP address ranges for IPv4, and /24,
-// about CIDR notation, see the Wikipedia entry Classless Inter-Domain Routing
+// /32, /48, /56, /64 and /128 for IPv6. For more information about CIDR notation,
-// (https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing).
+// see the Wikipedia entry Classless Inter-Domain Routing (https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing).
+//
+// IPv6 addresses can be represented using any of the following formats:
+//
+//    * 1111:0000:0000:0000:0000:0000:0000:0111/128
+//
+//    * 1111:0:0:0:0:0:0:0111/128
+//
+//    * 1111::0111/128
+//
+//    * 1111::111/128
 //
 // You use an IPSet to specify which web requests you want to allow or block
 // based on the IP addresses that the requests originated from. For example,
@@ -3237,6 +3271,9 @@ func (c *WAF) UpdateIPSetRequest(input *UpdateIPSetInput) (req *request.Request,
 //      * You tried to update a ByteMatchSet with a Field of HEADER but no value
 //      for Data.
 //
+//      * Your request references an ARN that is malformed, or corresponds to
+//      a resource with which a web ACL cannot be associated.
+//
 //   * NonexistentContainerException
 //   The operation failed because you tried to add an object to or delete an object
 //   from another object that doesn't exist. For example:
@@ -3419,6 +3456,9 @@ func (c *WAF) UpdateRuleRequest(input *UpdateRuleInput) (req *request.Request, o
 //      * You tried to update a ByteMatchSet with a Field of HEADER but no value
 //      for Data.
 //
+//      * Your request references an ARN that is malformed, or corresponds to
+//      a resource with which a web ACL cannot be associated.
+//
 //   * NonexistentContainerException
 //   The operation failed because you tried to add an object to or delete an object
 //   from another object that doesn't exist. For example:
@@ -3607,6 +3647,9 @@ func (c *WAF) UpdateSizeConstraintSetRequest(input *UpdateSizeConstraintSetInput
 //      * You tried to update a ByteMatchSet with a Field of HEADER but no value
 //      for Data.
 //
+//      * Your request references an ARN that is malformed, or corresponds to
+//      a resource with which a web ACL cannot be associated.
+//
 //   * NonexistentContainerException
 //   The operation failed because you tried to add an object to or delete an object
 //   from another object that doesn't exist. For example:
@@ -3784,6 +3827,9 @@ func (c *WAF) UpdateSqlInjectionMatchSetRequest(input *UpdateSqlInjectionMatchSe
 //      * You tried to update a ByteMatchSet with a Field of HEADER but no value
 //      for Data.
 //
+//      * Your request references an ARN that is malformed, or corresponds to
+//      a resource with which a web ACL cannot be associated.
+//
 //   * NonexistentContainerException
 //   The operation failed because you tried to add an object to or delete an object
 //   from another object that doesn't exist. For example:
@@ -3974,6 +4020,9 @@ func (c *WAF) UpdateWebACLRequest(input *UpdateWebACLInput) (req *request.Reques
 //      * You tried to update a ByteMatchSet with a Field of HEADER but no value
 //      for Data.
 //
+//      * Your request references an ARN that is malformed, or corresponds to
+//      a resource with which a web ACL cannot be associated.
+//
 //   * NonexistentContainerException
 //   The operation failed because you tried to add an object to or delete an object
 //   from another object that doesn't exist. For example:
@@ -4151,6 +4200,9 @@ func (c *WAF) UpdateXssMatchSetRequest(input *UpdateXssMatchSetInput) (req *requ
 //      * You tried to update a ByteMatchSet with a Field of HEADER but no value
 //      for Data.
 //
+//      * Your request references an ARN that is malformed, or corresponds to
+//      a resource with which a web ACL cannot be associated.
+//
 //   * NonexistentContainerException
 //   The operation failed because you tried to add an object to or delete an object
 //   from another object that doesn't exist. For example:
@@ -6418,8 +6470,8 @@ type GetSampledRequestsInput struct {
 
 	// The start date and time and the end date and time of the range for which
 	// you want GetSampledRequests to return a sample of requests. Specify the date
-	// and time in Unix time format (in seconds). You can specify any time range
+	// and time in the following format: "2016-09-27T14:50Z". You can specify any
-	// in the previous three hours.
+	// time range in the previous three hours.
 	//
 	// TimeWindow is a required field
 	TimeWindow *TimeWindow `type:"structure" required:"true"`
@@ -6970,16 +7022,20 @@ func (s *HTTPRequest) SetURI(v string) *HTTPRequest {
 }
 
 // Contains one or more IP addresses or blocks of IP addresses specified in
-// Classless Inter-Domain Routing (CIDR) notation. To specify an individual
+// Classless Inter-Domain Routing (CIDR) notation. AWS WAF supports /8, /16,
-// IP address, you specify the four-part IP address followed by a /32, for example,
+// /24, and /32 IP address ranges for IPv4, and /24, /32, /48, /56, /64 and
-// 192.0.2.0/31. To block a range of IP addresses, you can specify a /24, a
+// /128 for IPv6.
-// /16, or a /8 CIDR. For more information about CIDR notation, perform an Internet
+//
-// search on cidr notation.
+// To specify an individual IP address, you specify the four-part IP address
+// followed by a /32, for example, 192.0.2.0/31. To block a range of IP addresses,
+// you can specify a /128, /64, /56, /48, /32, /24, /16, or /8 CIDR. For more
+// information about CIDR notation, see the Wikipedia entry Classless Inter-Domain
+// Routing (https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing).
 type IPSet struct {
 	_ struct{} `type:"structure"`
 
-	// The IP address type (IPV4) and the IP address range (in CIDR notation) that
+	// The IP address type (IPV4 or IPV6) and the IP address range (in CIDR notation)
-	// web requests originate from. If the WebACL is associated with a CloudFront
+	// that web requests originate from. If the WebACL is associated with a CloudFront
 	// distribution, this is the value of one of the following fields in CloudFront
 	// access logs:
 	//
@@ -7035,12 +7091,12 @@ func (s *IPSet) SetName(v string) *IPSet {
 	return s
 }
 
-// Specifies the IP address type (IPV4) and the IP address range (in CIDR format)
+// Specifies the IP address type (IPV4 or IPV6) and the IP address range (in
-// that web requests originate from.
+// CIDR format) that web requests originate from.
 type IPSetDescriptor struct {
 	_ struct{} `type:"structure"`
 
-	// Specify IPV4.
+	// Specify IPV4 or IPV6.
 	//
 	// Type is a required field
 	Type *string `type:"string" required:"true" enum:"IPSetDescriptorType"`
@@ -7053,11 +7109,18 @@ type IPSetDescriptor struct {
 	//    * To configure AWS WAF to allow, block, or count requests that originated
 	//    from IP addresses from 192.0.2.0 to 192.0.2.255, specify 192.0.2.0/24.
 	//
-	// AWS WAF supports only /8, /16, /24, and /32 IP addresses.
-	//
 	// For more information about CIDR notation, see the Wikipedia entry Classless
 	// Inter-Domain Routing (https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing).
 	//
+	// Specify an IPv6 address by using CIDR notation. For example:
+	//
+	//    * To configure AWS WAF to allow, block, or count requests that originated
+	//    from the IP address 1111:0000:0000:0000:0000:0000:0000:0111, specify 1111:0000:0000:0000:0000:0000:0000:0111/128.
+	//
+	//    * To configure AWS WAF to allow, block, or count requests that originated
+	//    from IP addresses 1111:0000:0000:0000:0000:0000:0000:0000 to 1111:0000:0000:0000:ffff:ffff:ffff:ffff,
+	//    specify 1111:0000:0000:0000:0000:0000:0000:0000/64.
+	//
 	// Value is a required field
 	Value *string `type:"string" required:"true"`
 }
@@ -7148,8 +7211,8 @@ type IPSetUpdate struct {
 	// Action is a required field
 	Action *string `type:"string" required:"true" enum:"ChangeAction"`
 
-	// The IP address type (IPV4) and the IP address range (in CIDR notation) that
+	// The IP address type (IPV4 or IPV6) and the IP address range (in CIDR notation)
-	// web requests originate from.
+	// that web requests originate from.
 	//
 	// IPSetDescriptor is a required field
 	IPSetDescriptor *IPSetDescriptor `type:"structure" required:"true"`
@@ -7915,6 +7978,9 @@ func (s *Predicate) SetType(v string) *Predicate {
 type Rule struct {
 	_ struct{} `type:"structure"`
 
+	// A friendly name or description for the metrics for this Rule. The name can
+	// contain only alphanumeric characters (A-Z, a-z, 0-9); the name can't contain
+	// whitespace. You can't change MetricName after you create the Rule.
 	MetricName *string `type:"string"`
 
 	// The friendly name or description for the Rule. You can't change the name
@@ -8165,7 +8231,7 @@ type SizeConstraint struct {
 	// ComparisonOperator is a required field
 	ComparisonOperator *string `type:"string" required:"true" enum:"ComparisonOperator"`
 
-	// Specifies where in a web request to look for TargetString.
+	// Specifies where in a web request to look for the size constraint.
 	//
 	// FieldToMatch is a required field
 	FieldToMatch *FieldToMatch `type:"structure" required:"true"`
@@ -8656,7 +8722,7 @@ func (s *SqlInjectionMatchSetUpdate) SetSqlInjectionMatchTuple(v *SqlInjectionMa
 type SqlInjectionMatchTuple struct {
 	_ struct{} `type:"structure"`
 
-	// Specifies where in a web request to look for TargetString.
+	// Specifies where in a web request to look for snippets of malicious SQL code.
 	//
 	// FieldToMatch is a required field
 	FieldToMatch *FieldToMatch `type:"structure" required:"true"`
@@ -8793,15 +8859,17 @@ type TimeWindow struct {
 	_ struct{} `type:"structure"`
 
 	// The end of the time range from which you want GetSampledRequests to return
-	// a sample of the requests that your AWS resource received. You can specify
+	// a sample of the requests that your AWS resource received. Specify the date
-	// any time range in the previous three hours.
+	// and time in the following format: "2016-09-27T14:50Z". You can specify any
+	// time range in the previous three hours.
 	//
 	// EndTime is a required field
 	EndTime *time.Time `type:"timestamp" timestampFormat:"unix" required:"true"`
 
 	// The beginning of the time range from which you want GetSampledRequests to
-	// return a sample of the requests that your AWS resource received. You can
+	// return a sample of the requests that your AWS resource received. Specify
-	// specify any time range in the previous three hours.
+	// the date and time in the following format: "2016-09-27T14:50Z". You can specify
+	// any time range in the previous three hours.
 	//
 	// StartTime is a required field
 	StartTime *time.Time `type:"timestamp" timestampFormat:"unix" required:"true"`
@@ -9432,11 +9500,9 @@ type UpdateWebACLInput struct {
 	// ChangeToken is a required field
 	ChangeToken *string `min:"1" type:"string" required:"true"`
 
-	// For the action that is associated with a rule in a WebACL, specifies the
+	// A default action for the web ACL, either ALLOW or BLOCK. AWS WAF performs
-	// action that you want AWS WAF to perform when a web request matches all of
+	// the default action if a request doesn't match the criteria in any of the
-	// the conditions in a rule. For the default action in a WebACL, specifies the
+	// rules in a web ACL.
-	// action that you want AWS WAF to take when a web request doesn't match all
-	// of the conditions in any of the rules in a WebACL.
 	DefaultAction *WafAction `type:"structure"`
 
 	// An array of updates to make to the WebACL.
@@ -9741,6 +9807,9 @@ type WebACL struct {
 	// DefaultAction is a required field
 	DefaultAction *WafAction `type:"structure" required:"true"`
 
+	// A friendly name or description for the metrics for this WebACL. The name
+	// can contain only alphanumeric characters (A-Z, a-z, 0-9); the name can't
+	// contain whitespace. You can't change MetricName after you create the WebACL.
 	MetricName *string `type:"string"`
 
 	// A friendly name or description of the WebACL. You can't change the name of
@@ -9859,9 +9928,6 @@ type WebACLUpdate struct {
 	// the action that you want AWS WAF to take when a web request matches the Rule
 	// (ALLOW, BLOCK, or COUNT).
 	//
-	// To specify whether to insert or delete a Rule, use the Action parameter in
-	// the WebACLUpdate data type.
-	//
 	// ActivatedRule is a required field
 	ActivatedRule *ActivatedRule `type:"structure" required:"true"`
 }
@@ -10077,7 +10143,7 @@ func (s *XssMatchSetUpdate) SetXssMatchTuple(v *XssMatchTuple) *XssMatchSetUpdat
 type XssMatchTuple struct {
 	_ struct{} `type:"structure"`
 
-	// Specifies where in a web request to look for TargetString.
+	// Specifies where in a web request to look for cross-site scripting attacks.
 	//
 	// FieldToMatch is a required field
 	FieldToMatch *FieldToMatch `type:"structure" required:"true"`

vendor/github.com/aws/aws-sdk-go/service/waf/service.go

@@ -11,10 +11,13 @@ import (
 	"github.com/aws/aws-sdk-go/private/protocol/jsonrpc"
 )
 
-// This is the AWS WAF API Reference. This guide is for developers who need
+// This is the AWS WAF API Reference for using AWS WAF with Amazon CloudFront.
-// detailed information about the AWS WAF API actions, data types, and errors.
+// The AWS WAF actions and data types listed in the reference are available
-// For detailed information about AWS WAF features and an overview of how to
+// for protecting Amazon CloudFront distributions. You can use these actions
-// use the AWS WAF API, see the AWS WAF Developer Guide (http://docs.aws.amazon.com/waf/latest/developerguide/).
+// and data types via the endpoint waf.amazonaws.com. This guide is for developers
+// who need detailed information about the AWS WAF API actions, data types,
+// and errors. For detailed information about AWS WAF features and an overview
+// of how to use the AWS WAF API, see the AWS WAF Developer Guide (http://docs.aws.amazon.com/waf/latest/developerguide/).
 //The service client's operations are safe to be used concurrently.
 // It is not safe to mutate any of the client's properties though.
 type WAF struct {
@@ -42,16 +45,17 @@ const ServiceName = "waf"
 //     svc := waf.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
 func New(p client.ConfigProvider, cfgs ...*aws.Config) *WAF {
 	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
+	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 string) *WAF {
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *WAF {
 	svc := &WAF{
 		Client: client.New(
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   ServiceName,
+				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
 				APIVersion:    "2015-08-24",

vendor/vendor.json

@@ -385,588 +385,596 @@
 			"revision": "4239b77079c7b5d1243b7b4736304ce8ddb6f0f2"
 		},
 		{
-			"checksumSHA1": "4pgYZWTGSHhY5zzL2yvbh+XfFgg=",
+			"checksumSHA1": "Y32T4+W6A22f/T+k5oWBu1ksZG8=",
 			"path": "github.com/aws/aws-sdk-go",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "f5mMRgx2qaUv2T4AaCwMRj6HI8Q=",
+			"checksumSHA1": "4xOksgb6+UlSj06NdNOOw//S4hw=",
 			"path": "github.com/aws/aws-sdk-go/aws",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "Y9W+4GimK4Fuxq+vyIskVYFRnX4=",
 			"path": "github.com/aws/aws-sdk-go/aws/awserr",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "yyYr41HZ1Aq0hWc3J5ijXwYEcac=",
 			"path": "github.com/aws/aws-sdk-go/aws/awsutil",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "/232RBWA3KnT7U+wciPS2+wmvR0=",
+			"checksumSHA1": "7cQU8tU9hBgsG23XZmko1GePqjQ=",
 			"path": "github.com/aws/aws-sdk-go/aws/client",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "ieAJ+Cvp/PKv1LpUEnUXpc3OI6E=",
 			"path": "github.com/aws/aws-sdk-go/aws/client/metadata",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "Fl8vRSCY0MbM04cmiz/0MID+goA=",
 			"path": "github.com/aws/aws-sdk-go/aws/corehandlers",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "zu5C95rmCZff6NYZb62lEaT5ibE=",
 			"path": "github.com/aws/aws-sdk-go/aws/credentials",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "u3GOAJLmdvbuNUeUEcZSEAOeL/0=",
 			"path": "github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "NUJUTWlc1sV8b7WjfiYc4JZbXl0=",
 			"path": "github.com/aws/aws-sdk-go/aws/credentials/endpointcreds",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "4Ipx+5xN0gso+cENC2MHMWmQlR4=",
 			"path": "github.com/aws/aws-sdk-go/aws/credentials/stscreds",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "DwhFsNluCFEwqzyp3hbJR3q2Wqs=",
+			"checksumSHA1": "lqh3fG7wCochvB4iHAZJuhhEJW0=",
 			"path": "github.com/aws/aws-sdk-go/aws/defaults",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "/EXbk/z2TWjWc1Hvb4QYs3Wmhb8=",
 			"path": "github.com/aws/aws-sdk-go/aws/ec2metadata",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
+		},
+		{
+			"checksumSHA1": "Lqo3kG7oU3dkZwQ5LPINQtrVL+s=",
+			"path": "github.com/aws/aws-sdk-go/aws/endpoints",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
+			"revisionTime": "2016-12-09T00:47:51Z",
+			"version": "v1.6.2",
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "yVSL6yhjj0Pozx4NVrWA3aguENg=",
 			"path": "github.com/aws/aws-sdk-go/aws/request",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "HT1op89NoiShWN5XBRGdZkQTf4A=",
+			"checksumSHA1": "HynfxYegMG8sq9MpFfPu7h1EOvI=",
 			"path": "github.com/aws/aws-sdk-go/aws/session",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "bjf3WCqht846AsRh85c8d7iLmsk=",
 			"path": "github.com/aws/aws-sdk-go/aws/signer/v4",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "Esab5F8KswqkTdB4TtjSvZgs56k=",
 			"path": "github.com/aws/aws-sdk-go/private/endpoints",
 			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
 			"revisionTime": "2016-12-01T20:26:07Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "wk7EyvDaHwb5qqoOP/4d3cV0708=",
 			"path": "github.com/aws/aws-sdk-go/private/protocol",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "1QmQ3FqV37w0Zi44qv8pA1GeR0A=",
 			"path": "github.com/aws/aws-sdk-go/private/protocol/ec2query",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "pNeF0Ey7TfBArH5LBQhKOQXQbLY=",
 			"path": "github.com/aws/aws-sdk-go/private/protocol/json/jsonutil",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "R00RL5jJXRYq1iiK1+PGvMfvXyM=",
 			"path": "github.com/aws/aws-sdk-go/private/protocol/jsonrpc",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "ZqY5RWavBLWTo6j9xqdyBEaNFRk=",
 			"path": "github.com/aws/aws-sdk-go/private/protocol/query",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "5xzix1R8prUyWxgLnzUQoxTsfik=",
 			"path": "github.com/aws/aws-sdk-go/private/protocol/query/queryutil",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "dUpGLm7IHo6A40vuaEKwaCLbqu8=",
 			"path": "github.com/aws/aws-sdk-go/private/protocol/rest",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "Rpu8KBtHZgvhkwHxUfaky+qW+G4=",
 			"path": "github.com/aws/aws-sdk-go/private/protocol/restjson",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "ODo+ko8D6unAxZuN1jGzMcN4QCc=",
 			"path": "github.com/aws/aws-sdk-go/private/protocol/restxml",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "U30tX6Rd4LSOjrm/E2WB0TyFxr8=",
+			"checksumSHA1": "gEJLFS3ltnGYsfm2kXEPpxC1r0w=",
 			"path": "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "F6mth+G7dXN1GI+nktaGo8Lx8aE=",
 			"path": "github.com/aws/aws-sdk-go/private/signer/v2",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "Eo9yODN5U99BK0pMzoqnBm7PCrY=",
 			"path": "github.com/aws/aws-sdk-go/private/waiter",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "INWpIaoMQ5yhSUDuC6BI2tnT01w=",
+			"checksumSHA1": "TDz2yddSHFPJc/C22iNs4878PHM=",
 			"path": "github.com/aws/aws-sdk-go/service/acm",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "nc8ftVV4VgKNZrVA5IAOSjPCtUE=",
+			"checksumSHA1": "P64s704ATrUQRxVBFZqJOAYMjjI=",
 			"path": "github.com/aws/aws-sdk-go/service/apigateway",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "DZc+6wpn5VIQEoFMxLIKwVYliJE=",
+			"checksumSHA1": "1Pd+tSJCCgCOOfaep0R8ULeFcps=",
 			"path": "github.com/aws/aws-sdk-go/service/applicationautoscaling",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "Y5ewqOw2oooAc17RZBLEfFe97NQ=",
+			"checksumSHA1": "YP2elni/MgVN2Y6zsYpdFTmeqhI=",
 			"path": "github.com/aws/aws-sdk-go/service/autoscaling",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "e0qgGpjfhqhr2ka/IxWGVvtszzM=",
+			"checksumSHA1": "lCpOwC1fXad6ryDTypq0F4JtaS0=",
 			"path": "github.com/aws/aws-sdk-go/service/cloudformation",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "71H57UIgdJgkDZxJQsxJEB6ihqQ=",
+			"checksumSHA1": "Mh4SHt8v6TpcInltokbNmyrPjmM=",
 			"path": "github.com/aws/aws-sdk-go/service/cloudfront",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "1hnZsVUSJ0quZ37/xmwwCvQh2U8=",
+			"checksumSHA1": "BLNtHos7msi3UgPBabM5aGFBQLE=",
 			"path": "github.com/aws/aws-sdk-go/service/cloudtrail",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "3jnrRIRHqRiWDqb71FMSfs9AvXk=",
+			"checksumSHA1": "WMY04nOx+iSSqUvzhhXK0VQSMyo=",
 			"path": "github.com/aws/aws-sdk-go/service/cloudwatch",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "YLXFc6XhmmnVEfHPE0Bb8f5wndw=",
+			"checksumSHA1": "ylJusOEGXzgULSm4HJxizIVv9C4=",
 			"path": "github.com/aws/aws-sdk-go/service/cloudwatchevents",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "bgkauNc4M46Pmyw7lHkvzw3sxiw=",
+			"checksumSHA1": "+yi+erDoYK8na5KSqvmThSJAUuc=",
 			"path": "github.com/aws/aws-sdk-go/service/cloudwatchlogs",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "rKsbQ6FWQSqiE+ujHG6HietgH5Y=",
+			"checksumSHA1": "Jng3vw4P9MUVqz9DEtpKtkE+NzY=",
 			"path": "github.com/aws/aws-sdk-go/service/codecommit",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "YvpsgALidLyjzRgRHusdw7vS22k=",
+			"checksumSHA1": "C/9H+tfWy7SYZjnKRSVpVKtuq5U=",
 			"path": "github.com/aws/aws-sdk-go/service/codedeploy",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "3aRyyRHgUh+w26Wqrruxxa1VaxA=",
+			"checksumSHA1": "EZp2Hsz9AePGNEJj6UXTOrjgZ7E=",
 			"path": "github.com/aws/aws-sdk-go/service/directoryservice",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "E5qjR1pDa/V2LEhXP36kZH2w91o=",
+			"checksumSHA1": "1UC9irawr68ulnNczZ2He1hprIk=",
 			"path": "github.com/aws/aws-sdk-go/service/dynamodb",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "oS1hsSSRADAoJlk7oiJApIDeOYg=",
+			"checksumSHA1": "YA/T7rrQeSok3Hvq14HezMXVdgM=",
 			"path": "github.com/aws/aws-sdk-go/service/ec2",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "3wd5o69gQcsDpBIJU2QMAYu/Yjs=",
+			"checksumSHA1": "GoO3KLWKTC69nWtcLFd6I+0BviE=",
 			"path": "github.com/aws/aws-sdk-go/service/ecr",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "99y497vsASAyQYAmAiGOgCFniiI=",
+			"checksumSHA1": "HiXiiX/5C6GA3E2/4QGIjcX9Ph0=",
 			"path": "github.com/aws/aws-sdk-go/service/ecs",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "cAYa6uHNWAKex00wQZQh/3RIP20=",
+			"checksumSHA1": "rhCpeCHIb7gHMG3AzaeJ9gj90Ss=",
 			"path": "github.com/aws/aws-sdk-go/service/efs",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "e/nua6AZAM1DOX1s+qcuDaOqWYc=",
+			"checksumSHA1": "xnolozwEtUYa0ve4MhDECFP89E0=",
 			"path": "github.com/aws/aws-sdk-go/service/elasticache",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "TwFv7k5MXe7UOQBWd/QTqxJawL8=",
+			"checksumSHA1": "8kPGuxiLTDyU9qhpKqCGMu0uXh0=",
 			"path": "github.com/aws/aws-sdk-go/service/elasticbeanstalk",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "z0ca3QajyQGpShh3psqolZLJt7Q=",
+			"checksumSHA1": "P/fyidKJvpLRYkQ/kPI+TwR8mho=",
 			"path": "github.com/aws/aws-sdk-go/service/elasticsearchservice",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "t/dBXjcSbc5phqiIoGtOIELycNg=",
+			"checksumSHA1": "IS6CjupSEiS74a+CE4oNVPa5KCA=",
 			"path": "github.com/aws/aws-sdk-go/service/elastictranscoder",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "X6fiZ2b/U1WpYBzw5fqm2Wm8Hr0=",
+			"checksumSHA1": "pJ3cqQyo+6DmScOAGzoN/AbBN0I=",
 			"path": "github.com/aws/aws-sdk-go/service/elb",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "D+1s7cgL4iMtswW+x233jAV8eJI=",
+			"checksumSHA1": "0/6y8+qPnDY9Dt2rNSzXyZwBDZ8=",
 			"path": "github.com/aws/aws-sdk-go/service/elbv2",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "+GSIhCXrofZZRF4Bz4XuX8B8o7U=",
+			"checksumSHA1": "qF4j44Lj+8bQyN4JtFnLC/rdQQU=",
 			"path": "github.com/aws/aws-sdk-go/service/emr",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "71xHwOAjzdFQ+zQieThJWKObvS4=",
+			"checksumSHA1": "V5X1oCT01nRtG9IJR7vme1uEy6M=",
 			"path": "github.com/aws/aws-sdk-go/service/firehose",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "SU/YDilOf4uh4tC3O4ZyKfu9Ca8=",
+			"checksumSHA1": "0T1k3TvEF9NGsDBYstyQ0EfML5U=",
 			"path": "github.com/aws/aws-sdk-go/service/glacier",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "hQquEMm59E2CwVwfBvKRTVzBj/8=",
+			"checksumSHA1": "iZwFeUHpehkIRTnJW15F0U+vXy4=",
 			"path": "github.com/aws/aws-sdk-go/service/iam",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "1pBbVKt2n6Z/59Nd8mXe20/JEV4=",
+			"checksumSHA1": "YDO2aF3ENw9aAqR2S3I1cVzu5Ys=",
 			"path": "github.com/aws/aws-sdk-go/service/kinesis",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "ghoZkkKxN0lAJZ6Nb0sJiiFiQAI=",
+			"checksumSHA1": "CVgX/hDnfMt97xblJSD6doFKQX0=",
 			"path": "github.com/aws/aws-sdk-go/service/kms",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "GXX3mEJTPOrM1aHiNv31vyy+HAY=",
+			"checksumSHA1": "ym8DU7gjdHNjr82Yv+B7/Ba9nak=",
 			"path": "github.com/aws/aws-sdk-go/service/lambda",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "Zc40RDOSS1SZjt/YJebeWamE7+k=",
+			"checksumSHA1": "Jo8pWTgFDpH3UjUFH8vYuNRHliM=",
 			"path": "github.com/aws/aws-sdk-go/service/lightsail",
-			"revision": "e7849863adae563900a3474ee6feed65471ab070",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-11-30T19:57:18Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.12",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.12"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "BZY0NsRwwIbs52ZSjaEGqgWHXyo=",
+			"checksumSHA1": "CBDFLQpRfZtB9Symsz75x+rvX+8=",
 			"path": "github.com/aws/aws-sdk-go/service/opsworks",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "iGXoSzRemWsXcxdBLFqAaZ3ulf8=",
+			"checksumSHA1": "U1L9GpoLI0wS0A/HXsA22fq6iSE=",
 			"path": "github.com/aws/aws-sdk-go/service/rds",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "bxHXVhiqpF3njkRRNcLn+tyhwZQ=",
+			"checksumSHA1": "gaVND3Q/AISc7O5XpvEs6N0jBPQ=",
 			"path": "github.com/aws/aws-sdk-go/service/redshift",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "i04x4j6gtaNDUHGlJa5bs+m4wlw=",
+			"checksumSHA1": "IUqMex8vm/eplN5SnhqEBsNvIfA=",
 			"path": "github.com/aws/aws-sdk-go/service/route53",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "lC6CowuZ0Zjvbcw3hjYSc1cxbPE=",
+			"checksumSHA1": "u52HRY/P/tJnAPDG+PvAAaiYZvM=",
 			"path": "github.com/aws/aws-sdk-go/service/s3",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "6TbKrx2keOneistnAS39cVXTunY=",
+			"checksumSHA1": "UB+GbtUsEGWDtBi9CRgkQr5EMJU=",
 			"path": "github.com/aws/aws-sdk-go/service/ses",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "hp8JNTd1l4AvNps0/z3UsukvWsQ=",
+			"checksumSHA1": "lTQe5o+2c+Xsp40wjYzLtgmgRqE=",
 			"path": "github.com/aws/aws-sdk-go/service/simpledb",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "eGU3IGTGnOKW8qUi80UJrtkcmRw=",
+			"checksumSHA1": "eLaZeCUS3hDQ+zzsFZb0CJBMKfQ=",
 			"path": "github.com/aws/aws-sdk-go/service/sns",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "hTgsEbW3erfnTHok+7TKOSUlaYU=",
+			"checksumSHA1": "axR50MilXNLES2LyS4JZvINO6E8=",
 			"path": "github.com/aws/aws-sdk-go/service/sqs",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "9Tt+EzXo9wwMkrzZTdnXHkHfQoU=",
+			"checksumSHA1": "VJ3ESVb5RvAGkY4zPETJ3ia4v38=",
 			"path": "github.com/aws/aws-sdk-go/service/ssm",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "ouwhxcAsIYQ6oJbMRdLW/Ys/iyg=",
+			"checksumSHA1": "Y14Bai6CkzS0FI97MtC5XjQt8Iw=",
 			"path": "github.com/aws/aws-sdk-go/service/sts",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
-			"checksumSHA1": "BvZSVj6c/aEe0Ihf08fBXdIRz8A=",
+			"checksumSHA1": "s0hZKoL3y62JP2/3+ciUU3hhLW4=",
 			"path": "github.com/aws/aws-sdk-go/service/waf",
-			"revision": "918c42e2bcdb277aa821401c906e88254501bdf4",
+			"revision": "1355b456f6ba4a8453249e0dc7743f16ccac362d",
-			"revisionTime": "2016-12-01T20:26:07Z",
+			"revisionTime": "2016-12-09T00:47:51Z",
-			"version": "=v1.5.13",
+			"version": "v1.6.2",
-			"versionExact": "v1.5.13"
+			"versionExact": "v1.6.2"
 		},
 		{
 			"checksumSHA1": "nqw2Qn5xUklssHTubS5HDvEL9L4=",