diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json
index e532843..8af16a1 100644
--- a/Godeps/Godeps.json
+++ b/Godeps/Godeps.json
@@ -1,7 +1,7 @@
 {
 	"ImportPath": "github.com/golang/gddo",
-	"GoVersion": "go1.9",
-	"GodepVersion": "v79",
+	"GoVersion": "go1.10",
+	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
 	],
@@ -12,6 +12,11 @@
 			"Rev": "2d3a6656c17a60b0815b7e06ab0be04eacb6e613"
 		},
 		{
+			"ImportPath": "cloud.google.com/go/iam",
+			"Comment": "v0.16.0",
+			"Rev": "2d3a6656c17a60b0815b7e06ab0be04eacb6e613"
+		},
+		{
 			"ImportPath": "cloud.google.com/go/internal/tracecontext",
 			"Comment": "v0.16.0",
 			"Rev": "2d3a6656c17a60b0815b7e06ab0be04eacb6e613"
@@ -37,6 +42,16 @@
 			"Rev": "2d3a6656c17a60b0815b7e06ab0be04eacb6e613"
 		},
 		{
+			"ImportPath": "cloud.google.com/go/pubsub",
+			"Comment": "v0.16.0",
+			"Rev": "2d3a6656c17a60b0815b7e06ab0be04eacb6e613"
+		},
+		{
+			"ImportPath": "cloud.google.com/go/pubsub/apiv1",
+			"Comment": "v0.16.0",
+			"Rev": "2d3a6656c17a60b0815b7e06ab0be04eacb6e613"
+		},
+		{
 			"ImportPath": "cloud.google.com/go/trace",
 			"Comment": "v0.16.0",
 			"Rev": "2d3a6656c17a60b0815b7e06ab0be04eacb6e613"
@@ -289,6 +304,10 @@
 			"Rev": "13449ad91cb26cb47661c1b080790392170385fd"
 		},
 		{
+			"ImportPath": "golang.org/x/sync/errgroup",
+			"Rev": "f52d1811a62927559de87708c8913c1650ce4f26"
+		},
+		{
 			"ImportPath": "golang.org/x/sync/semaphore",
 			"Rev": "f52d1811a62927559de87708c8913c1650ce4f26"
 		},
@@ -298,18 +317,22 @@
 		},
 		{
 			"ImportPath": "golang.org/x/text/secure/bidirule",
+			"Comment": "v0.1.0-6-g1cbadb4",
 			"Rev": "1cbadb444a806fd9430d14ad08967ed91da4fa0a"
 		},
 		{
 			"ImportPath": "golang.org/x/text/transform",
+			"Comment": "v0.1.0-6-g1cbadb4",
 			"Rev": "1cbadb444a806fd9430d14ad08967ed91da4fa0a"
 		},
 		{
 			"ImportPath": "golang.org/x/text/unicode/bidi",
+			"Comment": "v0.1.0-6-g1cbadb4",
 			"Rev": "1cbadb444a806fd9430d14ad08967ed91da4fa0a"
 		},
 		{
 			"ImportPath": "golang.org/x/text/unicode/norm",
+			"Comment": "v0.1.0-6-g1cbadb4",
 			"Rev": "1cbadb444a806fd9430d14ad08967ed91da4fa0a"
 		},
 		{
@@ -318,15 +341,15 @@
 		},
 		{
 			"ImportPath": "golang.org/x/tools/go/gcexportdata",
-			"Rev": "e531a2a1c15f94033f6fa87666caeb19a688175f"
+			"Rev": "a5b4c53f6e8bdcafa95a94671bf2d1203365858b"
 		},
 		{
-			"ImportPath": "golang.org/x/tools/go/gcimporter15",
-			"Rev": "e531a2a1c15f94033f6fa87666caeb19a688175f"
+			"ImportPath": "golang.org/x/tools/go/internal/gcimporter",
+			"Rev": "a5b4c53f6e8bdcafa95a94671bf2d1203365858b"
 		},
 		{
 			"ImportPath": "golang.org/x/tools/present",
-			"Rev": "e531a2a1c15f94033f6fa87666caeb19a688175f"
+			"Rev": "a5b4c53f6e8bdcafa95a94671bf2d1203365858b"
 		},
 		{
 			"ImportPath": "google.golang.org/api/cloudtrace/v1",
@@ -497,7 +520,7 @@
 			"Rev": "1e559d0a00eef8a9a43151db4665280bd8dd5886"
 		},
 		{
-			"ImportPath": "google.golang.org/genproto/googleapis/cloud/runtimeconfig/v1beta1",
+			"ImportPath": "google.golang.org/genproto/googleapis/iam/v1",
 			"Rev": "1e559d0a00eef8a9a43151db4665280bd8dd5886"
 		},
 		{
@@ -509,7 +532,7 @@
 			"Rev": "1e559d0a00eef8a9a43151db4665280bd8dd5886"
 		},
 		{
-			"ImportPath": "google.golang.org/genproto/googleapis/longrunning",
+			"ImportPath": "google.golang.org/genproto/googleapis/pubsub/v1",
 			"Rev": "1e559d0a00eef8a9a43151db4665280bd8dd5886"
 		},
 		{
diff --git a/vendor/cloud.google.com/go/iam/iam.go b/vendor/cloud.google.com/go/iam/iam.go
new file mode 100644
index 0000000..8722ee8
--- /dev/null
+++ b/vendor/cloud.google.com/go/iam/iam.go
@@ -0,0 +1,256 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package iam supports the resource-specific operations of Google Cloud
+// IAM (Identity and Access Management) for the Google Cloud Libraries.
+// See https://cloud.google.com/iam for more about IAM.
+//
+// Users of the Google Cloud Libraries will typically not use this package
+// directly. Instead they will begin with some resource that supports IAM, like
+// a pubsub topic, and call its IAM method to get a Handle for that resource.
+package iam
+
+import (
+	"golang.org/x/net/context"
+	pb "google.golang.org/genproto/googleapis/iam/v1"
+	"google.golang.org/grpc"
+)
+
+// client abstracts the IAMPolicy API to allow multiple implementations.
+type client interface {
+	Get(ctx context.Context, resource string) (*pb.Policy, error)
+	Set(ctx context.Context, resource string, p *pb.Policy) error
+	Test(ctx context.Context, resource string, perms []string) ([]string, error)
+}
+
+// grpcClient implements client for the standard gRPC-based IAMPolicy service.
+type grpcClient struct {
+	c pb.IAMPolicyClient
+}
+
+func (g *grpcClient) Get(ctx context.Context, resource string) (*pb.Policy, error) {
+	proto, err := g.c.GetIamPolicy(ctx, &pb.GetIamPolicyRequest{Resource: resource})
+	if err != nil {
+		return nil, err
+	}
+	return proto, nil
+}
+func (g *grpcClient) Set(ctx context.Context, resource string, p *pb.Policy) error {
+	_, err := g.c.SetIamPolicy(ctx, &pb.SetIamPolicyRequest{
+		Resource: resource,
+		Policy:   p,
+	})
+	return err
+}
+
+func (g *grpcClient) Test(ctx context.Context, resource string, perms []string) ([]string, error) {
+	res, err := g.c.TestIamPermissions(ctx, &pb.TestIamPermissionsRequest{
+		Resource:    resource,
+		Permissions: perms,
+	})
+	if err != nil {
+		return nil, err
+	}
+	return res.Permissions, nil
+}
+
+// A Handle provides IAM operations for a resource.
+type Handle struct {
+	c        client
+	resource string
+}
+
+// InternalNewHandle is for use by the Google Cloud Libraries only.
+//
+// InternalNewHandle returns a Handle for resource.
+// The conn parameter refers to a server that must support the IAMPolicy service.
+func InternalNewHandle(conn *grpc.ClientConn, resource string) *Handle {
+	return InternalNewHandleClient(&grpcClient{c: pb.NewIAMPolicyClient(conn)}, resource)
+}
+
+// InternalNewHandleClient is for use by the Google Cloud Libraries only.
+//
+// InternalNewHandleClient returns a Handle for resource using the given
+// client implementation.
+func InternalNewHandleClient(c client, resource string) *Handle {
+	return &Handle{
+		c:        c,
+		resource: resource,
+	}
+}
+
+// Policy retrieves the IAM policy for the resource.
+func (h *Handle) Policy(ctx context.Context) (*Policy, error) {
+	proto, err := h.c.Get(ctx, h.resource)
+	if err != nil {
+		return nil, err
+	}
+	return &Policy{InternalProto: proto}, nil
+}
+
+// SetPolicy replaces the resource's current policy with the supplied Policy.
+//
+// If policy was created from a prior call to Get, then the modification will
+// only succeed if the policy has not changed since the Get.
+func (h *Handle) SetPolicy(ctx context.Context, policy *Policy) error {
+	return h.c.Set(ctx, h.resource, policy.InternalProto)
+}
+
+// TestPermissions returns the subset of permissions that the caller has on the resource.
+func (h *Handle) TestPermissions(ctx context.Context, permissions []string) ([]string, error) {
+	return h.c.Test(ctx, h.resource, permissions)
+}
+
+// A RoleName is a name representing a collection of permissions.
+type RoleName string
+
+// Common role names.
+const (
+	Owner  RoleName = "roles/owner"
+	Editor RoleName = "roles/editor"
+	Viewer RoleName = "roles/viewer"
+)
+
+const (
+	// AllUsers is a special member that denotes all users, even unauthenticated ones.
+	AllUsers = "allUsers"
+
+	// AllAuthenticatedUsers is a special member that denotes all authenticated users.
+	AllAuthenticatedUsers = "allAuthenticatedUsers"
+)
+
+// A Policy is a list of Bindings representing roles
+// granted to members.
+//
+// The zero Policy is a valid policy with no bindings.
+type Policy struct {
+	// TODO(jba): when type aliases are available, put Policy into an internal package
+	// and provide an exported alias here.
+
+	// This field is exported for use by the Google Cloud Libraries only.
+	// It may become unexported in a future release.
+	InternalProto *pb.Policy
+}
+
+// Members returns the list of members with the supplied role.
+// The return value should not be modified. Use Add and Remove
+// to modify the members of a role.
+func (p *Policy) Members(r RoleName) []string {
+	b := p.binding(r)
+	if b == nil {
+		return nil
+	}
+	return b.Members
+}
+
+// HasRole reports whether member has role r.
+func (p *Policy) HasRole(member string, r RoleName) bool {
+	return memberIndex(member, p.binding(r)) >= 0
+}
+
+// Add adds member member to role r if it is not already present.
+// A new binding is created if there is no binding for the role.
+func (p *Policy) Add(member string, r RoleName) {
+	b := p.binding(r)
+	if b == nil {
+		if p.InternalProto == nil {
+			p.InternalProto = &pb.Policy{}
+		}
+		p.InternalProto.Bindings = append(p.InternalProto.Bindings, &pb.Binding{
+			Role:    string(r),
+			Members: []string{member},
+		})
+		return
+	}
+	if memberIndex(member, b) < 0 {
+		b.Members = append(b.Members, member)
+		return
+	}
+}
+
+// Remove removes member from role r if it is present.
+func (p *Policy) Remove(member string, r RoleName) {
+	bi := p.bindingIndex(r)
+	if bi < 0 {
+		return
+	}
+	bindings := p.InternalProto.Bindings
+	b := bindings[bi]
+	mi := memberIndex(member, b)
+	if mi < 0 {
+		return
+	}
+	// Order doesn't matter for bindings or members, so to remove, move the last item
+	// into the removed spot and shrink the slice.
+	if len(b.Members) == 1 {
+		// Remove binding.
+		last := len(bindings) - 1
+		bindings[bi] = bindings[last]
+		bindings[last] = nil
+		p.InternalProto.Bindings = bindings[:last]
+		return
+	}
+	// Remove member.
+	// TODO(jba): worry about multiple copies of m?
+	last := len(b.Members) - 1
+	b.Members[mi] = b.Members[last]
+	b.Members[last] = ""
+	b.Members = b.Members[:last]
+}
+
+// Roles returns the names of all the roles that appear in the Policy.
+func (p *Policy) Roles() []RoleName {
+	if p.InternalProto == nil {
+		return nil
+	}
+	var rns []RoleName
+	for _, b := range p.InternalProto.Bindings {
+		rns = append(rns, RoleName(b.Role))
+	}
+	return rns
+}
+
+// binding returns the Binding for the suppied role, or nil if there isn't one.
+func (p *Policy) binding(r RoleName) *pb.Binding {
+	i := p.bindingIndex(r)
+	if i < 0 {
+		return nil
+	}
+	return p.InternalProto.Bindings[i]
+}
+
+func (p *Policy) bindingIndex(r RoleName) int {
+	if p.InternalProto == nil {
+		return -1
+	}
+	for i, b := range p.InternalProto.Bindings {
+		if b.Role == string(r) {
+			return i
+		}
+	}
+	return -1
+}
+
+// memberIndex returns the index of m in b's Members, or -1 if not found.
+func memberIndex(m string, b *pb.Binding) int {
+	if b == nil {
+		return -1
+	}
+	for i, mm := range b.Members {
+		if mm == m {
+			return i
+		}
+	}
+	return -1
+}
diff --git a/vendor/cloud.google.com/go/pubsub/apiv1/README.md b/vendor/cloud.google.com/go/pubsub/apiv1/README.md
new file mode 100644
index 0000000..b5967ab
--- /dev/null
+++ b/vendor/cloud.google.com/go/pubsub/apiv1/README.md
@@ -0,0 +1,9 @@
+Auto-generated pubsub v1 clients
+=================================
+
+This package includes auto-generated clients for the pubsub v1 API.
+
+Use the handwritten client (in the parent directory,
+cloud.google.com/go/pubsub) in preference to this.
+
+This code is EXPERIMENTAL and subject to CHANGE AT ANY TIME.
diff --git a/vendor/cloud.google.com/go/pubsub/apiv1/doc.go b/vendor/cloud.google.com/go/pubsub/apiv1/doc.go
new file mode 100644
index 0000000..8945cfa
--- /dev/null
+++ b/vendor/cloud.google.com/go/pubsub/apiv1/doc.go
@@ -0,0 +1,50 @@
+// Copyright 2017, Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+// Package pubsub is an auto-generated package for the
+// Google Cloud Pub/Sub API.
+//
+//   NOTE: This package is in alpha. It is not stable, and is likely to be subject to changes.
+//
+// Provides reliable, many-to-many, asynchronous messaging between
+// applications.
+//
+// Use the client at cloud.google.com/go/pubsub in preference to this.
+package pubsub
+
+import (
+	"golang.org/x/net/context"
+	"google.golang.org/grpc/metadata"
+)
+
+func insertMetadata(ctx context.Context, mds ...metadata.MD) context.Context {
+	out, _ := metadata.FromOutgoingContext(ctx)
+	out = out.Copy()
+	for _, md := range mds {
+		for k, v := range md {
+			out[k] = append(out[k], v...)
+		}
+	}
+	return metadata.NewOutgoingContext(ctx, out)
+}
+
+// DefaultAuthScopes reports the default set of authentication scopes to use with this package.
+func DefaultAuthScopes() []string {
+	return []string{
+		"https://www.googleapis.com/auth/cloud-platform",
+		"https://www.googleapis.com/auth/pubsub",
+	}
+}
diff --git a/vendor/cloud.google.com/go/pubsub/apiv1/publisher_client.go b/vendor/cloud.google.com/go/pubsub/apiv1/publisher_client.go
new file mode 100644
index 0000000..6088dac
--- /dev/null
+++ b/vendor/cloud.google.com/go/pubsub/apiv1/publisher_client.go
@@ -0,0 +1,416 @@
+// Copyright 2017, Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+package pubsub
+
+import (
+	"math"
+	"time"
+
+	"cloud.google.com/go/iam"
+	"cloud.google.com/go/internal/version"
+	gax "github.com/googleapis/gax-go"
+	"golang.org/x/net/context"
+	"google.golang.org/api/iterator"
+	"google.golang.org/api/option"
+	"google.golang.org/api/transport"
+	pubsubpb "google.golang.org/genproto/googleapis/pubsub/v1"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/metadata"
+)
+
+// PublisherCallOptions contains the retry settings for each method of PublisherClient.
+type PublisherCallOptions struct {
+	CreateTopic            []gax.CallOption
+	UpdateTopic            []gax.CallOption
+	Publish                []gax.CallOption
+	GetTopic               []gax.CallOption
+	ListTopics             []gax.CallOption
+	ListTopicSubscriptions []gax.CallOption
+	DeleteTopic            []gax.CallOption
+}
+
+func defaultPublisherClientOptions() []option.ClientOption {
+	return []option.ClientOption{
+		option.WithEndpoint("pubsub.googleapis.com:443"),
+		option.WithScopes(DefaultAuthScopes()...),
+	}
+}
+
+func defaultPublisherCallOptions() *PublisherCallOptions {
+	retry := map[[2]string][]gax.CallOption{
+		{"default", "idempotent"}: {
+			gax.WithRetry(func() gax.Retryer {
+				return gax.OnCodes([]codes.Code{
+					codes.DeadlineExceeded,
+					codes.Unavailable,
+				}, gax.Backoff{
+					Initial:    100 * time.Millisecond,
+					Max:        60000 * time.Millisecond,
+					Multiplier: 1.3,
+				})
+			}),
+		},
+		{"messaging", "one_plus_delivery"}: {
+			gax.WithRetry(func() gax.Retryer {
+				return gax.OnCodes([]codes.Code{
+					codes.Aborted,
+					codes.Canceled,
+					codes.DeadlineExceeded,
+					codes.Internal,
+					codes.ResourceExhausted,
+					codes.Unavailable,
+					codes.Unknown,
+				}, gax.Backoff{
+					Initial:    100 * time.Millisecond,
+					Max:        60000 * time.Millisecond,
+					Multiplier: 1.3,
+				})
+			}),
+		},
+	}
+	return &PublisherCallOptions{
+		CreateTopic:            retry[[2]string{"default", "idempotent"}],
+		UpdateTopic:            retry[[2]string{"default", "idempotent"}],
+		Publish:                retry[[2]string{"messaging", "one_plus_delivery"}],
+		GetTopic:               retry[[2]string{"default", "idempotent"}],
+		ListTopics:             retry[[2]string{"default", "idempotent"}],
+		ListTopicSubscriptions: retry[[2]string{"default", "idempotent"}],
+		DeleteTopic:            retry[[2]string{"default", "idempotent"}],
+	}
+}
+
+// PublisherClient is a client for interacting with Google Cloud Pub/Sub API.
+type PublisherClient struct {
+	// The connection to the service.
+	conn *grpc.ClientConn
+
+	// The gRPC API client.
+	publisherClient pubsubpb.PublisherClient
+
+	// The call options for this service.
+	CallOptions *PublisherCallOptions
+
+	// The metadata to be sent with each request.
+	Metadata metadata.MD
+}
+
+// NewPublisherClient creates a new publisher client.
+//
+// The service that an application uses to manipulate topics, and to send
+// messages to a topic.
+func NewPublisherClient(ctx context.Context, opts ...option.ClientOption) (*PublisherClient, error) {
+	conn, err := transport.DialGRPC(ctx, append(defaultPublisherClientOptions(), opts...)...)
+	if err != nil {
+		return nil, err
+	}
+	c := &PublisherClient{
+		conn:        conn,
+		CallOptions: defaultPublisherCallOptions(),
+
+		publisherClient: pubsubpb.NewPublisherClient(conn),
+	}
+	c.SetGoogleClientInfo()
+	return c, nil
+}
+
+// Connection returns the client's connection to the API service.
+func (c *PublisherClient) Connection() *grpc.ClientConn {
+	return c.conn
+}
+
+// Close closes the connection to the API service. The user should invoke this when
+// the client is no longer required.
+func (c *PublisherClient) Close() error {
+	return c.conn.Close()
+}
+
+// SetGoogleClientInfo sets the name and version of the application in
+// the `x-goog-api-client` header passed on each request. Intended for
+// use by Google-written clients.
+func (c *PublisherClient) SetGoogleClientInfo(keyval ...string) {
+	kv := append([]string{"gl-go", version.Go()}, keyval...)
+	kv = append(kv, "gapic", version.Repo, "gax", gax.Version, "grpc", grpc.Version)
+	c.Metadata = metadata.Pairs("x-goog-api-client", gax.XGoogHeader(kv...))
+}
+
+// PublisherProjectPath returns the path for the project resource.
+func PublisherProjectPath(project string) string {
+	return "" +
+		"projects/" +
+		project +
+		""
+}
+
+// PublisherTopicPath returns the path for the topic resource.
+func PublisherTopicPath(project, topic string) string {
+	return "" +
+		"projects/" +
+		project +
+		"/topics/" +
+		topic +
+		""
+}
+
+func (c *PublisherClient) SubscriptionIAM(subscription *pubsubpb.Subscription) *iam.Handle {
+	return iam.InternalNewHandle(c.Connection(), subscription.Name)
+}
+
+func (c *PublisherClient) TopicIAM(topic *pubsubpb.Topic) *iam.Handle {
+	return iam.InternalNewHandle(c.Connection(), topic.Name)
+}
+
+// CreateTopic creates the given topic with the given name.
+func (c *PublisherClient) CreateTopic(ctx context.Context, req *pubsubpb.Topic, opts ...gax.CallOption) (*pubsubpb.Topic, error) {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.CreateTopic[0:len(c.CallOptions.CreateTopic):len(c.CallOptions.CreateTopic)], opts...)
+	var resp *pubsubpb.Topic
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.publisherClient.CreateTopic(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// UpdateTopic updates an existing topic. Note that certain properties of a topic are not
+// modifiable.  Options settings follow the style guide:
+// NOTE:  The style guide requires body: "topic" instead of body: "*".
+// Keeping the latter for internal consistency in V1, however it should be
+// corrected in V2.  See
+// https://cloud.google.com/apis/design/standard_methods#update for details.
+func (c *PublisherClient) UpdateTopic(ctx context.Context, req *pubsubpb.UpdateTopicRequest, opts ...gax.CallOption) (*pubsubpb.Topic, error) {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.UpdateTopic[0:len(c.CallOptions.UpdateTopic):len(c.CallOptions.UpdateTopic)], opts...)
+	var resp *pubsubpb.Topic
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.publisherClient.UpdateTopic(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// Publish adds one or more messages to the topic. Returns NOT_FOUND if the topic
+// does not exist. The message payload must not be empty; it must contain
+// either a non-empty data field, or at least one attribute.
+func (c *PublisherClient) Publish(ctx context.Context, req *pubsubpb.PublishRequest, opts ...gax.CallOption) (*pubsubpb.PublishResponse, error) {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.Publish[0:len(c.CallOptions.Publish):len(c.CallOptions.Publish)], opts...)
+	var resp *pubsubpb.PublishResponse
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.publisherClient.Publish(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// GetTopic gets the configuration of a topic.
+func (c *PublisherClient) GetTopic(ctx context.Context, req *pubsubpb.GetTopicRequest, opts ...gax.CallOption) (*pubsubpb.Topic, error) {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.GetTopic[0:len(c.CallOptions.GetTopic):len(c.CallOptions.GetTopic)], opts...)
+	var resp *pubsubpb.Topic
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.publisherClient.GetTopic(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// ListTopics lists matching topics.
+func (c *PublisherClient) ListTopics(ctx context.Context, req *pubsubpb.ListTopicsRequest, opts ...gax.CallOption) *TopicIterator {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.ListTopics[0:len(c.CallOptions.ListTopics):len(c.CallOptions.ListTopics)], opts...)
+	it := &TopicIterator{}
+	it.InternalFetch = func(pageSize int, pageToken string) ([]*pubsubpb.Topic, string, error) {
+		var resp *pubsubpb.ListTopicsResponse
+		req.PageToken = pageToken
+		if pageSize > math.MaxInt32 {
+			req.PageSize = math.MaxInt32
+		} else {
+			req.PageSize = int32(pageSize)
+		}
+		err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+			var err error
+			resp, err = c.publisherClient.ListTopics(ctx, req, settings.GRPC...)
+			return err
+		}, opts...)
+		if err != nil {
+			return nil, "", err
+		}
+		return resp.Topics, resp.NextPageToken, nil
+	}
+	fetch := func(pageSize int, pageToken string) (string, error) {
+		items, nextPageToken, err := it.InternalFetch(pageSize, pageToken)
+		if err != nil {
+			return "", err
+		}
+		it.items = append(it.items, items...)
+		return nextPageToken, nil
+	}
+	it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf)
+	return it
+}
+
+// ListTopicSubscriptions lists the name of the subscriptions for this topic.
+func (c *PublisherClient) ListTopicSubscriptions(ctx context.Context, req *pubsubpb.ListTopicSubscriptionsRequest, opts ...gax.CallOption) *StringIterator {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.ListTopicSubscriptions[0:len(c.CallOptions.ListTopicSubscriptions):len(c.CallOptions.ListTopicSubscriptions)], opts...)
+	it := &StringIterator{}
+	it.InternalFetch = func(pageSize int, pageToken string) ([]string, string, error) {
+		var resp *pubsubpb.ListTopicSubscriptionsResponse
+		req.PageToken = pageToken
+		if pageSize > math.MaxInt32 {
+			req.PageSize = math.MaxInt32
+		} else {
+			req.PageSize = int32(pageSize)
+		}
+		err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+			var err error
+			resp, err = c.publisherClient.ListTopicSubscriptions(ctx, req, settings.GRPC...)
+			return err
+		}, opts...)
+		if err != nil {
+			return nil, "", err
+		}
+		return resp.Subscriptions, resp.NextPageToken, nil
+	}
+	fetch := func(pageSize int, pageToken string) (string, error) {
+		items, nextPageToken, err := it.InternalFetch(pageSize, pageToken)
+		if err != nil {
+			return "", err
+		}
+		it.items = append(it.items, items...)
+		return nextPageToken, nil
+	}
+	it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf)
+	return it
+}
+
+// DeleteTopic deletes the topic with the given name. Returns NOT_FOUND if the topic
+// does not exist. After a topic is deleted, a new topic may be created with
+// the same name; this is an entirely new topic with none of the old
+// configuration or subscriptions. Existing subscriptions to this topic are
+// not deleted, but their topic field is set to _deleted-topic_.
+func (c *PublisherClient) DeleteTopic(ctx context.Context, req *pubsubpb.DeleteTopicRequest, opts ...gax.CallOption) error {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.DeleteTopic[0:len(c.CallOptions.DeleteTopic):len(c.CallOptions.DeleteTopic)], opts...)
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		_, err = c.publisherClient.DeleteTopic(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	return err
+}
+
+// StringIterator manages a stream of string.
+type StringIterator struct {
+	items    []string
+	pageInfo *iterator.PageInfo
+	nextFunc func() error
+
+	// InternalFetch is for use by the Google Cloud Libraries only.
+	// It is not part of the stable interface of this package.
+	//
+	// InternalFetch returns results from a single call to the underlying RPC.
+	// The number of results is no greater than pageSize.
+	// If there are no more results, nextPageToken is empty and err is nil.
+	InternalFetch func(pageSize int, pageToken string) (results []string, nextPageToken string, err error)
+}
+
+// PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
+func (it *StringIterator) PageInfo() *iterator.PageInfo {
+	return it.pageInfo
+}
+
+// Next returns the next result. Its second return value is iterator.Done if there are no more
+// results. Once Next returns Done, all subsequent calls will return Done.
+func (it *StringIterator) Next() (string, error) {
+	var item string
+	if err := it.nextFunc(); err != nil {
+		return item, err
+	}
+	item = it.items[0]
+	it.items = it.items[1:]
+	return item, nil
+}
+
+func (it *StringIterator) bufLen() int {
+	return len(it.items)
+}
+
+func (it *StringIterator) takeBuf() interface{} {
+	b := it.items
+	it.items = nil
+	return b
+}
+
+// TopicIterator manages a stream of *pubsubpb.Topic.
+type TopicIterator struct {
+	items    []*pubsubpb.Topic
+	pageInfo *iterator.PageInfo
+	nextFunc func() error
+
+	// InternalFetch is for use by the Google Cloud Libraries only.
+	// It is not part of the stable interface of this package.
+	//
+	// InternalFetch returns results from a single call to the underlying RPC.
+	// The number of results is no greater than pageSize.
+	// If there are no more results, nextPageToken is empty and err is nil.
+	InternalFetch func(pageSize int, pageToken string) (results []*pubsubpb.Topic, nextPageToken string, err error)
+}
+
+// PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
+func (it *TopicIterator) PageInfo() *iterator.PageInfo {
+	return it.pageInfo
+}
+
+// Next returns the next result. Its second return value is iterator.Done if there are no more
+// results. Once Next returns Done, all subsequent calls will return Done.
+func (it *TopicIterator) Next() (*pubsubpb.Topic, error) {
+	var item *pubsubpb.Topic
+	if err := it.nextFunc(); err != nil {
+		return item, err
+	}
+	item = it.items[0]
+	it.items = it.items[1:]
+	return item, nil
+}
+
+func (it *TopicIterator) bufLen() int {
+	return len(it.items)
+}
+
+func (it *TopicIterator) takeBuf() interface{} {
+	b := it.items
+	it.items = nil
+	return b
+}
diff --git a/vendor/cloud.google.com/go/pubsub/apiv1/subscriber_client.go b/vendor/cloud.google.com/go/pubsub/apiv1/subscriber_client.go
new file mode 100644
index 0000000..574c07d
--- /dev/null
+++ b/vendor/cloud.google.com/go/pubsub/apiv1/subscriber_client.go
@@ -0,0 +1,631 @@
+// Copyright 2017, Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+package pubsub
+
+import (
+	"math"
+	"time"
+
+	"cloud.google.com/go/iam"
+	"cloud.google.com/go/internal/version"
+	gax "github.com/googleapis/gax-go"
+	"golang.org/x/net/context"
+	"google.golang.org/api/iterator"
+	"google.golang.org/api/option"
+	"google.golang.org/api/transport"
+	pubsubpb "google.golang.org/genproto/googleapis/pubsub/v1"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/metadata"
+)
+
+// SubscriberCallOptions contains the retry settings for each method of SubscriberClient.
+type SubscriberCallOptions struct {
+	CreateSubscription []gax.CallOption
+	GetSubscription    []gax.CallOption
+	UpdateSubscription []gax.CallOption
+	ListSubscriptions  []gax.CallOption
+	DeleteSubscription []gax.CallOption
+	ModifyAckDeadline  []gax.CallOption
+	Acknowledge        []gax.CallOption
+	Pull               []gax.CallOption
+	StreamingPull      []gax.CallOption
+	ModifyPushConfig   []gax.CallOption
+	ListSnapshots      []gax.CallOption
+	CreateSnapshot     []gax.CallOption
+	UpdateSnapshot     []gax.CallOption
+	DeleteSnapshot     []gax.CallOption
+	Seek               []gax.CallOption
+}
+
+func defaultSubscriberClientOptions() []option.ClientOption {
+	return []option.ClientOption{
+		option.WithEndpoint("pubsub.googleapis.com:443"),
+		option.WithScopes(DefaultAuthScopes()...),
+	}
+}
+
+func defaultSubscriberCallOptions() *SubscriberCallOptions {
+	retry := map[[2]string][]gax.CallOption{
+		{"default", "idempotent"}: {
+			gax.WithRetry(func() gax.Retryer {
+				return gax.OnCodes([]codes.Code{
+					codes.DeadlineExceeded,
+					codes.Unavailable,
+				}, gax.Backoff{
+					Initial:    100 * time.Millisecond,
+					Max:        60000 * time.Millisecond,
+					Multiplier: 1.3,
+				})
+			}),
+		},
+		{"messaging", "pull"}: {
+			gax.WithRetry(func() gax.Retryer {
+				return gax.OnCodes([]codes.Code{
+					codes.Canceled,
+					codes.DeadlineExceeded,
+					codes.Internal,
+					codes.ResourceExhausted,
+					codes.Unavailable,
+				}, gax.Backoff{
+					Initial:    100 * time.Millisecond,
+					Max:        60000 * time.Millisecond,
+					Multiplier: 1.3,
+				})
+			}),
+		},
+		{"streaming_messaging", "pull"}: {
+			gax.WithRetry(func() gax.Retryer {
+				return gax.OnCodes([]codes.Code{
+					codes.Canceled,
+					codes.DeadlineExceeded,
+					codes.Internal,
+					codes.ResourceExhausted,
+					codes.Unavailable,
+				}, gax.Backoff{
+					Initial:    100 * time.Millisecond,
+					Max:        60000 * time.Millisecond,
+					Multiplier: 1.3,
+				})
+			}),
+		},
+	}
+	return &SubscriberCallOptions{
+		CreateSubscription: retry[[2]string{"default", "idempotent"}],
+		GetSubscription:    retry[[2]string{"default", "idempotent"}],
+		UpdateSubscription: retry[[2]string{"default", "idempotent"}],
+		ListSubscriptions:  retry[[2]string{"default", "idempotent"}],
+		DeleteSubscription: retry[[2]string{"default", "idempotent"}],
+		ModifyAckDeadline:  retry[[2]string{"default", "non_idempotent"}],
+		Acknowledge:        retry[[2]string{"messaging", "non_idempotent"}],
+		Pull:               retry[[2]string{"messaging", "pull"}],
+		StreamingPull:      retry[[2]string{"streaming_messaging", "pull"}],
+		ModifyPushConfig:   retry[[2]string{"default", "non_idempotent"}],
+		ListSnapshots:      retry[[2]string{"default", "idempotent"}],
+		CreateSnapshot:     retry[[2]string{"default", "idempotent"}],
+		UpdateSnapshot:     retry[[2]string{"default", "idempotent"}],
+		DeleteSnapshot:     retry[[2]string{"default", "idempotent"}],
+		Seek:               retry[[2]string{"default", "non_idempotent"}],
+	}
+}
+
+// SubscriberClient is a client for interacting with Google Cloud Pub/Sub API.
+type SubscriberClient struct {
+	// The connection to the service.
+	conn *grpc.ClientConn
+
+	// The gRPC API client.
+	subscriberClient pubsubpb.SubscriberClient
+
+	// The call options for this service.
+	CallOptions *SubscriberCallOptions
+
+	// The metadata to be sent with each request.
+	Metadata metadata.MD
+}
+
+// NewSubscriberClient creates a new subscriber client.
+//
+// The service that an application uses to manipulate subscriptions and to
+// consume messages from a subscription via the Pull method.
+func NewSubscriberClient(ctx context.Context, opts ...option.ClientOption) (*SubscriberClient, error) {
+	conn, err := transport.DialGRPC(ctx, append(defaultSubscriberClientOptions(), opts...)...)
+	if err != nil {
+		return nil, err
+	}
+	c := &SubscriberClient{
+		conn:        conn,
+		CallOptions: defaultSubscriberCallOptions(),
+
+		subscriberClient: pubsubpb.NewSubscriberClient(conn),
+	}
+	c.SetGoogleClientInfo()
+	return c, nil
+}
+
+// Connection returns the client's connection to the API service.
+func (c *SubscriberClient) Connection() *grpc.ClientConn {
+	return c.conn
+}
+
+// Close closes the connection to the API service. The user should invoke this when
+// the client is no longer required.
+func (c *SubscriberClient) Close() error {
+	return c.conn.Close()
+}
+
+// SetGoogleClientInfo sets the name and version of the application in
+// the `x-goog-api-client` header passed on each request. Intended for
+// use by Google-written clients.
+func (c *SubscriberClient) SetGoogleClientInfo(keyval ...string) {
+	kv := append([]string{"gl-go", version.Go()}, keyval...)
+	kv = append(kv, "gapic", version.Repo, "gax", gax.Version, "grpc", grpc.Version)
+	c.Metadata = metadata.Pairs("x-goog-api-client", gax.XGoogHeader(kv...))
+}
+
+// SubscriberProjectPath returns the path for the project resource.
+func SubscriberProjectPath(project string) string {
+	return "" +
+		"projects/" +
+		project +
+		""
+}
+
+// SubscriberSnapshotPath returns the path for the snapshot resource.
+func SubscriberSnapshotPath(project, snapshot string) string {
+	return "" +
+		"projects/" +
+		project +
+		"/snapshots/" +
+		snapshot +
+		""
+}
+
+// SubscriberSubscriptionPath returns the path for the subscription resource.
+func SubscriberSubscriptionPath(project, subscription string) string {
+	return "" +
+		"projects/" +
+		project +
+		"/subscriptions/" +
+		subscription +
+		""
+}
+
+// SubscriberTopicPath returns the path for the topic resource.
+func SubscriberTopicPath(project, topic string) string {
+	return "" +
+		"projects/" +
+		project +
+		"/topics/" +
+		topic +
+		""
+}
+
+func (c *SubscriberClient) SubscriptionIAM(subscription *pubsubpb.Subscription) *iam.Handle {
+	return iam.InternalNewHandle(c.Connection(), subscription.Name)
+}
+
+func (c *SubscriberClient) TopicIAM(topic *pubsubpb.Topic) *iam.Handle {
+	return iam.InternalNewHandle(c.Connection(), topic.Name)
+}
+
+// CreateSubscription creates a subscription to a given topic.
+// If the subscription already exists, returns ALREADY_EXISTS.
+// If the corresponding topic doesn't exist, returns NOT_FOUND.
+//
+// If the name is not provided in the request, the server will assign a random
+// name for this subscription on the same project as the topic, conforming
+// to the
+// resource name format (at https://cloud.google.com/pubsub/docs/overview#names).
+// The generated name is populated in the returned Subscription object.
+// Note that for REST API requests, you must specify a name in the request.
+func (c *SubscriberClient) CreateSubscription(ctx context.Context, req *pubsubpb.Subscription, opts ...gax.CallOption) (*pubsubpb.Subscription, error) {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.CreateSubscription[0:len(c.CallOptions.CreateSubscription):len(c.CallOptions.CreateSubscription)], opts...)
+	var resp *pubsubpb.Subscription
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.subscriberClient.CreateSubscription(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// GetSubscription gets the configuration details of a subscription.
+func (c *SubscriberClient) GetSubscription(ctx context.Context, req *pubsubpb.GetSubscriptionRequest, opts ...gax.CallOption) (*pubsubpb.Subscription, error) {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.GetSubscription[0:len(c.CallOptions.GetSubscription):len(c.CallOptions.GetSubscription)], opts...)
+	var resp *pubsubpb.Subscription
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.subscriberClient.GetSubscription(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// UpdateSubscription updates an existing subscription. Note that certain properties of a
+// subscription, such as its topic, are not modifiable.
+// NOTE:  The style guide requires body: "subscription" instead of body: "*".
+// Keeping the latter for internal consistency in V1, however it should be
+// corrected in V2.  See
+// https://cloud.google.com/apis/design/standard_methods#update for details.
+func (c *SubscriberClient) UpdateSubscription(ctx context.Context, req *pubsubpb.UpdateSubscriptionRequest, opts ...gax.CallOption) (*pubsubpb.Subscription, error) {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.UpdateSubscription[0:len(c.CallOptions.UpdateSubscription):len(c.CallOptions.UpdateSubscription)], opts...)
+	var resp *pubsubpb.Subscription
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.subscriberClient.UpdateSubscription(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// ListSubscriptions lists matching subscriptions.
+func (c *SubscriberClient) ListSubscriptions(ctx context.Context, req *pubsubpb.ListSubscriptionsRequest, opts ...gax.CallOption) *SubscriptionIterator {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.ListSubscriptions[0:len(c.CallOptions.ListSubscriptions):len(c.CallOptions.ListSubscriptions)], opts...)
+	it := &SubscriptionIterator{}
+	it.InternalFetch = func(pageSize int, pageToken string) ([]*pubsubpb.Subscription, string, error) {
+		var resp *pubsubpb.ListSubscriptionsResponse
+		req.PageToken = pageToken
+		if pageSize > math.MaxInt32 {
+			req.PageSize = math.MaxInt32
+		} else {
+			req.PageSize = int32(pageSize)
+		}
+		err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+			var err error
+			resp, err = c.subscriberClient.ListSubscriptions(ctx, req, settings.GRPC...)
+			return err
+		}, opts...)
+		if err != nil {
+			return nil, "", err
+		}
+		return resp.Subscriptions, resp.NextPageToken, nil
+	}
+	fetch := func(pageSize int, pageToken string) (string, error) {
+		items, nextPageToken, err := it.InternalFetch(pageSize, pageToken)
+		if err != nil {
+			return "", err
+		}
+		it.items = append(it.items, items...)
+		return nextPageToken, nil
+	}
+	it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf)
+	return it
+}
+
+// DeleteSubscription deletes an existing subscription. All messages retained in the subscription
+// are immediately dropped. Calls to Pull after deletion will return
+// NOT_FOUND. After a subscription is deleted, a new one may be created with
+// the same name, but the new one has no association with the old
+// subscription or its topic unless the same topic is specified.
+func (c *SubscriberClient) DeleteSubscription(ctx context.Context, req *pubsubpb.DeleteSubscriptionRequest, opts ...gax.CallOption) error {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.DeleteSubscription[0:len(c.CallOptions.DeleteSubscription):len(c.CallOptions.DeleteSubscription)], opts...)
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		_, err = c.subscriberClient.DeleteSubscription(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	return err
+}
+
+// ModifyAckDeadline modifies the ack deadline for a specific message. This method is useful
+// to indicate that more time is needed to process a message by the
+// subscriber, or to make the message available for redelivery if the
+// processing was interrupted. Note that this does not modify the
+// subscription-level ackDeadlineSeconds used for subsequent messages.
+func (c *SubscriberClient) ModifyAckDeadline(ctx context.Context, req *pubsubpb.ModifyAckDeadlineRequest, opts ...gax.CallOption) error {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.ModifyAckDeadline[0:len(c.CallOptions.ModifyAckDeadline):len(c.CallOptions.ModifyAckDeadline)], opts...)
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		_, err = c.subscriberClient.ModifyAckDeadline(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	return err
+}
+
+// Acknowledge acknowledges the messages associated with the ack_ids in the
+// AcknowledgeRequest. The Pub/Sub system can remove the relevant messages
+// from the subscription.
+//
+// Acknowledging a message whose ack deadline has expired may succeed,
+// but such a message may be redelivered later. Acknowledging a message more
+// than once will not result in an error.
+func (c *SubscriberClient) Acknowledge(ctx context.Context, req *pubsubpb.AcknowledgeRequest, opts ...gax.CallOption) error {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.Acknowledge[0:len(c.CallOptions.Acknowledge):len(c.CallOptions.Acknowledge)], opts...)
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		_, err = c.subscriberClient.Acknowledge(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	return err
+}
+
+// Pull pulls messages from the server. Returns an empty list if there are no
+// messages available in the backlog. The server may return UNAVAILABLE if
+// there are too many concurrent pull requests pending for the given
+// subscription.
+func (c *SubscriberClient) Pull(ctx context.Context, req *pubsubpb.PullRequest, opts ...gax.CallOption) (*pubsubpb.PullResponse, error) {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.Pull[0:len(c.CallOptions.Pull):len(c.CallOptions.Pull)], opts...)
+	var resp *pubsubpb.PullResponse
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.subscriberClient.Pull(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// StreamingPull (EXPERIMENTAL) StreamingPull is an experimental feature. This RPC will
+// respond with UNIMPLEMENTED errors unless you have been invited to test
+// this feature. Contact cloud-pubsub@google.com with any questions.
+//
+// Establishes a stream with the server, which sends messages down to the
+// client. The client streams acknowledgements and ack deadline modifications
+// back to the server. The server will close the stream and return the status
+// on any error. The server may close the stream with status OK to reassign
+// server-side resources, in which case, the client should re-establish the
+// stream. UNAVAILABLE may also be returned in the case of a transient error
+// (e.g., a server restart). These should also be retried by the client. Flow
+// control can be achieved by configuring the underlying RPC channel.
+func (c *SubscriberClient) StreamingPull(ctx context.Context, opts ...gax.CallOption) (pubsubpb.Subscriber_StreamingPullClient, error) {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.StreamingPull[0:len(c.CallOptions.StreamingPull):len(c.CallOptions.StreamingPull)], opts...)
+	var resp pubsubpb.Subscriber_StreamingPullClient
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.subscriberClient.StreamingPull(ctx, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// ModifyPushConfig modifies the PushConfig for a specified subscription.
+//
+// This may be used to change a push subscription to a pull one (signified by
+// an empty PushConfig) or vice versa, or change the endpoint URL and other
+// attributes of a push subscription. Messages will accumulate for delivery
+// continuously through the call regardless of changes to the PushConfig.
+func (c *SubscriberClient) ModifyPushConfig(ctx context.Context, req *pubsubpb.ModifyPushConfigRequest, opts ...gax.CallOption) error {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.ModifyPushConfig[0:len(c.CallOptions.ModifyPushConfig):len(c.CallOptions.ModifyPushConfig)], opts...)
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		_, err = c.subscriberClient.ModifyPushConfig(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	return err
+}
+
+// ListSnapshots lists the existing snapshots.
+func (c *SubscriberClient) ListSnapshots(ctx context.Context, req *pubsubpb.ListSnapshotsRequest, opts ...gax.CallOption) *SnapshotIterator {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.ListSnapshots[0:len(c.CallOptions.ListSnapshots):len(c.CallOptions.ListSnapshots)], opts...)
+	it := &SnapshotIterator{}
+	it.InternalFetch = func(pageSize int, pageToken string) ([]*pubsubpb.Snapshot, string, error) {
+		var resp *pubsubpb.ListSnapshotsResponse
+		req.PageToken = pageToken
+		if pageSize > math.MaxInt32 {
+			req.PageSize = math.MaxInt32
+		} else {
+			req.PageSize = int32(pageSize)
+		}
+		err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+			var err error
+			resp, err = c.subscriberClient.ListSnapshots(ctx, req, settings.GRPC...)
+			return err
+		}, opts...)
+		if err != nil {
+			return nil, "", err
+		}
+		return resp.Snapshots, resp.NextPageToken, nil
+	}
+	fetch := func(pageSize int, pageToken string) (string, error) {
+		items, nextPageToken, err := it.InternalFetch(pageSize, pageToken)
+		if err != nil {
+			return "", err
+		}
+		it.items = append(it.items, items...)
+		return nextPageToken, nil
+	}
+	it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf)
+	return it
+}
+
+// CreateSnapshot creates a snapshot from the requested subscription.
+// If the snapshot already exists, returns ALREADY_EXISTS.
+// If the requested subscription doesn't exist, returns NOT_FOUND.
+//
+// If the name is not provided in the request, the server will assign a random
+// name for this snapshot on the same project as the subscription, conforming
+// to the
+// resource name format (at https://cloud.google.com/pubsub/docs/overview#names).
+// The generated name is populated in the returned Snapshot object.
+// Note that for REST API requests, you must specify a name in the request.
+func (c *SubscriberClient) CreateSnapshot(ctx context.Context, req *pubsubpb.CreateSnapshotRequest, opts ...gax.CallOption) (*pubsubpb.Snapshot, error) {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.CreateSnapshot[0:len(c.CallOptions.CreateSnapshot):len(c.CallOptions.CreateSnapshot)], opts...)
+	var resp *pubsubpb.Snapshot
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.subscriberClient.CreateSnapshot(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// UpdateSnapshot updates an existing snapshot. Note that certain properties of a snapshot
+// are not modifiable.
+// NOTE:  The style guide requires body: "snapshot" instead of body: "*".
+// Keeping the latter for internal consistency in V1, however it should be
+// corrected in V2.  See
+// https://cloud.google.com/apis/design/standard_methods#update for details.
+func (c *SubscriberClient) UpdateSnapshot(ctx context.Context, req *pubsubpb.UpdateSnapshotRequest, opts ...gax.CallOption) (*pubsubpb.Snapshot, error) {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.UpdateSnapshot[0:len(c.CallOptions.UpdateSnapshot):len(c.CallOptions.UpdateSnapshot)], opts...)
+	var resp *pubsubpb.Snapshot
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.subscriberClient.UpdateSnapshot(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// DeleteSnapshot removes an existing snapshot. All messages retained in the snapshot
+// are immediately dropped. After a snapshot is deleted, a new one may be
+// created with the same name, but the new one has no association with the old
+// snapshot or its subscription, unless the same subscription is specified.
+func (c *SubscriberClient) DeleteSnapshot(ctx context.Context, req *pubsubpb.DeleteSnapshotRequest, opts ...gax.CallOption) error {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.DeleteSnapshot[0:len(c.CallOptions.DeleteSnapshot):len(c.CallOptions.DeleteSnapshot)], opts...)
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		_, err = c.subscriberClient.DeleteSnapshot(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	return err
+}
+
+// Seek seeks an existing subscription to a point in time or to a given snapshot,
+// whichever is provided in the request.
+func (c *SubscriberClient) Seek(ctx context.Context, req *pubsubpb.SeekRequest, opts ...gax.CallOption) (*pubsubpb.SeekResponse, error) {
+	ctx = insertMetadata(ctx, c.Metadata)
+	opts = append(c.CallOptions.Seek[0:len(c.CallOptions.Seek):len(c.CallOptions.Seek)], opts...)
+	var resp *pubsubpb.SeekResponse
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.subscriberClient.Seek(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// SnapshotIterator manages a stream of *pubsubpb.Snapshot.
+type SnapshotIterator struct {
+	items    []*pubsubpb.Snapshot
+	pageInfo *iterator.PageInfo
+	nextFunc func() error
+
+	// InternalFetch is for use by the Google Cloud Libraries only.
+	// It is not part of the stable interface of this package.
+	//
+	// InternalFetch returns results from a single call to the underlying RPC.
+	// The number of results is no greater than pageSize.
+	// If there are no more results, nextPageToken is empty and err is nil.
+	InternalFetch func(pageSize int, pageToken string) (results []*pubsubpb.Snapshot, nextPageToken string, err error)
+}
+
+// PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
+func (it *SnapshotIterator) PageInfo() *iterator.PageInfo {
+	return it.pageInfo
+}
+
+// Next returns the next result. Its second return value is iterator.Done if there are no more
+// results. Once Next returns Done, all subsequent calls will return Done.
+func (it *SnapshotIterator) Next() (*pubsubpb.Snapshot, error) {
+	var item *pubsubpb.Snapshot
+	if err := it.nextFunc(); err != nil {
+		return item, err
+	}
+	item = it.items[0]
+	it.items = it.items[1:]
+	return item, nil
+}
+
+func (it *SnapshotIterator) bufLen() int {
+	return len(it.items)
+}
+
+func (it *SnapshotIterator) takeBuf() interface{} {
+	b := it.items
+	it.items = nil
+	return b
+}
+
+// SubscriptionIterator manages a stream of *pubsubpb.Subscription.
+type SubscriptionIterator struct {
+	items    []*pubsubpb.Subscription
+	pageInfo *iterator.PageInfo
+	nextFunc func() error
+
+	// InternalFetch is for use by the Google Cloud Libraries only.
+	// It is not part of the stable interface of this package.
+	//
+	// InternalFetch returns results from a single call to the underlying RPC.
+	// The number of results is no greater than pageSize.
+	// If there are no more results, nextPageToken is empty and err is nil.
+	InternalFetch func(pageSize int, pageToken string) (results []*pubsubpb.Subscription, nextPageToken string, err error)
+}
+
+// PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
+func (it *SubscriptionIterator) PageInfo() *iterator.PageInfo {
+	return it.pageInfo
+}
+
+// Next returns the next result. Its second return value is iterator.Done if there are no more
+// results. Once Next returns Done, all subsequent calls will return Done.
+func (it *SubscriptionIterator) Next() (*pubsubpb.Subscription, error) {
+	var item *pubsubpb.Subscription
+	if err := it.nextFunc(); err != nil {
+		return item, err
+	}
+	item = it.items[0]
+	it.items = it.items[1:]
+	return item, nil
+}
+
+func (it *SubscriptionIterator) bufLen() int {
+	return len(it.items)
+}
+
+func (it *SubscriptionIterator) takeBuf() interface{} {
+	b := it.items
+	it.items = nil
+	return b
+}
diff --git a/vendor/cloud.google.com/go/pubsub/doc.go b/vendor/cloud.google.com/go/pubsub/doc.go
new file mode 100644
index 0000000..3349f07
--- /dev/null
+++ b/vendor/cloud.google.com/go/pubsub/doc.go
@@ -0,0 +1,120 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/*
+Package pubsub provides an easy way to publish and receive Google Cloud Pub/Sub
+messages, hiding the the details of the underlying server RPCs.  Google Cloud
+Pub/Sub is a many-to-many, asynchronous messaging system that decouples senders
+and receivers.
+
+Note: This package is in beta. Some backwards-incompatible changes may occur.
+
+More information about Google Cloud Pub/Sub is available at
+https://cloud.google.com/pubsub/docs
+
+Publishing
+
+Google Cloud Pub/Sub messages are published to topics. Topics may be created
+using the pubsub package like so:
+
+ topic, err := pubsubClient.CreateTopic(context.Background(), "topic-name")
+
+Messages may then be published to a topic:
+
+ res := topic.Publish(ctx, &pubsub.Message{Data: []byte("payload")})
+
+Publish queues the message for publishing and returns immediately. When enough
+messages have accumulated, or enough time has elapsed, the batch of messages is
+sent to the Pub/Sub service.
+
+Publish returns a PublishResult, which behaves like a future: its Get method
+blocks until the message has been sent to the service.
+
+The first time you call Publish on a topic, goroutines are started in the
+background. To clean up these goroutines, call Stop:
+
+  topic.Stop()
+
+Receiving
+
+To receive messages published to a topic, clients create subscriptions
+to the topic. There may be more than one subscription per topic; each message
+that is published to the topic will be delivered to all of its subscriptions.
+
+Subsciptions may be created like so:
+
+ sub, err := pubsubClient.CreateSubscription(context.Background(), "sub-name",
+	pubsub.SubscriptionConfig{Topic: topic})
+
+Messages are then consumed from a subscription via callback.
+
+ err := sub.Receive(context.Background(), func(ctx context.Context, m *Message) {
+ 	log.Printf("Got message: %s", m.Data)
+ 	m.Ack()
+ })
+ if err != nil {
+	// Handle error.
+ }
+
+The callback is invoked concurrently by multiple goroutines, maximizing
+throughput. To terminate a call to Receive, cancel its context.
+
+Once client code has processed the message, it must call Message.Ack, otherwise
+the message will eventually be redelivered. As an optimization, if the client
+cannot or doesn't want to process the message, it can call Message.Nack to
+speed redelivery. For more information and configuration options, see
+"Deadlines" below.
+
+Note: It is possible for Messages to be redelivered, even if Message.Ack has
+been called. Client code must be robust to multiple deliveries of messages.
+
+Deadlines
+
+The default pubsub deadlines are suitable for most use cases, but may be
+overridden.  This section describes the tradeoffs that should be considered
+when overriding the defaults.
+
+Behind the scenes, each message returned by the Pub/Sub server has an
+associated lease, known as an "ACK deadline".
+Unless a message is acknowledged within the ACK deadline, or the client requests that
+the ACK deadline be extended, the message will become elegible for redelivery.
+As a convenience, the pubsub package will automatically extend deadlines until
+either:
+ * Message.Ack or Message.Nack is called, or
+ * the "MaxExtension" period elapses from the time the message is fetched from the server.
+
+The initial ACK deadline given to each messages defaults to 10 seconds, but may
+be overridden during subscription creation.  Selecting an ACK deadline is a
+tradeoff between message redelivery latency and RPC volume. If the pubsub
+package fails to acknowledge or extend a message (e.g. due to unexpected
+termination of the process), a shorter ACK deadline will generally result in
+faster message redelivery by the Pub/Sub system. However, a short ACK deadline
+may also increase the number of deadline extension RPCs that the pubsub package
+sends to the server.
+
+The default max extension period is DefaultReceiveSettings.MaxExtension, and can
+be overridden by setting Subscription.ReceiveSettings.MaxExtension. Selecting a
+max extension period is a tradeoff between the speed at which client code must
+process messages, and the redelivery delay if messages fail to be acknowledged
+(e.g. because client code neglects to do so). Using a large MaxExtension
+increases the available time for client code to process messages. However, if
+the client code neglects to call Message.Ack/Nack, a large MaxExtension will
+increase the delay before the message is redelivered.
+
+Authentication
+
+See examples of authorization and authentication at
+https://godoc.org/cloud.google.com/go#pkg-examples.
+*/
+package pubsub
diff --git a/vendor/cloud.google.com/go/pubsub/flow_controller.go b/vendor/cloud.google.com/go/pubsub/flow_controller.go
new file mode 100644
index 0000000..0fd7bd6
--- /dev/null
+++ b/vendor/cloud.google.com/go/pubsub/flow_controller.go
@@ -0,0 +1,106 @@
+// Copyright 2017 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pubsub
+
+import (
+	"golang.org/x/net/context"
+	"golang.org/x/sync/semaphore"
+)
+
+// flowController implements flow control for Subscription.Receive.
+type flowController struct {
+	maxSize           int                 // max total size of messages
+	semCount, semSize *semaphore.Weighted // enforces max number and size of messages
+}
+
+// newFlowController creates a new flowController that ensures no more than
+// maxCount messages or maxSize bytes are outstanding at once. If maxCount or
+// maxSize is < 1, then an unlimited number of messages or bytes is permitted,
+// respectively.
+func newFlowController(maxCount, maxSize int) *flowController {
+	fc := &flowController{
+		maxSize:  maxSize,
+		semCount: nil,
+		semSize:  nil,
+	}
+	if maxCount > 0 {
+		fc.semCount = semaphore.NewWeighted(int64(maxCount))
+	}
+	if maxSize > 0 {
+		fc.semSize = semaphore.NewWeighted(int64(maxSize))
+	}
+	return fc
+}
+
+// acquire blocks until one message of size bytes can proceed or ctx is done.
+// It returns nil in the first case, or ctx.Err() in the second.
+//
+// acquire allows large messages to proceed by treating a size greater than maxSize
+// as if it were equal to maxSize.
+func (f *flowController) acquire(ctx context.Context, size int) error {
+	if f.semCount != nil {
+		if err := f.semCount.Acquire(ctx, 1); err != nil {
+			return err
+		}
+	}
+	if f.semSize != nil {
+		if err := f.semSize.Acquire(ctx, f.bound(size)); err != nil {
+			if f.semCount != nil {
+				f.semCount.Release(1)
+			}
+			return err
+		}
+	}
+	return nil
+}
+
+// tryAcquire returns false if acquire would block. Otherwise, it behaves like
+// acquire and returns true.
+//
+// tryAcquire allows large messages to proceed by treating a size greater than
+// maxSize as if it were equal to maxSize.
+func (f *flowController) tryAcquire(size int) bool {
+	if f.semCount != nil {
+		if !f.semCount.TryAcquire(1) {
+			return false
+		}
+	}
+	if f.semSize != nil {
+		if !f.semSize.TryAcquire(f.bound(size)) {
+			if f.semCount != nil {
+				f.semCount.Release(1)
+			}
+			return false
+		}
+	}
+	return true
+}
+
+// release notes that one message of size bytes is no longer outstanding.
+func (f *flowController) release(size int) {
+	if f.semCount != nil {
+		f.semCount.Release(1)
+	}
+	if f.semSize != nil {
+		f.semSize.Release(f.bound(size))
+	}
+}
+
+func (f *flowController) bound(size int) int64 {
+	if size > f.maxSize {
+		return int64(f.maxSize)
+	}
+	return int64(size)
+}
diff --git a/vendor/cloud.google.com/go/pubsub/iterator.go b/vendor/cloud.google.com/go/pubsub/iterator.go
new file mode 100644
index 0000000..12d1f07
--- /dev/null
+++ b/vendor/cloud.google.com/go/pubsub/iterator.go
@@ -0,0 +1,271 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pubsub
+
+import (
+	"sync"
+	"time"
+
+	"golang.org/x/net/context"
+	pb "google.golang.org/genproto/googleapis/pubsub/v1"
+)
+
+// newMessageIterator starts a new streamingMessageIterator.  Stop must be called on the messageIterator
+// when it is no longer needed.
+// subName is the full name of the subscription to pull messages from.
+// ctx is the context to use for acking messages and extending message deadlines.
+func newMessageIterator(ctx context.Context, s service, subName string, po *pullOptions) *streamingMessageIterator {
+	sp := s.newStreamingPuller(ctx, subName, int32(po.ackDeadline.Seconds()))
+	_ = sp.open() // error stored in sp
+	return newStreamingMessageIterator(ctx, sp, po)
+}
+
+type streamingMessageIterator struct {
+	ctx        context.Context
+	po         *pullOptions
+	sp         *streamingPuller
+	kaTicker   *time.Ticker  // keep-alive (deadline extensions)
+	ackTicker  *time.Ticker  // message acks
+	nackTicker *time.Ticker  // message nacks (more frequent than acks)
+	failed     chan struct{} // closed on stream error
+	stopped    chan struct{} // closed when Stop is called
+	drained    chan struct{} // closed when stopped && no more pending messages
+	wg         sync.WaitGroup
+
+	mu                 sync.Mutex
+	keepAliveDeadlines map[string]time.Time
+	pendingReq         *pb.StreamingPullRequest
+	err                error // error from stream failure
+}
+
+func newStreamingMessageIterator(ctx context.Context, sp *streamingPuller, po *pullOptions) *streamingMessageIterator {
+	// TODO: make kaTicker frequency more configurable. (ackDeadline - 5s) is a
+	// reasonable default for now, because the minimum ack period is 10s. This
+	// gives us 5s grace.
+	keepAlivePeriod := po.ackDeadline - 5*time.Second
+	kaTicker := time.NewTicker(keepAlivePeriod)
+
+	// Ack promptly so users don't lose work if client crashes.
+	ackTicker := time.NewTicker(100 * time.Millisecond)
+	nackTicker := time.NewTicker(100 * time.Millisecond)
+	it := &streamingMessageIterator{
+		ctx:                ctx,
+		sp:                 sp,
+		po:                 po,
+		kaTicker:           kaTicker,
+		ackTicker:          ackTicker,
+		nackTicker:         nackTicker,
+		failed:             make(chan struct{}),
+		stopped:            make(chan struct{}),
+		drained:            make(chan struct{}),
+		keepAliveDeadlines: map[string]time.Time{},
+		pendingReq:         &pb.StreamingPullRequest{},
+	}
+	it.wg.Add(1)
+	go it.sender()
+	return it
+}
+
+// Subscription.receive will call stop on its messageIterator when finished with it.
+// Stop will block until Done has been called on all Messages that have been
+// returned by Next, or until the context with which the messageIterator was created
+// is cancelled or exceeds its deadline.
+func (it *streamingMessageIterator) stop() {
+	it.mu.Lock()
+	select {
+	case <-it.stopped:
+	default:
+		close(it.stopped)
+	}
+	it.checkDrained()
+	it.mu.Unlock()
+	it.wg.Wait()
+}
+
+// checkDrained closes the drained channel if the iterator has been stopped and all
+// pending messages have either been n/acked or expired.
+//
+// Called with the lock held.
+func (it *streamingMessageIterator) checkDrained() {
+	select {
+	case <-it.drained:
+		return
+	default:
+	}
+	select {
+	case <-it.stopped:
+		if len(it.keepAliveDeadlines) == 0 {
+			close(it.drained)
+		}
+	default:
+	}
+}
+
+// Called when a message is acked/nacked.
+func (it *streamingMessageIterator) done(ackID string, ack bool) {
+	it.mu.Lock()
+	defer it.mu.Unlock()
+	delete(it.keepAliveDeadlines, ackID)
+	if ack {
+		it.pendingReq.AckIds = append(it.pendingReq.AckIds, ackID)
+	} else {
+		it.addDeadlineMod(ackID, 0) // Nack indicated by modifying the deadline to zero.
+	}
+	it.checkDrained()
+}
+
+// addDeadlineMod adds the ack ID to the pending request with the given deadline.
+//
+// Called with the lock held.
+func (it *streamingMessageIterator) addDeadlineMod(ackID string, deadlineSecs int32) {
+	pr := it.pendingReq
+	pr.ModifyDeadlineAckIds = append(pr.ModifyDeadlineAckIds, ackID)
+	pr.ModifyDeadlineSeconds = append(pr.ModifyDeadlineSeconds, deadlineSecs)
+}
+
+// fail is called when a stream method returns a permanent error.
+func (it *streamingMessageIterator) fail(err error) {
+	it.mu.Lock()
+	if it.err == nil {
+		it.err = err
+		close(it.failed)
+	}
+	it.mu.Unlock()
+}
+
+// receive makes a call to the stream's Recv method and returns
+// its messages.
+func (it *streamingMessageIterator) receive() ([]*Message, error) {
+	// Stop retrieving messages if the context is done, the stream
+	// failed, or the iterator's Stop method was called.
+	select {
+	case <-it.ctx.Done():
+		return nil, it.ctx.Err()
+	default:
+	}
+	it.mu.Lock()
+	err := it.err
+	it.mu.Unlock()
+	if err != nil {
+		return nil, err
+	}
+	// Receive messages from stream. This may block indefinitely.
+	msgs, err := it.sp.fetchMessages()
+	// The streamingPuller handles retries, so any error here
+	// is fatal.
+	if err != nil {
+		it.fail(err)
+		return nil, err
+	}
+	// We received some messages. Remember them so we can
+	// keep them alive.
+	deadline := time.Now().Add(it.po.maxExtension)
+	it.mu.Lock()
+	for _, m := range msgs {
+		m.doneFunc = it.done
+		it.keepAliveDeadlines[m.ackID] = deadline
+	}
+	it.mu.Unlock()
+	return msgs, nil
+}
+
+// sender runs in a goroutine and handles all sends to the stream.
+func (it *streamingMessageIterator) sender() {
+	defer it.wg.Done()
+	defer it.kaTicker.Stop()
+	defer it.ackTicker.Stop()
+	defer it.nackTicker.Stop()
+	defer it.sp.closeSend()
+
+	done := false
+	for !done {
+		send := false
+		select {
+		case <-it.ctx.Done():
+			// Context canceled or timed out: stop immediately, without
+			// another RPC.
+			return
+
+		case <-it.failed:
+			// Stream failed: nothing to do, so stop immediately.
+			return
+
+		case <-it.drained:
+			// All outstanding messages have been marked done:
+			// nothing left to do except send the final request.
+			it.mu.Lock()
+			send = (len(it.pendingReq.AckIds) > 0 || len(it.pendingReq.ModifyDeadlineAckIds) > 0)
+			done = true
+
+		case <-it.kaTicker.C:
+			it.mu.Lock()
+			send = it.handleKeepAlives()
+
+		case <-it.nackTicker.C:
+			it.mu.Lock()
+			send = (len(it.pendingReq.ModifyDeadlineAckIds) > 0)
+
+		case <-it.ackTicker.C:
+			it.mu.Lock()
+			send = (len(it.pendingReq.AckIds) > 0)
+
+		}
+		// Lock is held here.
+		if send {
+			req := it.pendingReq
+			it.pendingReq = &pb.StreamingPullRequest{}
+			it.mu.Unlock()
+			err := it.sp.send(req)
+			if err != nil {
+				// The streamingPuller handles retries, so any error here
+				// is fatal to the iterator.
+				it.fail(err)
+				return
+			}
+		} else {
+			it.mu.Unlock()
+		}
+	}
+}
+
+// handleKeepAlives modifies the pending request to include deadline extensions
+// for live messages. It also purges expired messages. It reports whether
+// there were any live messages.
+//
+// Called with the lock held.
+func (it *streamingMessageIterator) handleKeepAlives() bool {
+	live, expired := getKeepAliveAckIDs(it.keepAliveDeadlines)
+	for _, e := range expired {
+		delete(it.keepAliveDeadlines, e)
+	}
+	dl := trunc32(int64(it.po.ackDeadline.Seconds()))
+	for _, m := range live {
+		it.addDeadlineMod(m, dl)
+	}
+	it.checkDrained()
+	return len(live) > 0
+}
+
+func getKeepAliveAckIDs(items map[string]time.Time) (live, expired []string) {
+	now := time.Now()
+	for id, expiry := range items {
+		if expiry.Before(now) {
+			expired = append(expired, id)
+		} else {
+			live = append(live, id)
+		}
+	}
+	return live, expired
+}
diff --git a/vendor/cloud.google.com/go/pubsub/message.go b/vendor/cloud.google.com/go/pubsub/message.go
new file mode 100644
index 0000000..f6bb5e0
--- /dev/null
+++ b/vendor/cloud.google.com/go/pubsub/message.go
@@ -0,0 +1,97 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pubsub
+
+import (
+	"time"
+
+	"github.com/golang/protobuf/ptypes"
+	pb "google.golang.org/genproto/googleapis/pubsub/v1"
+)
+
+// Message represents a Pub/Sub message.
+type Message struct {
+	// ID identifies this message.
+	// This ID is assigned by the server and is populated for Messages obtained from a subscription.
+	// This field is read-only.
+	ID string
+
+	// Data is the actual data in the message.
+	Data []byte
+
+	// Attributes represents the key-value pairs the current message
+	// is labelled with.
+	Attributes map[string]string
+
+	// ackID is the identifier to acknowledge this message.
+	ackID string
+
+	// The time at which the message was published.
+	// This is populated by the server for Messages obtained from a subscription.
+	// This field is read-only.
+	PublishTime time.Time
+
+	// size is the approximate size of the message's data and attributes.
+	size int
+
+	calledDone bool
+
+	// The done method of the iterator that created this Message.
+	doneFunc func(string, bool)
+}
+
+func toMessage(resp *pb.ReceivedMessage) (*Message, error) {
+	if resp.Message == nil {
+		return &Message{ackID: resp.AckId}, nil
+	}
+
+	pubTime, err := ptypes.Timestamp(resp.Message.PublishTime)
+	if err != nil {
+		return nil, err
+	}
+	return &Message{
+		ackID:       resp.AckId,
+		Data:        resp.Message.Data,
+		Attributes:  resp.Message.Attributes,
+		ID:          resp.Message.MessageId,
+		PublishTime: pubTime,
+	}, nil
+}
+
+// Ack indicates successful processing of a Message passed to the Subscriber.Receive callback.
+// It should not be called on any other Message value.
+// If message acknowledgement fails, the Message will be redelivered.
+// Client code must call Ack or Nack when finished for each received Message.
+// Calls to Ack or Nack have no effect after the first call.
+func (m *Message) Ack() {
+	m.done(true)
+}
+
+// Nack indicates that the client will not or cannot process a Message passed to the Subscriber.Receive callback.
+// It should not be called on any other Message value.
+// Nack will result in the Message being redelivered more quickly than if it were allowed to expire.
+// Client code must call Ack or Nack when finished for each received Message.
+// Calls to Ack or Nack have no effect after the first call.
+func (m *Message) Nack() {
+	m.done(false)
+}
+
+func (m *Message) done(ack bool) {
+	if m.calledDone {
+		return
+	}
+	m.calledDone = true
+	m.doneFunc(m.ackID, ack)
+}
diff --git a/vendor/cloud.google.com/go/pubsub/pubsub.go b/vendor/cloud.google.com/go/pubsub/pubsub.go
new file mode 100644
index 0000000..6f88b25
--- /dev/null
+++ b/vendor/cloud.google.com/go/pubsub/pubsub.go
@@ -0,0 +1,149 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pubsub
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"time"
+
+	"google.golang.org/api/iterator"
+	"google.golang.org/api/option"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/keepalive"
+
+	"golang.org/x/net/context"
+)
+
+const (
+	// ScopePubSub grants permissions to view and manage Pub/Sub
+	// topics and subscriptions.
+	ScopePubSub = "https://www.googleapis.com/auth/pubsub"
+
+	// ScopeCloudPlatform grants permissions to view and manage your data
+	// across Google Cloud Platform services.
+	ScopeCloudPlatform = "https://www.googleapis.com/auth/cloud-platform"
+)
+
+const prodAddr = "https://pubsub.googleapis.com/"
+
+// Client is a Google Pub/Sub client scoped to a single project.
+//
+// Clients should be reused rather than being created as needed.
+// A Client may be shared by multiple goroutines.
+type Client struct {
+	projectID string
+	s         service
+}
+
+// NewClient creates a new PubSub client.
+func NewClient(ctx context.Context, projectID string, opts ...option.ClientOption) (*Client, error) {
+	var o []option.ClientOption
+	// Environment variables for gcloud emulator:
+	// https://cloud.google.com/sdk/gcloud/reference/beta/emulators/pubsub/
+	if addr := os.Getenv("PUBSUB_EMULATOR_HOST"); addr != "" {
+		conn, err := grpc.Dial(addr, grpc.WithInsecure())
+		if err != nil {
+			return nil, fmt.Errorf("grpc.Dial: %v", err)
+		}
+		o = []option.ClientOption{option.WithGRPCConn(conn)}
+	} else {
+		o = []option.ClientOption{
+			// Create multiple connections to increase throughput.
+			option.WithGRPCConnectionPool(runtime.GOMAXPROCS(0)),
+
+			// TODO(grpc/grpc-go#1388) using connection pool without WithBlock
+			// can cause RPCs to fail randomly. We can delete this after the issue is fixed.
+			option.WithGRPCDialOption(grpc.WithBlock()),
+
+			option.WithGRPCDialOption(grpc.WithKeepaliveParams(keepalive.ClientParameters{
+				Time: 5 * time.Minute,
+			})),
+		}
+	}
+	o = append(o, opts...)
+	s, err := newPubSubService(ctx, o)
+	if err != nil {
+		return nil, fmt.Errorf("constructing pubsub client: %v", err)
+	}
+
+	c := &Client{
+		projectID: projectID,
+		s:         s,
+	}
+
+	return c, nil
+}
+
+// Close closes any resources held by the client.
+//
+// Close need not be called at program exit.
+func (c *Client) Close() error {
+	return c.s.close()
+}
+
+func (c *Client) fullyQualifiedProjectName() string {
+	return fmt.Sprintf("projects/%s", c.projectID)
+}
+
+// pageToken stores the next page token for a server response which is split over multiple pages.
+type pageToken struct {
+	tok      string
+	explicit bool
+}
+
+func (pt *pageToken) set(tok string) {
+	pt.tok = tok
+	pt.explicit = true
+}
+
+func (pt *pageToken) get() string {
+	return pt.tok
+}
+
+// more returns whether further pages should be fetched from the server.
+func (pt *pageToken) more() bool {
+	return pt.tok != "" || !pt.explicit
+}
+
+// stringsIterator provides an iterator API for a sequence of API page fetches that return lists of strings.
+type stringsIterator struct {
+	ctx     context.Context
+	strings []string
+	token   pageToken
+	fetch   func(ctx context.Context, tok string) (*stringsPage, error)
+}
+
+// Next returns the next string. If there are no more strings, iterator.Done will be returned.
+func (si *stringsIterator) Next() (string, error) {
+	for len(si.strings) == 0 && si.token.more() {
+		page, err := si.fetch(si.ctx, si.token.get())
+		if err != nil {
+			return "", err
+		}
+		si.token.set(page.tok)
+		si.strings = page.strings
+	}
+
+	if len(si.strings) == 0 {
+		return "", iterator.Done
+	}
+
+	s := si.strings[0]
+	si.strings = si.strings[1:]
+
+	return s, nil
+}
diff --git a/vendor/cloud.google.com/go/pubsub/service.go b/vendor/cloud.google.com/go/pubsub/service.go
new file mode 100644
index 0000000..4d57d1b
--- /dev/null
+++ b/vendor/cloud.google.com/go/pubsub/service.go
@@ -0,0 +1,598 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pubsub
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/golang/protobuf/ptypes"
+
+	"cloud.google.com/go/iam"
+	"cloud.google.com/go/internal/version"
+	vkit "cloud.google.com/go/pubsub/apiv1"
+	durpb "github.com/golang/protobuf/ptypes/duration"
+	gax "github.com/googleapis/gax-go"
+	"golang.org/x/net/context"
+	"google.golang.org/api/option"
+	pb "google.golang.org/genproto/googleapis/pubsub/v1"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+type nextStringFunc func() (string, error)
+type nextSnapshotFunc func() (*snapshotConfig, error)
+
+// service provides an internal abstraction to isolate the generated
+// PubSub API; most of this package uses this interface instead.
+// The single implementation, *apiService, contains all the knowledge
+// of the generated PubSub API (except for that present in legacy code).
+type service interface {
+	createSubscription(ctx context.Context, subName string, cfg SubscriptionConfig) error
+	getSubscriptionConfig(ctx context.Context, subName string) (SubscriptionConfig, string, error)
+	listProjectSubscriptions(ctx context.Context, projName string) nextStringFunc
+	deleteSubscription(ctx context.Context, name string) error
+	subscriptionExists(ctx context.Context, name string) (bool, error)
+	modifyPushConfig(ctx context.Context, subName string, conf PushConfig) error
+
+	createTopic(ctx context.Context, name string) error
+	deleteTopic(ctx context.Context, name string) error
+	topicExists(ctx context.Context, name string) (bool, error)
+	listProjectTopics(ctx context.Context, projName string) nextStringFunc
+	listTopicSubscriptions(ctx context.Context, topicName string) nextStringFunc
+
+	modifyAckDeadline(ctx context.Context, subName string, deadline time.Duration, ackIDs []string) error
+	fetchMessages(ctx context.Context, subName string, maxMessages int32) ([]*Message, error)
+	publishMessages(ctx context.Context, topicName string, msgs []*Message) ([]string, error)
+
+	// splitAckIDs divides ackIDs into
+	//  * a batch of a size which is suitable for passing to acknowledge or
+	//    modifyAckDeadline, and
+	//  * the rest.
+	splitAckIDs(ackIDs []string) ([]string, []string)
+
+	// acknowledge ACKs the IDs in ackIDs.
+	acknowledge(ctx context.Context, subName string, ackIDs []string) error
+
+	iamHandle(resourceName string) *iam.Handle
+
+	newStreamingPuller(ctx context.Context, subName string, ackDeadline int32) *streamingPuller
+
+	createSnapshot(ctx context.Context, snapName, subName string) (*snapshotConfig, error)
+	deleteSnapshot(ctx context.Context, snapName string) error
+	listProjectSnapshots(ctx context.Context, projName string) nextSnapshotFunc
+
+	// TODO(pongad): Raw proto returns an empty SeekResponse; figure out if we want to return it before GA.
+	seekToTime(ctx context.Context, subName string, t time.Time) error
+	seekToSnapshot(ctx context.Context, subName, snapName string) error
+
+	close() error
+}
+
+type apiService struct {
+	pubc *vkit.PublisherClient
+	subc *vkit.SubscriberClient
+}
+
+func newPubSubService(ctx context.Context, opts []option.ClientOption) (*apiService, error) {
+	pubc, err := vkit.NewPublisherClient(ctx, opts...)
+	if err != nil {
+		return nil, err
+	}
+	subc, err := vkit.NewSubscriberClient(ctx, option.WithGRPCConn(pubc.Connection()))
+	if err != nil {
+		_ = pubc.Close() // ignore error
+		return nil, err
+	}
+	pubc.SetGoogleClientInfo("gccl", version.Repo)
+	subc.SetGoogleClientInfo("gccl", version.Repo)
+	return &apiService{pubc: pubc, subc: subc}, nil
+}
+
+func (s *apiService) close() error {
+	// Return the first error, because the first call closes the connection.
+	err := s.pubc.Close()
+	_ = s.subc.Close()
+	return err
+}
+
+func (s *apiService) createSubscription(ctx context.Context, subName string, cfg SubscriptionConfig) error {
+	var rawPushConfig *pb.PushConfig
+	if cfg.PushConfig.Endpoint != "" || len(cfg.PushConfig.Attributes) != 0 {
+		rawPushConfig = &pb.PushConfig{
+			Attributes:   cfg.PushConfig.Attributes,
+			PushEndpoint: cfg.PushConfig.Endpoint,
+		}
+	}
+	var retentionDuration *durpb.Duration
+	if cfg.retentionDuration != 0 {
+		retentionDuration = ptypes.DurationProto(cfg.retentionDuration)
+	}
+
+	_, err := s.subc.CreateSubscription(ctx, &pb.Subscription{
+		Name:                     subName,
+		Topic:                    cfg.Topic.name,
+		PushConfig:               rawPushConfig,
+		AckDeadlineSeconds:       trunc32(int64(cfg.AckDeadline.Seconds())),
+		RetainAckedMessages:      cfg.retainAckedMessages,
+		MessageRetentionDuration: retentionDuration,
+	})
+	return err
+}
+
+func (s *apiService) getSubscriptionConfig(ctx context.Context, subName string) (SubscriptionConfig, string, error) {
+	rawSub, err := s.subc.GetSubscription(ctx, &pb.GetSubscriptionRequest{Subscription: subName})
+	if err != nil {
+		return SubscriptionConfig{}, "", err
+	}
+	var rd time.Duration
+	// TODO(pongad): Remove nil-check after white list is removed.
+	if rawSub.MessageRetentionDuration != nil {
+		if rd, err = ptypes.Duration(rawSub.MessageRetentionDuration); err != nil {
+			return SubscriptionConfig{}, "", err
+		}
+	}
+	sub := SubscriptionConfig{
+		AckDeadline: time.Second * time.Duration(rawSub.AckDeadlineSeconds),
+		PushConfig: PushConfig{
+			Endpoint:   rawSub.PushConfig.PushEndpoint,
+			Attributes: rawSub.PushConfig.Attributes,
+		},
+		retainAckedMessages: rawSub.RetainAckedMessages,
+		retentionDuration:   rd,
+	}
+	return sub, rawSub.Topic, nil
+}
+
+// stringsPage contains a list of strings and a token for fetching the next page.
+type stringsPage struct {
+	strings []string
+	tok     string
+}
+
+func (s *apiService) listProjectSubscriptions(ctx context.Context, projName string) nextStringFunc {
+	it := s.subc.ListSubscriptions(ctx, &pb.ListSubscriptionsRequest{
+		Project: projName,
+	})
+	return func() (string, error) {
+		sub, err := it.Next()
+		if err != nil {
+			return "", err
+		}
+		return sub.Name, nil
+	}
+}
+
+func (s *apiService) deleteSubscription(ctx context.Context, name string) error {
+	return s.subc.DeleteSubscription(ctx, &pb.DeleteSubscriptionRequest{Subscription: name})
+}
+
+func (s *apiService) subscriptionExists(ctx context.Context, name string) (bool, error) {
+	_, err := s.subc.GetSubscription(ctx, &pb.GetSubscriptionRequest{Subscription: name})
+	if err == nil {
+		return true, nil
+	}
+	if grpc.Code(err) == codes.NotFound {
+		return false, nil
+	}
+	return false, err
+}
+
+func (s *apiService) createTopic(ctx context.Context, name string) error {
+	_, err := s.pubc.CreateTopic(ctx, &pb.Topic{Name: name})
+	return err
+}
+
+func (s *apiService) listProjectTopics(ctx context.Context, projName string) nextStringFunc {
+	it := s.pubc.ListTopics(ctx, &pb.ListTopicsRequest{
+		Project: projName,
+	})
+	return func() (string, error) {
+		topic, err := it.Next()
+		if err != nil {
+			return "", err
+		}
+		return topic.Name, nil
+	}
+}
+
+func (s *apiService) deleteTopic(ctx context.Context, name string) error {
+	return s.pubc.DeleteTopic(ctx, &pb.DeleteTopicRequest{Topic: name})
+}
+
+func (s *apiService) topicExists(ctx context.Context, name string) (bool, error) {
+	_, err := s.pubc.GetTopic(ctx, &pb.GetTopicRequest{Topic: name})
+	if err == nil {
+		return true, nil
+	}
+	if grpc.Code(err) == codes.NotFound {
+		return false, nil
+	}
+	return false, err
+}
+
+func (s *apiService) listTopicSubscriptions(ctx context.Context, topicName string) nextStringFunc {
+	it := s.pubc.ListTopicSubscriptions(ctx, &pb.ListTopicSubscriptionsRequest{
+		Topic: topicName,
+	})
+	return it.Next
+}
+
+func (s *apiService) modifyAckDeadline(ctx context.Context, subName string, deadline time.Duration, ackIDs []string) error {
+	return s.subc.ModifyAckDeadline(ctx, &pb.ModifyAckDeadlineRequest{
+		Subscription:       subName,
+		AckIds:             ackIDs,
+		AckDeadlineSeconds: trunc32(int64(deadline.Seconds())),
+	})
+}
+
+// maxPayload is the maximum number of bytes to devote to actual ids in
+// acknowledgement or modifyAckDeadline requests. A serialized
+// AcknowledgeRequest proto has a small constant overhead, plus the size of the
+// subscription name, plus 3 bytes per ID (a tag byte and two size bytes). A
+// ModifyAckDeadlineRequest has an additional few bytes for the deadline. We
+// don't know the subscription name here, so we just assume the size exclusive
+// of ids is 100 bytes.
+//
+// With gRPC there is no way for the client to know the server's max message size (it is
+// configurable on the server). We know from experience that it
+// it 512K.
+const (
+	maxPayload       = 512 * 1024
+	reqFixedOverhead = 100
+	overheadPerID    = 3
+	maxSendRecvBytes = 20 * 1024 * 1024 // 20M
+)
+
+// splitAckIDs splits ids into two slices, the first of which contains at most maxPayload bytes of ackID data.
+func (s *apiService) splitAckIDs(ids []string) ([]string, []string) {
+	total := reqFixedOverhead
+	for i, id := range ids {
+		total += len(id) + overheadPerID
+		if total > maxPayload {
+			return ids[:i], ids[i:]
+		}
+	}
+	return ids, nil
+}
+
+func (s *apiService) acknowledge(ctx context.Context, subName string, ackIDs []string) error {
+	return s.subc.Acknowledge(ctx, &pb.AcknowledgeRequest{
+		Subscription: subName,
+		AckIds:       ackIDs,
+	})
+}
+
+func (s *apiService) fetchMessages(ctx context.Context, subName string, maxMessages int32) ([]*Message, error) {
+	resp, err := s.subc.Pull(ctx, &pb.PullRequest{
+		Subscription: subName,
+		MaxMessages:  maxMessages,
+	}, gax.WithGRPCOptions(grpc.MaxCallRecvMsgSize(maxSendRecvBytes)))
+	if err != nil {
+		return nil, err
+	}
+	return convertMessages(resp.ReceivedMessages)
+}
+
+func convertMessages(rms []*pb.ReceivedMessage) ([]*Message, error) {
+	msgs := make([]*Message, 0, len(rms))
+	for i, m := range rms {
+		msg, err := toMessage(m)
+		if err != nil {
+			return nil, fmt.Errorf("pubsub: cannot decode the retrieved message at index: %d, message: %+v", i, m)
+		}
+		msgs = append(msgs, msg)
+	}
+	return msgs, nil
+}
+
+func (s *apiService) publishMessages(ctx context.Context, topicName string, msgs []*Message) ([]string, error) {
+	rawMsgs := make([]*pb.PubsubMessage, len(msgs))
+	for i, msg := range msgs {
+		rawMsgs[i] = &pb.PubsubMessage{
+			Data:       msg.Data,
+			Attributes: msg.Attributes,
+		}
+	}
+	resp, err := s.pubc.Publish(ctx, &pb.PublishRequest{
+		Topic:    topicName,
+		Messages: rawMsgs,
+	}, gax.WithGRPCOptions(grpc.MaxCallSendMsgSize(maxSendRecvBytes)))
+	if err != nil {
+		return nil, err
+	}
+	return resp.MessageIds, nil
+}
+
+func (s *apiService) modifyPushConfig(ctx context.Context, subName string, conf PushConfig) error {
+	return s.subc.ModifyPushConfig(ctx, &pb.ModifyPushConfigRequest{
+		Subscription: subName,
+		PushConfig: &pb.PushConfig{
+			Attributes:   conf.Attributes,
+			PushEndpoint: conf.Endpoint,
+		},
+	})
+}
+
+func (s *apiService) iamHandle(resourceName string) *iam.Handle {
+	return iam.InternalNewHandle(s.pubc.Connection(), resourceName)
+}
+
+func trunc32(i int64) int32 {
+	if i > math.MaxInt32 {
+		i = math.MaxInt32
+	}
+	return int32(i)
+}
+
+func (s *apiService) newStreamingPuller(ctx context.Context, subName string, ackDeadlineSecs int32) *streamingPuller {
+	p := &streamingPuller{
+		ctx:             ctx,
+		subName:         subName,
+		ackDeadlineSecs: ackDeadlineSecs,
+		subc:            s.subc,
+	}
+	p.c = sync.NewCond(&p.mu)
+	return p
+}
+
+type streamingPuller struct {
+	ctx             context.Context
+	subName         string
+	ackDeadlineSecs int32
+	subc            *vkit.SubscriberClient
+
+	mu       sync.Mutex
+	c        *sync.Cond
+	inFlight bool
+	closed   bool // set after CloseSend called
+	spc      pb.Subscriber_StreamingPullClient
+	err      error
+}
+
+// open establishes (or re-establishes) a stream for pulling messages.
+// It takes care that only one RPC is in flight at a time.
+func (p *streamingPuller) open() error {
+	p.c.L.Lock()
+	defer p.c.L.Unlock()
+	p.openLocked()
+	return p.err
+}
+
+func (p *streamingPuller) openLocked() {
+	if p.inFlight {
+		// Another goroutine is opening; wait for it.
+		for p.inFlight {
+			p.c.Wait()
+		}
+		return
+	}
+	// No opens in flight; start one.
+	// Keep the lock held, to avoid a race where we
+	// close the old stream while opening a new one.
+	p.inFlight = true
+	spc, err := p.subc.StreamingPull(p.ctx, gax.WithGRPCOptions(grpc.MaxCallRecvMsgSize(maxSendRecvBytes)))
+	if err == nil {
+		err = spc.Send(&pb.StreamingPullRequest{
+			Subscription:             p.subName,
+			StreamAckDeadlineSeconds: p.ackDeadlineSecs,
+		})
+	}
+	p.spc = spc
+	p.err = err
+	p.inFlight = false
+	p.c.Broadcast()
+}
+
+func (p *streamingPuller) call(f func(pb.Subscriber_StreamingPullClient) error) error {
+	p.c.L.Lock()
+	defer p.c.L.Unlock()
+	// Wait for an open in flight.
+	for p.inFlight {
+		p.c.Wait()
+	}
+	var err error
+	var bo gax.Backoff
+	for {
+		select {
+		case <-p.ctx.Done():
+			p.err = p.ctx.Err()
+		default:
+		}
+		if p.err != nil {
+			return p.err
+		}
+		spc := p.spc
+		// Do not call f with the lock held. Only one goroutine calls Send
+		// (streamingMessageIterator.sender) and only one calls Recv
+		// (streamingMessageIterator.receiver). If we locked, then a
+		// blocked Recv would prevent a Send from happening.
+		p.c.L.Unlock()
+		err = f(spc)
+		p.c.L.Lock()
+		if !p.closed && err != nil && isRetryable(err) {
+			// Sleep with exponential backoff. Normally we wouldn't hold the lock while sleeping,
+			// but here it can't do any harm, since the stream is broken anyway.
+			gax.Sleep(p.ctx, bo.Pause())
+			p.openLocked()
+			continue
+		}
+		// Not an error, or not a retryable error; stop retrying.
+		p.err = err
+		return err
+	}
+}
+
+// Logic from https://github.com/GoogleCloudPlatform/google-cloud-java/blob/master/google-cloud-pubsub/src/main/java/com/google/cloud/pubsub/v1/StatusUtil.java.
+func isRetryable(err error) bool {
+	s, ok := status.FromError(err)
+	if !ok { // includes io.EOF, normal stream close, which causes us to reopen
+		return true
+	}
+	switch s.Code() {
+	case codes.DeadlineExceeded, codes.Internal, codes.Canceled, codes.ResourceExhausted:
+		return true
+	case codes.Unavailable:
+		return !strings.Contains(s.Message(), "Server shutdownNow invoked")
+	default:
+		return false
+	}
+}
+
+func (p *streamingPuller) fetchMessages() ([]*Message, error) {
+	var res *pb.StreamingPullResponse
+	err := p.call(func(spc pb.Subscriber_StreamingPullClient) error {
+		var err error
+		res, err = spc.Recv()
+		return err
+	})
+	if err != nil {
+		return nil, err
+	}
+	return convertMessages(res.ReceivedMessages)
+}
+
+func (p *streamingPuller) send(req *pb.StreamingPullRequest) error {
+	// Note: len(modAckIDs) == len(modSecs)
+	var rest *pb.StreamingPullRequest
+	for len(req.AckIds) > 0 || len(req.ModifyDeadlineAckIds) > 0 {
+		req, rest = splitRequest(req, maxPayload)
+		err := p.call(func(spc pb.Subscriber_StreamingPullClient) error {
+			x := spc.Send(req)
+			return x
+		})
+		if err != nil {
+			return err
+		}
+		req = rest
+	}
+	return nil
+}
+
+func (p *streamingPuller) closeSend() {
+	p.mu.Lock()
+	p.closed = true
+	p.spc.CloseSend()
+	p.mu.Unlock()
+}
+
+// Split req into a prefix that is smaller than maxSize, and a remainder.
+func splitRequest(req *pb.StreamingPullRequest, maxSize int) (prefix, remainder *pb.StreamingPullRequest) {
+	const int32Bytes = 4
+
+	// Copy all fields before splitting the variable-sized ones.
+	remainder = &pb.StreamingPullRequest{}
+	*remainder = *req
+	// Split message so it isn't too big.
+	size := reqFixedOverhead
+	i := 0
+	for size < maxSize && (i < len(req.AckIds) || i < len(req.ModifyDeadlineAckIds)) {
+		if i < len(req.AckIds) {
+			size += overheadPerID + len(req.AckIds[i])
+		}
+		if i < len(req.ModifyDeadlineAckIds) {
+			size += overheadPerID + len(req.ModifyDeadlineAckIds[i]) + int32Bytes
+		}
+		i++
+	}
+
+	min := func(a, b int) int {
+		if a < b {
+			return a
+		}
+		return b
+	}
+
+	j := i
+	if size > maxSize {
+		j--
+	}
+	k := min(j, len(req.AckIds))
+	remainder.AckIds = req.AckIds[k:]
+	req.AckIds = req.AckIds[:k]
+	k = min(j, len(req.ModifyDeadlineAckIds))
+	remainder.ModifyDeadlineAckIds = req.ModifyDeadlineAckIds[k:]
+	remainder.ModifyDeadlineSeconds = req.ModifyDeadlineSeconds[k:]
+	req.ModifyDeadlineAckIds = req.ModifyDeadlineAckIds[:k]
+	req.ModifyDeadlineSeconds = req.ModifyDeadlineSeconds[:k]
+	return req, remainder
+}
+
+func (s *apiService) createSnapshot(ctx context.Context, snapName, subName string) (*snapshotConfig, error) {
+	snap, err := s.subc.CreateSnapshot(ctx, &pb.CreateSnapshotRequest{
+		Name:         snapName,
+		Subscription: subName,
+	})
+	if err != nil {
+		return nil, err
+	}
+	return s.toSnapshotConfig(snap)
+}
+
+func (s *apiService) deleteSnapshot(ctx context.Context, snapName string) error {
+	return s.subc.DeleteSnapshot(ctx, &pb.DeleteSnapshotRequest{Snapshot: snapName})
+}
+
+func (s *apiService) listProjectSnapshots(ctx context.Context, projName string) nextSnapshotFunc {
+	it := s.subc.ListSnapshots(ctx, &pb.ListSnapshotsRequest{
+		Project: projName,
+	})
+	return func() (*snapshotConfig, error) {
+		snap, err := it.Next()
+		if err != nil {
+			return nil, err
+		}
+		return s.toSnapshotConfig(snap)
+	}
+}
+
+func (s *apiService) toSnapshotConfig(snap *pb.Snapshot) (*snapshotConfig, error) {
+	exp, err := ptypes.Timestamp(snap.ExpireTime)
+	if err != nil {
+		return nil, err
+	}
+	return &snapshotConfig{
+		snapshot: &snapshot{
+			s:    s,
+			name: snap.Name,
+		},
+		Topic:      newTopic(s, snap.Topic),
+		Expiration: exp,
+	}, nil
+}
+
+func (s *apiService) seekToTime(ctx context.Context, subName string, t time.Time) error {
+	ts, err := ptypes.TimestampProto(t)
+	if err != nil {
+		return err
+	}
+	_, err = s.subc.Seek(ctx, &pb.SeekRequest{
+		Subscription: subName,
+		Target:       &pb.SeekRequest_Time{ts},
+	})
+	return err
+}
+
+func (s *apiService) seekToSnapshot(ctx context.Context, subName, snapName string) error {
+	_, err := s.subc.Seek(ctx, &pb.SeekRequest{
+		Subscription: subName,
+		Target:       &pb.SeekRequest_Snapshot{snapName},
+	})
+	return err
+}
diff --git a/vendor/cloud.google.com/go/pubsub/snapshot.go b/vendor/cloud.google.com/go/pubsub/snapshot.go
new file mode 100644
index 0000000..77115b5
--- /dev/null
+++ b/vendor/cloud.google.com/go/pubsub/snapshot.go
@@ -0,0 +1,119 @@
+// Copyright 2017 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pubsub
+
+import (
+	"strings"
+	"time"
+
+	vkit "cloud.google.com/go/pubsub/apiv1"
+	"golang.org/x/net/context"
+)
+
+// Snapshot is a reference to a PubSub snapshot.
+type snapshot struct {
+	s service
+
+	// The fully qualified identifier for the snapshot, in the format "projects/<projid>/snapshots/<snap>"
+	name string
+}
+
+// ID returns the unique identifier of the snapshot within its project.
+func (s *snapshot) ID() string {
+	slash := strings.LastIndex(s.name, "/")
+	if slash == -1 {
+		// name is not a fully-qualified name.
+		panic("bad snapshot name")
+	}
+	return s.name[slash+1:]
+}
+
+// SnapshotConfig contains the details of a Snapshot.
+type snapshotConfig struct {
+	*snapshot
+	Topic      *Topic
+	Expiration time.Time
+}
+
+// Snapshot creates a reference to a snapshot.
+func (c *Client) snapshot(id string) *snapshot {
+	return &snapshot{
+		s:    c.s,
+		name: vkit.SubscriberSnapshotPath(c.projectID, id),
+	}
+}
+
+// Snapshots returns an iterator which returns snapshots for this project.
+func (c *Client) snapshots(ctx context.Context) *snapshotConfigIterator {
+	return &snapshotConfigIterator{
+		next: c.s.listProjectSnapshots(ctx, c.fullyQualifiedProjectName()),
+	}
+}
+
+// SnapshotConfigIterator is an iterator that returns a series of snapshots.
+type snapshotConfigIterator struct {
+	next nextSnapshotFunc
+}
+
+// Next returns the next SnapshotConfig. Its second return value is iterator.Done if there are no more results.
+// Once Next returns iterator.Done, all subsequent calls will return iterator.Done.
+func (snaps *snapshotConfigIterator) Next() (*snapshotConfig, error) {
+	return snaps.next()
+}
+
+// Delete deletes a snapshot.
+func (snap *snapshot) delete(ctx context.Context) error {
+	return snap.s.deleteSnapshot(ctx, snap.name)
+}
+
+// SeekTime seeks the subscription to a point in time.
+//
+// Messages retained in the subscription that were published before this
+// time are marked as acknowledged, and messages retained in the
+// subscription that were published after this time are marked as
+// unacknowledged. Note that this operation affects only those messages
+// retained in the subscription (configured by SnapshotConfig). For example,
+// if `time` corresponds to a point before the message retention
+// window (or to a point before the system's notion of the subscription
+// creation time), only retained messages will be marked as unacknowledged,
+// and already-expunged messages will not be restored.
+func (s *Subscription) seekToTime(ctx context.Context, t time.Time) error {
+	return s.s.seekToTime(ctx, s.name, t)
+}
+
+// Snapshot creates a new snapshot from this subscription.
+// The snapshot will be for the topic this subscription is subscribed to.
+// If the name is empty string, a unique name is assigned.
+//
+// The created snapshot is guaranteed to retain:
+//  (a) The existing backlog on the subscription. More precisely, this is
+//      defined as the messages in the subscription's backlog that are
+//      unacknowledged when Snapshot returns without error.
+//  (b) Any messages published to the subscription's topic following
+//      Snapshot returning without error.
+func (s *Subscription) createSnapshot(ctx context.Context, name string) (*snapshotConfig, error) {
+	if name != "" {
+		name = vkit.SubscriberSnapshotPath(strings.Split(s.name, "/")[1], name)
+	}
+	return s.s.createSnapshot(ctx, name, s.name)
+}
+
+// SeekSnapshot seeks the subscription to a snapshot.
+//
+// The snapshot needs not be created from this subscription,
+// but the snapshot must be for the topic this subscription is subscribed to.
+func (s *Subscription) seekToSnapshot(ctx context.Context, snap *snapshot) error {
+	return s.s.seekToSnapshot(ctx, s.name, snap.name)
+}
diff --git a/vendor/cloud.google.com/go/pubsub/subscription.go b/vendor/cloud.google.com/go/pubsub/subscription.go
new file mode 100644
index 0000000..2144125
--- /dev/null
+++ b/vendor/cloud.google.com/go/pubsub/subscription.go
@@ -0,0 +1,405 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pubsub
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+	"sync"
+	"time"
+
+	"cloud.google.com/go/iam"
+	"golang.org/x/net/context"
+	"golang.org/x/sync/errgroup"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+)
+
+// Subscription is a reference to a PubSub subscription.
+type Subscription struct {
+	s service
+
+	// The fully qualified identifier for the subscription, in the format "projects/<projid>/subscriptions/<name>"
+	name string
+
+	// Settings for pulling messages. Configure these before calling Receive.
+	ReceiveSettings ReceiveSettings
+
+	mu            sync.Mutex
+	receiveActive bool
+}
+
+// Subscription creates a reference to a subscription.
+func (c *Client) Subscription(id string) *Subscription {
+	return newSubscription(c.s, fmt.Sprintf("projects/%s/subscriptions/%s", c.projectID, id))
+}
+
+func newSubscription(s service, name string) *Subscription {
+	return &Subscription{
+		s:    s,
+		name: name,
+	}
+}
+
+// String returns the globally unique printable name of the subscription.
+func (s *Subscription) String() string {
+	return s.name
+}
+
+// ID returns the unique identifier of the subscription within its project.
+func (s *Subscription) ID() string {
+	slash := strings.LastIndex(s.name, "/")
+	if slash == -1 {
+		// name is not a fully-qualified name.
+		panic("bad subscription name")
+	}
+	return s.name[slash+1:]
+}
+
+// Subscriptions returns an iterator which returns all of the subscriptions for the client's project.
+func (c *Client) Subscriptions(ctx context.Context) *SubscriptionIterator {
+	return &SubscriptionIterator{
+		s:    c.s,
+		next: c.s.listProjectSubscriptions(ctx, c.fullyQualifiedProjectName()),
+	}
+}
+
+// SubscriptionIterator is an iterator that returns a series of subscriptions.
+type SubscriptionIterator struct {
+	s    service
+	next nextStringFunc
+}
+
+// Next returns the next subscription. If there are no more subscriptions, iterator.Done will be returned.
+func (subs *SubscriptionIterator) Next() (*Subscription, error) {
+	subName, err := subs.next()
+	if err != nil {
+		return nil, err
+	}
+	return newSubscription(subs.s, subName), nil
+}
+
+// PushConfig contains configuration for subscriptions that operate in push mode.
+type PushConfig struct {
+	// A URL locating the endpoint to which messages should be pushed.
+	Endpoint string
+
+	// Endpoint configuration attributes. See https://cloud.google.com/pubsub/docs/reference/rest/v1/projects.subscriptions#pushconfig for more details.
+	Attributes map[string]string
+}
+
+// Subscription config contains the configuration of a subscription.
+type SubscriptionConfig struct {
+	Topic      *Topic
+	PushConfig PushConfig
+
+	// The default maximum time after a subscriber receives a message before
+	// the subscriber should acknowledge the message. Note: messages which are
+	// obtained via Subscription.Receive need not be acknowledged within this
+	// deadline, as the deadline will be automatically extended.
+	AckDeadline time.Duration
+
+	// Whether to retain acknowledged messages. If true, acknowledged messages
+	// will not be expunged until they fall out of the RetentionDuration window.
+	retainAckedMessages bool
+
+	// How long to retain messages in backlog, from the time of publish. If RetainAckedMessages is true,
+	// this duration affects the retention of acknowledged messages,
+	// otherwise only unacknowledged messages are retained.
+	// Defaults to 7 days. Cannot be longer than 7 days or shorter than 10 minutes.
+	retentionDuration time.Duration
+}
+
+// ReceiveSettings configure the Receive method.
+// A zero ReceiveSettings will result in values equivalent to DefaultReceiveSettings.
+type ReceiveSettings struct {
+	// MaxExtension is the maximum period for which the Subscription should
+	// automatically extend the ack deadline for each message.
+	//
+	// The Subscription will automatically extend the ack deadline of all
+	// fetched Messages for the duration specified. Automatic deadline
+	// extension may be disabled by specifying a duration less than 1.
+	MaxExtension time.Duration
+
+	// MaxOutstandingMessages is the maximum number of unprocessed messages
+	// (unacknowledged but not yet expired). If MaxOutstandingMessages is 0, it
+	// will be treated as if it were DefaultReceiveSettings.MaxOutstandingMessages.
+	// If the value is negative, then there will be no limit on the number of
+	// unprocessed messages.
+	MaxOutstandingMessages int
+
+	// MaxOutstandingBytes is the maximum size of unprocessed messages
+	// (unacknowledged but not yet expired). If MaxOutstandingBytes is 0, it will
+	// be treated as if it were DefaultReceiveSettings.MaxOutstandingBytes. If
+	// the value is negative, then there will be no limit on the number of bytes
+	// for unprocessed messages.
+	MaxOutstandingBytes int
+
+	// NumGoroutines is the number of goroutines Receive will spawn to pull
+	// messages concurrently. If NumGoroutines is less than 1, it will be treated
+	// as if it were DefaultReceiveSettings.NumGoroutines.
+	//
+	// NumGoroutines does not limit the number of messages that can be processed
+	// concurrently. Even with one goroutine, many messages might be processed at
+	// once, because that goroutine may continually receive messages and invoke the
+	// function passed to Receive on them. To limit the number of messages being
+	// processed concurrently, set MaxOutstandingMessages.
+	NumGoroutines int
+}
+
+// DefaultReceiveSettings holds the default values for ReceiveSettings.
+var DefaultReceiveSettings = ReceiveSettings{
+	MaxExtension:           10 * time.Minute,
+	MaxOutstandingMessages: 1000,
+	MaxOutstandingBytes:    1e9, // 1G
+	NumGoroutines:          1,
+}
+
+// Delete deletes the subscription.
+func (s *Subscription) Delete(ctx context.Context) error {
+	return s.s.deleteSubscription(ctx, s.name)
+}
+
+// Exists reports whether the subscription exists on the server.
+func (s *Subscription) Exists(ctx context.Context) (bool, error) {
+	return s.s.subscriptionExists(ctx, s.name)
+}
+
+// Config fetches the current configuration for the subscription.
+func (s *Subscription) Config(ctx context.Context) (SubscriptionConfig, error) {
+	conf, topicName, err := s.s.getSubscriptionConfig(ctx, s.name)
+	if err != nil {
+		return SubscriptionConfig{}, err
+	}
+	conf.Topic = &Topic{
+		s:    s.s,
+		name: topicName,
+	}
+	return conf, nil
+}
+
+// SubscriptionConfigToUpdate describes how to update a subscription.
+type SubscriptionConfigToUpdate struct {
+	// If non-nil, the push config is changed.
+	PushConfig *PushConfig
+}
+
+// Update changes an existing subscription according to the fields set in cfg.
+// It returns the new SubscriptionConfig.
+//
+// Update returns an error if no fields were modified.
+func (s *Subscription) Update(ctx context.Context, cfg SubscriptionConfigToUpdate) (SubscriptionConfig, error) {
+	if cfg.PushConfig == nil {
+		return SubscriptionConfig{}, errors.New("pubsub: UpdateSubscription call with nothing to update")
+	}
+	if err := s.s.modifyPushConfig(ctx, s.name, *cfg.PushConfig); err != nil {
+		return SubscriptionConfig{}, err
+	}
+	return s.Config(ctx)
+}
+
+func (s *Subscription) IAM() *iam.Handle {
+	return s.s.iamHandle(s.name)
+}
+
+// CreateSubscription creates a new subscription on a topic.
+//
+// id is the name of the subscription to create. It must start with a letter,
+// and contain only letters ([A-Za-z]), numbers ([0-9]), dashes (-),
+// underscores (_), periods (.), tildes (~), plus (+) or percent signs (%). It
+// must be between 3 and 255 characters in length, and must not start with
+// "goog".
+//
+// cfg.Topic is the topic from which the subscription should receive messages. It
+// need not belong to the same project as the subscription. This field is required.
+//
+// cfg.AckDeadline is the maximum time after a subscriber receives a message before
+// the subscriber should acknowledge the message. It must be between 10 and 600
+// seconds (inclusive), and is rounded down to the nearest second. If the
+// provided ackDeadline is 0, then the default value of 10 seconds is used.
+// Note: messages which are obtained via Subscription.Receive need not be
+// acknowledged within this deadline, as the deadline will be automatically
+// extended.
+//
+// cfg.PushConfig may be set to configure this subscription for push delivery.
+//
+// If the subscription already exists an error will be returned.
+func (c *Client) CreateSubscription(ctx context.Context, id string, cfg SubscriptionConfig) (*Subscription, error) {
+	if cfg.Topic == nil {
+		return nil, errors.New("pubsub: require non-nil Topic")
+	}
+	if cfg.AckDeadline == 0 {
+		cfg.AckDeadline = 10 * time.Second
+	}
+	if d := cfg.AckDeadline; d < 10*time.Second || d > 600*time.Second {
+		return nil, fmt.Errorf("ack deadline must be between 10 and 600 seconds; got: %v", d)
+	}
+
+	sub := c.Subscription(id)
+	err := c.s.createSubscription(ctx, sub.name, cfg)
+	return sub, err
+}
+
+var errReceiveInProgress = errors.New("pubsub: Receive already in progress for this subscription")
+
+// Receive calls f with the outstanding messages from the subscription.
+// It blocks until ctx is done, or the service returns a non-retryable error.
+//
+// The standard way to terminate a Receive is to cancel its context:
+//
+//   cctx, cancel := context.WithCancel(ctx)
+//   err := sub.Receive(cctx, callback)
+//   // Call cancel from callback, or another goroutine.
+//
+// If the service returns a non-retryable error, Receive returns that error after
+// all of the outstanding calls to f have returned. If ctx is done, Receive
+// returns nil after all of the outstanding calls to f have returned and
+// all messages have been acknowledged or have expired.
+//
+// Receive calls f concurrently from multiple goroutines. It is encouraged to
+// process messages synchronously in f, even if that processing is relatively
+// time-consuming; Receive will spawn new goroutines for incoming messages,
+// limited by MaxOutstandingMessages and MaxOutstandingBytes in ReceiveSettings.
+//
+// The context passed to f will be canceled when ctx is Done or there is a
+// fatal service error.
+//
+// Receive will automatically extend the ack deadline of all fetched Messages for the
+// period specified by s.ReceiveSettings.MaxExtension.
+//
+// Each Subscription may have only one invocation of Receive active at a time.
+func (s *Subscription) Receive(ctx context.Context, f func(context.Context, *Message)) error {
+	s.mu.Lock()
+	if s.receiveActive {
+		s.mu.Unlock()
+		return errReceiveInProgress
+	}
+	s.receiveActive = true
+	s.mu.Unlock()
+	defer func() { s.mu.Lock(); s.receiveActive = false; s.mu.Unlock() }()
+
+	config, err := s.Config(ctx)
+	if err != nil {
+		if grpc.Code(err) == codes.Canceled {
+			return nil
+		}
+		return err
+	}
+	maxCount := s.ReceiveSettings.MaxOutstandingMessages
+	if maxCount == 0 {
+		maxCount = DefaultReceiveSettings.MaxOutstandingMessages
+	}
+	maxBytes := s.ReceiveSettings.MaxOutstandingBytes
+	if maxBytes == 0 {
+		maxBytes = DefaultReceiveSettings.MaxOutstandingBytes
+	}
+	maxExt := s.ReceiveSettings.MaxExtension
+	if maxExt == 0 {
+		maxExt = DefaultReceiveSettings.MaxExtension
+	} else if maxExt < 0 {
+		// If MaxExtension is negative, disable automatic extension.
+		maxExt = 0
+	}
+	numGoroutines := s.ReceiveSettings.NumGoroutines
+	if numGoroutines < 1 {
+		numGoroutines = DefaultReceiveSettings.NumGoroutines
+	}
+	// TODO(jba): add tests that verify that ReceiveSettings are correctly processed.
+	po := &pullOptions{
+		maxExtension: maxExt,
+		maxPrefetch:  trunc32(int64(maxCount)),
+		ackDeadline:  config.AckDeadline,
+	}
+	fc := newFlowController(maxCount, maxBytes)
+
+	// Wait for all goroutines started by Receive to return, so instead of an
+	// obscure goroutine leak we have an obvious blocked call to Receive.
+	group, gctx := errgroup.WithContext(ctx)
+	for i := 0; i < numGoroutines; i++ {
+		group.Go(func() error {
+			return s.receive(gctx, po, fc, f)
+		})
+	}
+	return group.Wait()
+}
+
+func (s *Subscription) receive(ctx context.Context, po *pullOptions, fc *flowController, f func(context.Context, *Message)) error {
+	// Cancel a sub-context when we return, to kick the context-aware callbacks
+	// and the goroutine below.
+	ctx2, cancel := context.WithCancel(ctx)
+	// Call stop when Receive's context is done.
+	// Stop will block until all outstanding messages have been acknowledged
+	// or there was a fatal service error.
+	// The iterator does not use the context passed to Receive. If it did, canceling
+	// that context would immediately stop the iterator without waiting for unacked
+	// messages.
+	iter := newMessageIterator(context.Background(), s.s, s.name, po)
+
+	// We cannot use errgroup from Receive here. Receive might already be calling group.Wait,
+	// and group.Wait cannot be called concurrently with group.Go. We give each receive() its
+	// own WaitGroup instead.
+	// Since wg.Add is only called from the main goroutine, wg.Wait is guaranteed
+	// to be called after all Adds.
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+		<-ctx2.Done()
+		iter.stop()
+		wg.Done()
+	}()
+	defer wg.Wait()
+
+	defer cancel()
+	for {
+		msgs, err := iter.receive()
+		if err == io.EOF {
+			return nil
+		}
+		if err != nil {
+			return err
+		}
+		for i, msg := range msgs {
+			msg := msg
+			// TODO(jba): call acquire closer to when the message is allocated.
+			if err := fc.acquire(ctx, len(msg.Data)); err != nil {
+				// TODO(jba): test that these "orphaned" messages are nacked immediately when ctx is done.
+				for _, m := range msgs[i:] {
+					m.Nack()
+				}
+				return nil
+			}
+			wg.Add(1)
+			go func() {
+				// TODO(jba): call release when the message is available for GC.
+				// This considers the message to be released when
+				// f is finished, but f may ack early or not at all.
+				defer wg.Done()
+				defer fc.release(len(msg.Data))
+				f(ctx2, msg)
+			}()
+		}
+	}
+}
+
+// TODO(jba): remove when we delete messageIterator.
+type pullOptions struct {
+	maxExtension time.Duration
+	maxPrefetch  int32
+	// ackDeadline is the default ack deadline for the subscription. Not
+	// configurable.
+	ackDeadline time.Duration
+}
diff --git a/vendor/cloud.google.com/go/pubsub/topic.go b/vendor/cloud.google.com/go/pubsub/topic.go
new file mode 100644
index 0000000..274f54d
--- /dev/null
+++ b/vendor/cloud.google.com/go/pubsub/topic.go
@@ -0,0 +1,368 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pubsub
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+
+	"cloud.google.com/go/iam"
+	"github.com/golang/protobuf/proto"
+	"golang.org/x/net/context"
+	"google.golang.org/api/support/bundler"
+	pb "google.golang.org/genproto/googleapis/pubsub/v1"
+)
+
+const (
+	// The maximum number of messages that can be in a single publish request, as
+	// determined by the PubSub service.
+	MaxPublishRequestCount = 1000
+
+	// The maximum size of a single publish request in bytes, as determined by the PubSub service.
+	MaxPublishRequestBytes = 1e7
+
+	maxInt = int(^uint(0) >> 1)
+)
+
+// ErrOversizedMessage indicates that a message's size exceeds MaxPublishRequestBytes.
+var ErrOversizedMessage = bundler.ErrOversizedItem
+
+// Topic is a reference to a PubSub topic.
+//
+// The methods of Topic are safe for use by multiple goroutines.
+type Topic struct {
+	s service
+	// The fully qualified identifier for the topic, in the format "projects/<projid>/topics/<name>"
+	name string
+
+	// Settings for publishing messages. All changes must be made before the
+	// first call to Publish. The default is DefaultPublishSettings.
+	PublishSettings PublishSettings
+
+	mu      sync.RWMutex
+	stopped bool
+	bundler *bundler.Bundler
+
+	wg sync.WaitGroup
+
+	// Channel for message bundles to be published. Close to indicate that Stop was called.
+	bundlec chan []*bundledMessage
+}
+
+// PublishSettings control the bundling of published messages.
+type PublishSettings struct {
+
+	// Publish a non-empty batch after this delay has passed.
+	DelayThreshold time.Duration
+
+	// Publish a batch when it has this many messages. The maximum is
+	// MaxPublishRequestCount.
+	CountThreshold int
+
+	// Publish a batch when its size in bytes reaches this value.
+	ByteThreshold int
+
+	// The number of goroutines that invoke the Publish RPC concurrently.
+	// Defaults to a multiple of GOMAXPROCS.
+	NumGoroutines int
+
+	// The maximum time that the client will attempt to publish a bundle of messages.
+	Timeout time.Duration
+}
+
+// DefaultPublishSettings holds the default values for topics' PublishSettings.
+var DefaultPublishSettings = PublishSettings{
+	DelayThreshold: 1 * time.Millisecond,
+	CountThreshold: 100,
+	ByteThreshold:  1e6,
+	Timeout:        60 * time.Second,
+}
+
+// CreateTopic creates a new topic.
+// The specified topic ID must start with a letter, and contain only letters
+// ([A-Za-z]), numbers ([0-9]), dashes (-), underscores (_), periods (.),
+// tildes (~), plus (+) or percent signs (%). It must be between 3 and 255
+// characters in length, and must not start with "goog".
+// If the topic already exists an error will be returned.
+func (c *Client) CreateTopic(ctx context.Context, id string) (*Topic, error) {
+	t := c.Topic(id)
+	err := c.s.createTopic(ctx, t.name)
+	return t, err
+}
+
+// Topic creates a reference to a topic in the client's project.
+//
+// If a Topic's Publish method is called, it has background goroutines
+// associated with it. Clean them up by calling Topic.Stop.
+//
+// Avoid creating many Topic instances if you use them to publish.
+func (c *Client) Topic(id string) *Topic {
+	return c.TopicInProject(id, c.projectID)
+}
+
+// TopicInProject creates a reference to a topic in the given project.
+//
+// If a Topic's Publish method is called, it has background goroutines
+// associated with it. Clean them up by calling Topic.Stop.
+//
+// Avoid creating many Topic instances if you use them to publish.
+func (c *Client) TopicInProject(id, projectID string) *Topic {
+	return newTopic(c.s, fmt.Sprintf("projects/%s/topics/%s", projectID, id))
+}
+
+func newTopic(s service, name string) *Topic {
+	// bundlec is unbuffered. A buffer would occupy memory not
+	// accounted for by the bundler, so BufferedByteLimit would be a lie:
+	// the actual memory consumed would be higher.
+	return &Topic{
+		s:               s,
+		name:            name,
+		PublishSettings: DefaultPublishSettings,
+		bundlec:         make(chan []*bundledMessage),
+	}
+}
+
+// Topics returns an iterator which returns all of the topics for the client's project.
+func (c *Client) Topics(ctx context.Context) *TopicIterator {
+	return &TopicIterator{
+		s:    c.s,
+		next: c.s.listProjectTopics(ctx, c.fullyQualifiedProjectName()),
+	}
+}
+
+// TopicIterator is an iterator that returns a series of topics.
+type TopicIterator struct {
+	s    service
+	next nextStringFunc
+}
+
+// Next returns the next topic. If there are no more topics, iterator.Done will be returned.
+func (tps *TopicIterator) Next() (*Topic, error) {
+	topicName, err := tps.next()
+	if err != nil {
+		return nil, err
+	}
+	return newTopic(tps.s, topicName), nil
+}
+
+// ID returns the unique idenfier of the topic within its project.
+func (t *Topic) ID() string {
+	slash := strings.LastIndex(t.name, "/")
+	if slash == -1 {
+		// name is not a fully-qualified name.
+		panic("bad topic name")
+	}
+	return t.name[slash+1:]
+}
+
+// String returns the printable globally unique name for the topic.
+func (t *Topic) String() string {
+	return t.name
+}
+
+// Delete deletes the topic.
+func (t *Topic) Delete(ctx context.Context) error {
+	return t.s.deleteTopic(ctx, t.name)
+}
+
+// Exists reports whether the topic exists on the server.
+func (t *Topic) Exists(ctx context.Context) (bool, error) {
+	if t.name == "_deleted-topic_" {
+		return false, nil
+	}
+
+	return t.s.topicExists(ctx, t.name)
+}
+
+func (t *Topic) IAM() *iam.Handle {
+	return t.s.iamHandle(t.name)
+}
+
+// Subscriptions returns an iterator which returns the subscriptions for this topic.
+func (t *Topic) Subscriptions(ctx context.Context) *SubscriptionIterator {
+	// NOTE: zero or more Subscriptions that are ultimately returned by this
+	// Subscriptions iterator may belong to a different project to t.
+	return &SubscriptionIterator{
+		s:    t.s,
+		next: t.s.listTopicSubscriptions(ctx, t.name),
+	}
+}
+
+var errTopicStopped = errors.New("pubsub: Stop has been called for this topic")
+
+// Publish publishes msg to the topic asynchronously. Messages are batched and
+// sent according to the topic's PublishSettings. Publish never blocks.
+//
+// Publish returns a non-nil PublishResult which will be ready when the
+// message has been sent (or has failed to be sent) to the server.
+//
+// Publish creates goroutines for batching and sending messages. These goroutines
+// need to be stopped by calling t.Stop(). Once stopped, future calls to Publish
+// will immediately return a PublishResult with an error.
+func (t *Topic) Publish(ctx context.Context, msg *Message) *PublishResult {
+	// TODO(jba): if this turns out to take significant time, try to approximate it.
+	// Or, convert the messages to protos in Publish, instead of in the service.
+	msg.size = proto.Size(&pb.PubsubMessage{
+		Data:       msg.Data,
+		Attributes: msg.Attributes,
+	})
+	r := &PublishResult{ready: make(chan struct{})}
+	t.initBundler()
+	t.mu.RLock()
+	defer t.mu.RUnlock()
+	// TODO(aboulhosn) [from bcmills] consider changing the semantics of bundler to perform this logic so we don't have to do it here
+	if t.stopped {
+		r.set("", errTopicStopped)
+		return r
+	}
+
+	// TODO(jba) [from bcmills] consider using a shared channel per bundle
+	// (requires Bundler API changes; would reduce allocations)
+	// The call to Add should never return an error because the bundler's
+	// BufferedByteLimit is set to maxInt; we do not perform any flow
+	// control in the client.
+	err := t.bundler.Add(&bundledMessage{msg, r}, msg.size)
+	if err != nil {
+		r.set("", err)
+	}
+	return r
+}
+
+// Send all remaining published messages and stop goroutines created for handling
+// publishing. Returns once all outstanding messages have been sent or have
+// failed to be sent.
+func (t *Topic) Stop() {
+	t.mu.Lock()
+	noop := t.stopped || t.bundler == nil
+	t.stopped = true
+	t.mu.Unlock()
+	if noop {
+		return
+	}
+	t.bundler.Flush()
+	// At this point, all pending bundles have been published and the bundler's
+	// goroutines have exited, so it is OK for this goroutine to close bundlec.
+	close(t.bundlec)
+	t.wg.Wait()
+}
+
+// A PublishResult holds the result from a call to Publish.
+type PublishResult struct {
+	ready    chan struct{}
+	serverID string
+	err      error
+}
+
+// Ready returns a channel that is closed when the result is ready.
+// When the Ready channel is closed, Get is guaranteed not to block.
+func (r *PublishResult) Ready() <-chan struct{} { return r.ready }
+
+// Get returns the server-generated message ID and/or error result of a Publish call.
+// Get blocks until the Publish call completes or the context is done.
+func (r *PublishResult) Get(ctx context.Context) (serverID string, err error) {
+	// If the result is already ready, return it even if the context is done.
+	select {
+	case <-r.Ready():
+		return r.serverID, r.err
+	default:
+	}
+	select {
+	case <-ctx.Done():
+		return "", ctx.Err()
+	case <-r.Ready():
+		return r.serverID, r.err
+	}
+}
+
+func (r *PublishResult) set(sid string, err error) {
+	r.serverID = sid
+	r.err = err
+	close(r.ready)
+}
+
+type bundledMessage struct {
+	msg *Message
+	res *PublishResult
+}
+
+func (t *Topic) initBundler() {
+	t.mu.RLock()
+	noop := t.stopped || t.bundler != nil
+	t.mu.RUnlock()
+	if noop {
+		return
+	}
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	// Must re-check, since we released the lock.
+	if t.stopped || t.bundler != nil {
+		return
+	}
+
+	// TODO(jba): use a context detached from the one passed to NewClient.
+	ctx := context.TODO()
+	// Unless overridden, run several goroutines per CPU to call the Publish RPC.
+	n := t.PublishSettings.NumGoroutines
+	if n <= 0 {
+		n = 25 * runtime.GOMAXPROCS(0)
+	}
+	timeout := t.PublishSettings.Timeout
+	t.wg.Add(n)
+	for i := 0; i < n; i++ {
+		go func() {
+			defer t.wg.Done()
+			for b := range t.bundlec {
+				bctx := ctx
+				cancel := func() {}
+				if timeout != 0 {
+					bctx, cancel = context.WithTimeout(ctx, timeout)
+				}
+				t.publishMessageBundle(bctx, b)
+				cancel()
+			}
+		}()
+	}
+	t.bundler = bundler.NewBundler(&bundledMessage{}, func(items interface{}) {
+		t.bundlec <- items.([]*bundledMessage)
+
+	})
+	t.bundler.DelayThreshold = t.PublishSettings.DelayThreshold
+	t.bundler.BundleCountThreshold = t.PublishSettings.CountThreshold
+	if t.bundler.BundleCountThreshold > MaxPublishRequestCount {
+		t.bundler.BundleCountThreshold = MaxPublishRequestCount
+	}
+	t.bundler.BundleByteThreshold = t.PublishSettings.ByteThreshold
+	t.bundler.BufferedByteLimit = maxInt
+	t.bundler.BundleByteLimit = MaxPublishRequestBytes
+}
+
+func (t *Topic) publishMessageBundle(ctx context.Context, bms []*bundledMessage) {
+	msgs := make([]*Message, len(bms))
+	for i, bm := range bms {
+		msgs[i], bm.msg = bm.msg, nil // release bm.msg for GC
+	}
+	ids, err := t.s.publishMessages(ctx, t.name, msgs)
+	for i, bm := range bms {
+		if err != nil {
+			bm.res.set("", err)
+		} else {
+			bm.res.set(ids[i], nil)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/sync/errgroup/errgroup.go b/vendor/golang.org/x/sync/errgroup/errgroup.go
new file mode 100644
index 0000000..533438d
--- /dev/null
+++ b/vendor/golang.org/x/sync/errgroup/errgroup.go
@@ -0,0 +1,67 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package errgroup provides synchronization, error propagation, and Context
+// cancelation for groups of goroutines working on subtasks of a common task.
+package errgroup
+
+import (
+	"sync"
+
+	"golang.org/x/net/context"
+)
+
+// A Group is a collection of goroutines working on subtasks that are part of
+// the same overall task.
+//
+// A zero Group is valid and does not cancel on error.
+type Group struct {
+	cancel func()
+
+	wg sync.WaitGroup
+
+	errOnce sync.Once
+	err     error
+}
+
+// WithContext returns a new Group and an associated Context derived from ctx.
+//
+// The derived Context is canceled the first time a function passed to Go
+// returns a non-nil error or the first time Wait returns, whichever occurs
+// first.
+func WithContext(ctx context.Context) (*Group, context.Context) {
+	ctx, cancel := context.WithCancel(ctx)
+	return &Group{cancel: cancel}, ctx
+}
+
+// Wait blocks until all function calls from the Go method have returned, then
+// returns the first non-nil error (if any) from them.
+func (g *Group) Wait() error {
+	g.wg.Wait()
+	if g.cancel != nil {
+		g.cancel()
+	}
+	return g.err
+}
+
+// Go calls the given function in a new goroutine.
+//
+// The first call to return a non-nil error cancels the group; its error will be
+// returned by Wait.
+func (g *Group) Go(f func() error) {
+	g.wg.Add(1)
+
+	go func() {
+		defer g.wg.Done()
+
+		if err := f(); err != nil {
+			g.errOnce.Do(func() {
+				g.err = err
+				if g.cancel != nil {
+					g.cancel()
+				}
+			})
+		}
+	}()
+}
diff --git a/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go b/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go
index fc3c4d7..b1c0727 100644
--- a/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go
+++ b/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go
@@ -7,9 +7,6 @@
 // gc compiler.  This package supports go1.7 export data format and all
 // later versions.
 //
-// This package replaces the deprecated golang.org/x/tools/go/gcimporter15
-// package, which will be deleted in October 2017.
-//
 // Although it might seem convenient for this package to live alongside
 // go/types in the standard library, this would cause version skew
 // problems for developer tools that use it, since they must be able to
@@ -32,7 +29,7 @@
 	"io"
 	"io/ioutil"
 
-	gcimporter "golang.org/x/tools/go/gcimporter15"
+	"golang.org/x/tools/go/internal/gcimporter"
 )
 
 // Find returns the name of an object (.o) or archive (.a) file
@@ -95,6 +92,10 @@
 // Write writes encoded type information for the specified package to out.
 // The FileSet provides file position information for named objects.
 func Write(out io.Writer, fset *token.FileSet, pkg *types.Package) error {
-	_, err := out.Write(gcimporter.BExportData(fset, pkg))
+	b, err := gcimporter.BExportData(fset, pkg)
+	if err != nil {
+		return err
+	}
+	_, err = out.Write(b)
 	return err
 }
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/bexport.go b/vendor/golang.org/x/tools/go/internal/gcimporter/bexport.go
similarity index 93%
rename from vendor/golang.org/x/tools/go/gcimporter15/bexport.go
rename to vendor/golang.org/x/tools/go/internal/gcimporter/bexport.go
index cbf8bc0..b106172 100644
--- a/vendor/golang.org/x/tools/go/gcimporter15/bexport.go
+++ b/vendor/golang.org/x/tools/go/internal/gcimporter/bexport.go
@@ -16,7 +16,6 @@
 	"go/constant"
 	"go/token"
 	"go/types"
-	"log"
 	"math"
 	"math/big"
 	"sort"
@@ -76,9 +75,29 @@
 	indent  int // for trace
 }
 
+// internalError represents an error generated inside this package.
+type internalError string
+
+func (e internalError) Error() string { return "gcimporter: " + string(e) }
+
+func internalErrorf(format string, args ...interface{}) error {
+	return internalError(fmt.Sprintf(format, args...))
+}
+
 // BExportData returns binary export data for pkg.
 // If no file set is provided, position info will be missing.
-func BExportData(fset *token.FileSet, pkg *types.Package) []byte {
+func BExportData(fset *token.FileSet, pkg *types.Package) (b []byte, err error) {
+	defer func() {
+		if e := recover(); e != nil {
+			if ierr, ok := e.(internalError); ok {
+				err = ierr
+				return
+			}
+			// Not an internal error; panic again.
+			panic(e)
+		}
+	}()
+
 	p := exporter{
 		fset:          fset,
 		strIndex:      map[string]int{"": 0}, // empty string is mapped to 0
@@ -107,7 +126,7 @@
 		p.typIndex[typ] = index
 	}
 	if len(p.typIndex) != len(predeclared) {
-		log.Fatalf("gcimporter: duplicate entries in type map?")
+		return nil, internalError("duplicate entries in type map?")
 	}
 
 	// write package data
@@ -145,12 +164,12 @@
 
 	// --- end of export data ---
 
-	return p.out.Bytes()
+	return p.out.Bytes(), nil
 }
 
 func (p *exporter) pkg(pkg *types.Package, emptypath bool) {
 	if pkg == nil {
-		log.Fatalf("gcimporter: unexpected nil pkg")
+		panic(internalError("unexpected nil pkg"))
 	}
 
 	// if we saw the package before, write its index (>= 0)
@@ -209,7 +228,7 @@
 		p.paramList(sig.Results(), false)
 
 	default:
-		log.Fatalf("gcimporter: unexpected object %v (%T)", obj, obj)
+		panic(internalErrorf("unexpected object %v (%T)", obj, obj))
 	}
 }
 
@@ -273,7 +292,7 @@
 
 func (p *exporter) typ(t types.Type) {
 	if t == nil {
-		log.Fatalf("gcimporter: nil type")
+		panic(internalError("nil type"))
 	}
 
 	// Possible optimization: Anonymous pointer types *T where
@@ -356,7 +375,7 @@
 		p.typ(t.Elem())
 
 	default:
-		log.Fatalf("gcimporter: unexpected type %T: %s", t, t)
+		panic(internalErrorf("unexpected type %T: %s", t, t))
 	}
 }
 
@@ -422,7 +441,7 @@
 
 func (p *exporter) field(f *types.Var) {
 	if !f.IsField() {
-		log.Fatalf("gcimporter: field expected")
+		panic(internalError("field expected"))
 	}
 
 	p.pos(f)
@@ -452,7 +471,7 @@
 func (p *exporter) method(m *types.Func) {
 	sig := m.Type().(*types.Signature)
 	if sig.Recv() == nil {
-		log.Fatalf("gcimporter: method expected")
+		panic(internalError("method expected"))
 	}
 
 	p.pos(m)
@@ -575,13 +594,13 @@
 		p.tag(unknownTag)
 
 	default:
-		log.Fatalf("gcimporter: unexpected value %v (%T)", x, x)
+		panic(internalErrorf("unexpected value %v (%T)", x, x))
 	}
 }
 
 func (p *exporter) float(x constant.Value) {
 	if x.Kind() != constant.Float {
-		log.Fatalf("gcimporter: unexpected constant %v, want float", x)
+		panic(internalErrorf("unexpected constant %v, want float", x))
 	}
 	// extract sign (there is no -0)
 	sign := constant.Sign(x)
@@ -616,7 +635,7 @@
 	m.SetMantExp(&m, int(m.MinPrec()))
 	mant, acc := m.Int(nil)
 	if acc != big.Exact {
-		log.Fatalf("gcimporter: internal error")
+		panic(internalError("internal error"))
 	}
 
 	p.int(sign)
@@ -653,7 +672,7 @@
 
 func (p *exporter) index(marker byte, index int) {
 	if index < 0 {
-		log.Fatalf("gcimporter: invalid index < 0")
+		panic(internalError("invalid index < 0"))
 	}
 	if debugFormat {
 		p.marker('t')
@@ -666,7 +685,7 @@
 
 func (p *exporter) tag(tag int) {
 	if tag >= 0 {
-		log.Fatalf("gcimporter: invalid tag >= 0")
+		panic(internalError("invalid tag >= 0"))
 	}
 	if debugFormat {
 		p.marker('t')
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/bimport.go b/vendor/golang.org/x/tools/go/internal/gcimporter/bimport.go
similarity index 88%
rename from vendor/golang.org/x/tools/go/gcimporter15/bimport.go
rename to vendor/golang.org/x/tools/go/internal/gcimporter/bimport.go
index 1936a7f..3e845ea 100644
--- a/vendor/golang.org/x/tools/go/gcimporter15/bimport.go
+++ b/vendor/golang.org/x/tools/go/internal/gcimporter/bimport.go
@@ -39,8 +39,7 @@
 	posInfoFormat bool
 	prevFile      string
 	prevLine      int
-	fset          *token.FileSet
-	files         map[string]*token.File
+	fake          fakeFileSet
 
 	// debugging support
 	debugFormat bool
@@ -62,6 +61,10 @@
 		}
 	}()
 
+	if len(data) > 0 && data[0] == 'i' {
+		return iImportData(fset, imports, data[1:], path)
+	}
+
 	p := importer{
 		imports:    imports,
 		data:       data,
@@ -69,8 +72,10 @@
 		version:    -1,           // unknown version
 		strList:    []string{""}, // empty string is mapped to 0
 		pathList:   []string{""}, // empty string is mapped to 0
-		fset:       fset,
-		files:      make(map[string]*token.File),
+		fake: fakeFileSet{
+			fset:  fset,
+			files: make(map[string]*token.File),
+		},
 	}
 
 	// read version info
@@ -104,10 +109,10 @@
 
 	// read version specific flags - extend as necessary
 	switch p.version {
-	// case 6:
+	// case 7:
 	// 	...
 	//	fallthrough
-	case 5, 4, 3, 2, 1:
+	case 6, 5, 4, 3, 2, 1:
 		p.debugFormat = p.rawStringln(p.rawByte()) == "debug"
 		p.trackAllTypes = p.int() != 0
 		p.posInfoFormat = p.int() != 0
@@ -125,7 +130,7 @@
 	// read package data
 	pkg = p.pkg()
 
-	// read objects of phase 1 only (see cmd/compiler/internal/gc/bexport.go)
+	// read objects of phase 1 only (see cmd/compile/internal/gc/bexport.go)
 	objcount := 0
 	for {
 		tag := p.tagOrIndex()
@@ -184,6 +189,9 @@
 	} else {
 		path = p.string()
 	}
+	if p.version >= 6 {
+		p.int() // package height; unused by go/types
+	}
 
 	// we should never see an empty package name
 	if name == "" {
@@ -259,7 +267,7 @@
 	case constTag:
 		pos := p.pos()
 		pkg, name := p.qualifiedName()
-		typ := p.typ(nil)
+		typ := p.typ(nil, nil)
 		val := p.value()
 		p.declare(types.NewConst(pos, pkg, name, typ, val))
 
@@ -267,16 +275,16 @@
 		// TODO(gri) verify type alias hookup is correct
 		pos := p.pos()
 		pkg, name := p.qualifiedName()
-		typ := p.typ(nil)
+		typ := p.typ(nil, nil)
 		p.declare(types.NewTypeName(pos, pkg, name, typ))
 
 	case typeTag:
-		p.typ(nil)
+		p.typ(nil, nil)
 
 	case varTag:
 		pos := p.pos()
 		pkg, name := p.qualifiedName()
-		typ := p.typ(nil)
+		typ := p.typ(nil, nil)
 		p.declare(types.NewVar(pos, pkg, name, typ))
 
 	case funcTag:
@@ -323,15 +331,23 @@
 	p.prevFile = file
 	p.prevLine = line
 
-	// Synthesize a token.Pos
+	return p.fake.pos(file, line)
+}
 
+// Synthesize a token.Pos
+type fakeFileSet struct {
+	fset  *token.FileSet
+	files map[string]*token.File
+}
+
+func (s *fakeFileSet) pos(file string, line int) token.Pos {
 	// Since we don't know the set of needed file positions, we
 	// reserve maxlines positions per file.
 	const maxlines = 64 * 1024
-	f := p.files[file]
+	f := s.files[file]
 	if f == nil {
-		f = p.fset.AddFile(file, -1, maxlines)
-		p.files[file] = f
+		f = s.fset.AddFile(file, -1, maxlines)
+		s.files[file] = f
 		// Allocate the fake linebreak indices on first use.
 		// TODO(adonovan): opt: save ~512KB using a more complex scheme?
 		fakeLinesOnce.Do(func() {
@@ -381,7 +397,11 @@
 // the package currently imported. The parent package is needed for
 // exported struct fields and interface methods which don't contain
 // explicit package information in the export data.
-func (p *importer) typ(parent *types.Package) types.Type {
+//
+// A non-nil tname is used as the "owner" of the result type; i.e.,
+// the result type is the underlying type of tname. tname is used
+// to give interface methods a named receiver type where possible.
+func (p *importer) typ(parent *types.Package, tname *types.Named) types.Type {
 	// if the type was seen before, i is its index (>= 0)
 	i := p.tagOrIndex()
 	if i >= 0 {
@@ -411,15 +431,15 @@
 		t0 := types.NewNamed(obj.(*types.TypeName), nil, nil)
 
 		// but record the existing type, if any
-		t := obj.Type().(*types.Named)
-		p.record(t)
+		tname := obj.Type().(*types.Named) // tname is either t0 or the existing type
+		p.record(tname)
 
 		// read underlying type
-		t0.SetUnderlying(p.typ(parent))
+		t0.SetUnderlying(p.typ(parent, t0))
 
 		// interfaces don't have associated methods
 		if types.IsInterface(t0) {
-			return t
+			return tname
 		}
 
 		// read associated methods
@@ -440,7 +460,7 @@
 			t0.AddMethod(types.NewFunc(pos, parent, name, sig))
 		}
 
-		return t
+		return tname
 
 	case arrayTag:
 		t := new(types.Array)
@@ -449,7 +469,7 @@
 		}
 
 		n := p.int64()
-		*t = *types.NewArray(p.typ(parent), n)
+		*t = *types.NewArray(p.typ(parent, nil), n)
 		return t
 
 	case sliceTag:
@@ -458,7 +478,7 @@
 			p.record(t)
 		}
 
-		*t = *types.NewSlice(p.typ(parent))
+		*t = *types.NewSlice(p.typ(parent, nil))
 		return t
 
 	case dddTag:
@@ -467,7 +487,7 @@
 			p.record(t)
 		}
 
-		t.elem = p.typ(parent)
+		t.elem = p.typ(parent, nil)
 		return t
 
 	case structTag:
@@ -485,7 +505,7 @@
 			p.record(t)
 		}
 
-		*t = *types.NewPointer(p.typ(parent))
+		*t = *types.NewPointer(p.typ(parent, nil))
 		return t
 
 	case signatureTag:
@@ -504,6 +524,8 @@
 		// cannot expect the interface type to appear in a cycle, as any
 		// such cycle must contain a named type which would have been
 		// first defined earlier.
+		// TODO(gri) Is this still true now that we have type aliases?
+		// See issue #23225.
 		n := len(p.typList)
 		if p.trackAllTypes {
 			p.record(nil)
@@ -512,10 +534,10 @@
 		var embeddeds []*types.Named
 		for n := p.int(); n > 0; n-- {
 			p.pos()
-			embeddeds = append(embeddeds, p.typ(parent).(*types.Named))
+			embeddeds = append(embeddeds, p.typ(parent, nil).(*types.Named))
 		}
 
-		t := types.NewInterface(p.methodList(parent), embeddeds)
+		t := types.NewInterface(p.methodList(parent, tname), embeddeds)
 		p.interfaceList = append(p.interfaceList, t)
 		if p.trackAllTypes {
 			p.typList[n] = t
@@ -528,8 +550,8 @@
 			p.record(t)
 		}
 
-		key := p.typ(parent)
-		val := p.typ(parent)
+		key := p.typ(parent, nil)
+		val := p.typ(parent, nil)
 		*t = *types.NewMap(key, val)
 		return t
 
@@ -539,19 +561,8 @@
 			p.record(t)
 		}
 
-		var dir types.ChanDir
-		// tag values must match the constants in cmd/compile/internal/gc/go.go
-		switch d := p.int(); d {
-		case 1 /* Crecv */ :
-			dir = types.RecvOnly
-		case 2 /* Csend */ :
-			dir = types.SendOnly
-		case 3 /* Cboth */ :
-			dir = types.SendRecv
-		default:
-			errorf("unexpected channel dir %d", d)
-		}
-		val := p.typ(parent)
+		dir := chanDir(p.int())
+		val := p.typ(parent, nil)
 		*t = *types.NewChan(dir, val)
 		return t
 
@@ -561,6 +572,21 @@
 	}
 }
 
+func chanDir(d int) types.ChanDir {
+	// tag values must match the constants in cmd/compile/internal/gc/go.go
+	switch d {
+	case 1 /* Crecv */ :
+		return types.RecvOnly
+	case 2 /* Csend */ :
+		return types.SendOnly
+	case 3 /* Cboth */ :
+		return types.SendRecv
+	default:
+		errorf("unexpected channel dir %d", d)
+		return 0
+	}
+}
+
 func (p *importer) fieldList(parent *types.Package) (fields []*types.Var, tags []string) {
 	if n := p.int(); n > 0 {
 		fields = make([]*types.Var, n)
@@ -575,7 +601,7 @@
 func (p *importer) field(parent *types.Package) (*types.Var, string) {
 	pos := p.pos()
 	pkg, name, alias := p.fieldName(parent)
-	typ := p.typ(parent)
+	typ := p.typ(parent, nil)
 	tag := p.string()
 
 	anonymous := false
@@ -599,22 +625,30 @@
 	return types.NewField(pos, pkg, name, typ, anonymous), tag
 }
 
-func (p *importer) methodList(parent *types.Package) (methods []*types.Func) {
+func (p *importer) methodList(parent *types.Package, baseType *types.Named) (methods []*types.Func) {
 	if n := p.int(); n > 0 {
 		methods = make([]*types.Func, n)
 		for i := range methods {
-			methods[i] = p.method(parent)
+			methods[i] = p.method(parent, baseType)
 		}
 	}
 	return
 }
 
-func (p *importer) method(parent *types.Package) *types.Func {
+func (p *importer) method(parent *types.Package, baseType *types.Named) *types.Func {
 	pos := p.pos()
 	pkg, name, _ := p.fieldName(parent)
+	// If we don't have a baseType, use a nil receiver.
+	// A receiver using the actual interface type (which
+	// we don't know yet) will be filled in when we call
+	// types.Interface.Complete.
+	var recv *types.Var
+	if baseType != nil {
+		recv = types.NewVar(token.NoPos, parent, "", baseType)
+	}
 	params, isddd := p.paramList()
 	result, _ := p.paramList()
-	sig := types.NewSignature(nil, params, result, isddd)
+	sig := types.NewSignature(recv, params, result, isddd)
 	return types.NewFunc(pos, pkg, name, sig)
 }
 
@@ -670,7 +704,7 @@
 }
 
 func (p *importer) param(named bool) (*types.Var, bool) {
-	t := p.typ(nil)
+	t := p.typ(nil, nil)
 	td, isddd := t.(*dddSlice)
 	if isddd {
 		t = types.NewSlice(td.elem)
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/exportdata.go b/vendor/golang.org/x/tools/go/internal/gcimporter/exportdata.go
similarity index 100%
rename from vendor/golang.org/x/tools/go/gcimporter15/exportdata.go
rename to vendor/golang.org/x/tools/go/internal/gcimporter/exportdata.go
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/gcimporter.go b/vendor/golang.org/x/tools/go/internal/gcimporter/gcimporter.go
similarity index 98%
rename from vendor/golang.org/x/tools/go/gcimporter15/gcimporter.go
rename to vendor/golang.org/x/tools/go/internal/gcimporter/gcimporter.go
index 370203b..4edd6a8 100644
--- a/vendor/golang.org/x/tools/go/gcimporter15/gcimporter.go
+++ b/vendor/golang.org/x/tools/go/internal/gcimporter/gcimporter.go
@@ -6,13 +6,9 @@
 // but it also contains the original source-based importer code for Go1.6.
 // Once we stop supporting 1.6, we can remove that code.
 
-// Package gcimporter15 provides various functions for reading
+// Package gcimporter provides various functions for reading
 // gc-generated object files that can be used to implement the
 // Importer interface defined by the Go 1.5 standard library package.
-//
-// Deprecated: this package will be deleted in October 2017.
-// New code should use golang.org/x/tools/go/gcexportdata.
-//
 package gcimporter
 
 import (
diff --git a/vendor/golang.org/x/tools/go/internal/gcimporter/iimport.go b/vendor/golang.org/x/tools/go/internal/gcimporter/iimport.go
new file mode 100644
index 0000000..dfc00a3
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gcimporter/iimport.go
@@ -0,0 +1,585 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Indexed package import.
+// See cmd/compile/internal/gc/iexport.go for the export data format.
+
+// This file is a copy of $GOROOT/src/go/internal/gcimporter/iimport.go.
+
+package gcimporter
+
+import (
+	"bytes"
+	"encoding/binary"
+	"go/constant"
+	"go/token"
+	"go/types"
+	"io"
+	"sort"
+)
+
+type intReader struct {
+	*bytes.Reader
+	path string
+}
+
+func (r *intReader) int64() int64 {
+	i, err := binary.ReadVarint(r.Reader)
+	if err != nil {
+		errorf("import %q: read varint error: %v", r.path, err)
+	}
+	return i
+}
+
+func (r *intReader) uint64() uint64 {
+	i, err := binary.ReadUvarint(r.Reader)
+	if err != nil {
+		errorf("import %q: read varint error: %v", r.path, err)
+	}
+	return i
+}
+
+const predeclReserved = 32
+
+type itag uint64
+
+const (
+	// Types
+	definedType itag = iota
+	pointerType
+	sliceType
+	arrayType
+	chanType
+	mapType
+	signatureType
+	structType
+	interfaceType
+)
+
+// iImportData imports a package from the serialized package data
+// and returns the number of bytes consumed and a reference to the package.
+// If the export data version is not recognized or the format is otherwise
+// compromised, an error is returned.
+func iImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (_ int, pkg *types.Package, err error) {
+	r := &intReader{bytes.NewReader(data), path}
+
+	version := r.uint64()
+	switch version {
+	case 0:
+	default:
+		errorf("cannot import %q: unknown iexport format version %d", path, version)
+	}
+
+	sLen := int64(r.uint64())
+	dLen := int64(r.uint64())
+
+	whence, _ := r.Seek(0, io.SeekCurrent)
+	stringData := data[whence : whence+sLen]
+	declData := data[whence+sLen : whence+sLen+dLen]
+	r.Seek(sLen+dLen, io.SeekCurrent)
+
+	p := iimporter{
+		ipath: path,
+
+		stringData:  stringData,
+		stringCache: make(map[uint64]string),
+		pkgCache:    make(map[uint64]*types.Package),
+
+		declData: declData,
+		pkgIndex: make(map[*types.Package]map[string]uint64),
+		typCache: make(map[uint64]types.Type),
+
+		fake: fakeFileSet{
+			fset:  fset,
+			files: make(map[string]*token.File),
+		},
+	}
+
+	for i, pt := range predeclared {
+		p.typCache[uint64(i)] = pt
+	}
+
+	pkgList := make([]*types.Package, r.uint64())
+	for i := range pkgList {
+		pkgPathOff := r.uint64()
+		pkgPath := p.stringAt(pkgPathOff)
+		pkgName := p.stringAt(r.uint64())
+		_ = r.uint64() // package height; unused by go/types
+
+		if pkgPath == "" {
+			pkgPath = path
+		}
+		pkg := imports[pkgPath]
+		if pkg == nil {
+			pkg = types.NewPackage(pkgPath, pkgName)
+			imports[pkgPath] = pkg
+		} else if pkg.Name() != pkgName {
+			errorf("conflicting names %s and %s for package %q", pkg.Name(), pkgName, path)
+		}
+
+		p.pkgCache[pkgPathOff] = pkg
+
+		nameIndex := make(map[string]uint64)
+		for nSyms := r.uint64(); nSyms > 0; nSyms-- {
+			name := p.stringAt(r.uint64())
+			nameIndex[name] = r.uint64()
+		}
+
+		p.pkgIndex[pkg] = nameIndex
+		pkgList[i] = pkg
+	}
+
+	localpkg := pkgList[0]
+
+	names := make([]string, 0, len(p.pkgIndex[localpkg]))
+	for name := range p.pkgIndex[localpkg] {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		p.doDecl(localpkg, name)
+	}
+
+	for _, typ := range p.interfaceList {
+		typ.Complete()
+	}
+
+	// record all referenced packages as imports
+	list := append(([]*types.Package)(nil), pkgList[1:]...)
+	sort.Sort(byPath(list))
+	localpkg.SetImports(list)
+
+	// package was imported completely and without errors
+	localpkg.MarkComplete()
+
+	consumed, _ := r.Seek(0, io.SeekCurrent)
+	return int(consumed), localpkg, nil
+}
+
+type iimporter struct {
+	ipath string
+
+	stringData  []byte
+	stringCache map[uint64]string
+	pkgCache    map[uint64]*types.Package
+
+	declData []byte
+	pkgIndex map[*types.Package]map[string]uint64
+	typCache map[uint64]types.Type
+
+	fake          fakeFileSet
+	interfaceList []*types.Interface
+}
+
+func (p *iimporter) doDecl(pkg *types.Package, name string) {
+	// See if we've already imported this declaration.
+	if obj := pkg.Scope().Lookup(name); obj != nil {
+		return
+	}
+
+	off, ok := p.pkgIndex[pkg][name]
+	if !ok {
+		errorf("%v.%v not in index", pkg, name)
+	}
+
+	r := &importReader{p: p, currPkg: pkg}
+	r.declReader.Reset(p.declData[off:])
+
+	r.obj(name)
+}
+
+func (p *iimporter) stringAt(off uint64) string {
+	if s, ok := p.stringCache[off]; ok {
+		return s
+	}
+
+	slen, n := binary.Uvarint(p.stringData[off:])
+	if n <= 0 {
+		errorf("varint failed")
+	}
+	spos := off + uint64(n)
+	s := string(p.stringData[spos : spos+slen])
+	p.stringCache[off] = s
+	return s
+}
+
+func (p *iimporter) pkgAt(off uint64) *types.Package {
+	if pkg, ok := p.pkgCache[off]; ok {
+		return pkg
+	}
+	path := p.stringAt(off)
+	errorf("missing package %q in %q", path, p.ipath)
+	return nil
+}
+
+func (p *iimporter) typAt(off uint64, base *types.Named) types.Type {
+	if t, ok := p.typCache[off]; ok && (base == nil || !isInterface(t)) {
+		return t
+	}
+
+	if off < predeclReserved {
+		errorf("predeclared type missing from cache: %v", off)
+	}
+
+	r := &importReader{p: p}
+	r.declReader.Reset(p.declData[off-predeclReserved:])
+	t := r.doType(base)
+
+	if base == nil || !isInterface(t) {
+		p.typCache[off] = t
+	}
+	return t
+}
+
+type importReader struct {
+	p          *iimporter
+	declReader bytes.Reader
+	currPkg    *types.Package
+	prevFile   string
+	prevLine   int64
+}
+
+func (r *importReader) obj(name string) {
+	tag := r.byte()
+	pos := r.pos()
+
+	switch tag {
+	case 'A':
+		typ := r.typ()
+
+		r.declare(types.NewTypeName(pos, r.currPkg, name, typ))
+
+	case 'C':
+		typ, val := r.value()
+
+		r.declare(types.NewConst(pos, r.currPkg, name, typ, val))
+
+	case 'F':
+		sig := r.signature(nil)
+
+		r.declare(types.NewFunc(pos, r.currPkg, name, sig))
+
+	case 'T':
+		// Types can be recursive. We need to setup a stub
+		// declaration before recursing.
+		obj := types.NewTypeName(pos, r.currPkg, name, nil)
+		named := types.NewNamed(obj, nil, nil)
+		r.declare(obj)
+
+		underlying := r.p.typAt(r.uint64(), named).Underlying()
+		named.SetUnderlying(underlying)
+
+		if !isInterface(underlying) {
+			for n := r.uint64(); n > 0; n-- {
+				mpos := r.pos()
+				mname := r.ident()
+				recv := r.param()
+				msig := r.signature(recv)
+
+				named.AddMethod(types.NewFunc(mpos, r.currPkg, mname, msig))
+			}
+		}
+
+	case 'V':
+		typ := r.typ()
+
+		r.declare(types.NewVar(pos, r.currPkg, name, typ))
+
+	default:
+		errorf("unexpected tag: %v", tag)
+	}
+}
+
+func (r *importReader) declare(obj types.Object) {
+	obj.Pkg().Scope().Insert(obj)
+}
+
+func (r *importReader) value() (typ types.Type, val constant.Value) {
+	typ = r.typ()
+
+	switch b := typ.Underlying().(*types.Basic); b.Info() & types.IsConstType {
+	case types.IsBoolean:
+		val = constant.MakeBool(r.bool())
+
+	case types.IsString:
+		val = constant.MakeString(r.string())
+
+	case types.IsInteger:
+		val = r.mpint(b)
+
+	case types.IsFloat:
+		val = r.mpfloat(b)
+
+	case types.IsComplex:
+		re := r.mpfloat(b)
+		im := r.mpfloat(b)
+		val = constant.BinaryOp(re, token.ADD, constant.MakeImag(im))
+
+	default:
+		errorf("unexpected type %v", typ) // panics
+		panic("unreachable")
+	}
+
+	return
+}
+
+func intSize(b *types.Basic) (signed bool, maxBytes uint) {
+	if (b.Info() & types.IsUntyped) != 0 {
+		return true, 64
+	}
+
+	switch b.Kind() {
+	case types.Float32, types.Complex64:
+		return true, 3
+	case types.Float64, types.Complex128:
+		return true, 7
+	}
+
+	signed = (b.Info() & types.IsUnsigned) == 0
+	switch b.Kind() {
+	case types.Int8, types.Uint8:
+		maxBytes = 1
+	case types.Int16, types.Uint16:
+		maxBytes = 2
+	case types.Int32, types.Uint32:
+		maxBytes = 4
+	default:
+		maxBytes = 8
+	}
+
+	return
+}
+
+func (r *importReader) mpint(b *types.Basic) constant.Value {
+	signed, maxBytes := intSize(b)
+
+	maxSmall := 256 - maxBytes
+	if signed {
+		maxSmall = 256 - 2*maxBytes
+	}
+	if maxBytes == 1 {
+		maxSmall = 256
+	}
+
+	n, _ := r.declReader.ReadByte()
+	if uint(n) < maxSmall {
+		v := int64(n)
+		if signed {
+			v >>= 1
+			if n&1 != 0 {
+				v = ^v
+			}
+		}
+		return constant.MakeInt64(v)
+	}
+
+	v := -n
+	if signed {
+		v = -(n &^ 1) >> 1
+	}
+	if v < 1 || uint(v) > maxBytes {
+		errorf("weird decoding: %v, %v => %v", n, signed, v)
+	}
+
+	buf := make([]byte, v)
+	io.ReadFull(&r.declReader, buf)
+
+	// convert to little endian
+	// TODO(gri) go/constant should have a more direct conversion function
+	//           (e.g., once it supports a big.Float based implementation)
+	for i, j := 0, len(buf)-1; i < j; i, j = i+1, j-1 {
+		buf[i], buf[j] = buf[j], buf[i]
+	}
+
+	x := constant.MakeFromBytes(buf)
+	if signed && n&1 != 0 {
+		x = constant.UnaryOp(token.SUB, x, 0)
+	}
+	return x
+}
+
+func (r *importReader) mpfloat(b *types.Basic) constant.Value {
+	x := r.mpint(b)
+	if constant.Sign(x) == 0 {
+		return x
+	}
+
+	exp := r.int64()
+	switch {
+	case exp > 0:
+		x = constant.Shift(x, token.SHL, uint(exp))
+	case exp < 0:
+		d := constant.Shift(constant.MakeInt64(1), token.SHL, uint(-exp))
+		x = constant.BinaryOp(x, token.QUO, d)
+	}
+	return x
+}
+
+func (r *importReader) ident() string {
+	return r.string()
+}
+
+func (r *importReader) qualifiedIdent() (*types.Package, string) {
+	name := r.string()
+	pkg := r.pkg()
+	return pkg, name
+}
+
+func (r *importReader) pos() token.Pos {
+	delta := r.int64()
+	if delta != deltaNewFile {
+		r.prevLine += delta
+	} else if l := r.int64(); l == -1 {
+		r.prevLine += deltaNewFile
+	} else {
+		r.prevFile = r.string()
+		r.prevLine = l
+	}
+
+	if r.prevFile == "" && r.prevLine == 0 {
+		return token.NoPos
+	}
+
+	return r.p.fake.pos(r.prevFile, int(r.prevLine))
+}
+
+func (r *importReader) typ() types.Type {
+	return r.p.typAt(r.uint64(), nil)
+}
+
+func isInterface(t types.Type) bool {
+	_, ok := t.(*types.Interface)
+	return ok
+}
+
+func (r *importReader) pkg() *types.Package { return r.p.pkgAt(r.uint64()) }
+func (r *importReader) string() string      { return r.p.stringAt(r.uint64()) }
+
+func (r *importReader) doType(base *types.Named) types.Type {
+	switch k := r.kind(); k {
+	default:
+		errorf("unexpected kind tag in %q: %v", r.p.ipath, k)
+		return nil
+
+	case definedType:
+		pkg, name := r.qualifiedIdent()
+		r.p.doDecl(pkg, name)
+		return pkg.Scope().Lookup(name).(*types.TypeName).Type()
+	case pointerType:
+		return types.NewPointer(r.typ())
+	case sliceType:
+		return types.NewSlice(r.typ())
+	case arrayType:
+		n := r.uint64()
+		return types.NewArray(r.typ(), int64(n))
+	case chanType:
+		dir := chanDir(int(r.uint64()))
+		return types.NewChan(dir, r.typ())
+	case mapType:
+		return types.NewMap(r.typ(), r.typ())
+	case signatureType:
+		r.currPkg = r.pkg()
+		return r.signature(nil)
+
+	case structType:
+		r.currPkg = r.pkg()
+
+		fields := make([]*types.Var, r.uint64())
+		tags := make([]string, len(fields))
+		for i := range fields {
+			fpos := r.pos()
+			fname := r.ident()
+			ftyp := r.typ()
+			emb := r.bool()
+			tag := r.string()
+
+			fields[i] = types.NewField(fpos, r.currPkg, fname, ftyp, emb)
+			tags[i] = tag
+		}
+		return types.NewStruct(fields, tags)
+
+	case interfaceType:
+		r.currPkg = r.pkg()
+
+		embeddeds := make([]*types.Named, r.uint64())
+		for i := range embeddeds {
+			_ = r.pos()
+			embeddeds[i] = r.typ().(*types.Named)
+		}
+
+		methods := make([]*types.Func, r.uint64())
+		for i := range methods {
+			mpos := r.pos()
+			mname := r.ident()
+
+			// TODO(mdempsky): Matches bimport.go, but I
+			// don't agree with this.
+			var recv *types.Var
+			if base != nil {
+				recv = types.NewVar(token.NoPos, r.currPkg, "", base)
+			}
+
+			msig := r.signature(recv)
+			methods[i] = types.NewFunc(mpos, r.currPkg, mname, msig)
+		}
+
+		typ := types.NewInterface(methods, embeddeds)
+		r.p.interfaceList = append(r.p.interfaceList, typ)
+		return typ
+	}
+}
+
+func (r *importReader) kind() itag {
+	return itag(r.uint64())
+}
+
+func (r *importReader) signature(recv *types.Var) *types.Signature {
+	params := r.paramList()
+	results := r.paramList()
+	variadic := params.Len() > 0 && r.bool()
+	return types.NewSignature(recv, params, results, variadic)
+}
+
+func (r *importReader) paramList() *types.Tuple {
+	xs := make([]*types.Var, r.uint64())
+	for i := range xs {
+		xs[i] = r.param()
+	}
+	return types.NewTuple(xs...)
+}
+
+func (r *importReader) param() *types.Var {
+	pos := r.pos()
+	name := r.ident()
+	typ := r.typ()
+	return types.NewParam(pos, r.currPkg, name, typ)
+}
+
+func (r *importReader) bool() bool {
+	return r.uint64() != 0
+}
+
+func (r *importReader) int64() int64 {
+	n, err := binary.ReadVarint(&r.declReader)
+	if err != nil {
+		errorf("readVarint: %v", err)
+	}
+	return n
+}
+
+func (r *importReader) uint64() uint64 {
+	n, err := binary.ReadUvarint(&r.declReader)
+	if err != nil {
+		errorf("readUvarint: %v", err)
+	}
+	return n
+}
+
+func (r *importReader) byte() byte {
+	x, err := r.declReader.ReadByte()
+	if err != nil {
+		errorf("declReader.ReadByte: %v", err)
+	}
+	return x
+}
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/isAlias18.go b/vendor/golang.org/x/tools/go/internal/gcimporter/isAlias18.go
similarity index 100%
rename from vendor/golang.org/x/tools/go/gcimporter15/isAlias18.go
rename to vendor/golang.org/x/tools/go/internal/gcimporter/isAlias18.go
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/isAlias19.go b/vendor/golang.org/x/tools/go/internal/gcimporter/isAlias19.go
similarity index 100%
rename from vendor/golang.org/x/tools/go/gcimporter15/isAlias19.go
rename to vendor/golang.org/x/tools/go/internal/gcimporter/isAlias19.go
diff --git a/vendor/golang.org/x/tools/present/doc.go b/vendor/golang.org/x/tools/present/doc.go
index e7f595e..3422294 100644
--- a/vendor/golang.org/x/tools/present/doc.go
+++ b/vendor/golang.org/x/tools/present/doc.go
@@ -117,7 +117,7 @@
 section of the file to display. The address syntax is similar in
 its simplest form to that of ed, but comes from sam and is more
 general. See
-	http://plan9.bell-labs.com/sys/doc/sam/sam.html Table II
+	https://plan9.io/sys/doc/sam/sam.html Table II
 for full details. The displayed block is always rounded out to a
 full line at both ends.
 
diff --git a/vendor/golang.org/x/tools/present/parse.go b/vendor/golang.org/x/tools/present/parse.go
index d7289db..dd0f00b 100644
--- a/vendor/golang.org/x/tools/present/parse.go
+++ b/vendor/golang.org/x/tools/present/parse.go
@@ -168,8 +168,17 @@
 	return execTemplate(t, e.TemplateName(), data)
 }
 
+// pageNum derives a page number from a section.
+func pageNum(s Section, offset int) int {
+	if len(s.Number) == 0 {
+		return offset
+	}
+	return s.Number[0] + offset
+}
+
 func init() {
 	funcs["elem"] = renderElem
+	funcs["pagenum"] = pageNum
 }
 
 // execTemplate is a helper to execute a template and return the output as a
diff --git a/vendor/google.golang.org/genproto/googleapis/iam/v1/iam_policy.pb.go b/vendor/google.golang.org/genproto/googleapis/iam/v1/iam_policy.pb.go
new file mode 100644
index 0000000..2f481a3
--- /dev/null
+++ b/vendor/google.golang.org/genproto/googleapis/iam/v1/iam_policy.pb.go
@@ -0,0 +1,337 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/iam/v1/iam_policy.proto
+
+/*
+Package iam is a generated protocol buffer package.
+
+It is generated from these files:
+	google/iam/v1/iam_policy.proto
+	google/iam/v1/policy.proto
+
+It has these top-level messages:
+	SetIamPolicyRequest
+	GetIamPolicyRequest
+	TestIamPermissionsRequest
+	TestIamPermissionsResponse
+	Policy
+	Binding
+	PolicyDelta
+	BindingDelta
+*/
+package iam
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import _ "google.golang.org/genproto/googleapis/api/annotations"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// Request message for `SetIamPolicy` method.
+type SetIamPolicyRequest struct {
+	// REQUIRED: The resource for which the policy is being specified.
+	// `resource` is usually specified as a path. For example, a Project
+	// resource is specified as `projects/{project}`.
+	Resource string `protobuf:"bytes,1,opt,name=resource" json:"resource,omitempty"`
+	// REQUIRED: The complete policy to be applied to the `resource`. The size of
+	// the policy is limited to a few 10s of KB. An empty policy is a
+	// valid policy but certain Cloud Platform services (such as Projects)
+	// might reject them.
+	Policy *Policy `protobuf:"bytes,2,opt,name=policy" json:"policy,omitempty"`
+}
+
+func (m *SetIamPolicyRequest) Reset()                    { *m = SetIamPolicyRequest{} }
+func (m *SetIamPolicyRequest) String() string            { return proto.CompactTextString(m) }
+func (*SetIamPolicyRequest) ProtoMessage()               {}
+func (*SetIamPolicyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *SetIamPolicyRequest) GetResource() string {
+	if m != nil {
+		return m.Resource
+	}
+	return ""
+}
+
+func (m *SetIamPolicyRequest) GetPolicy() *Policy {
+	if m != nil {
+		return m.Policy
+	}
+	return nil
+}
+
+// Request message for `GetIamPolicy` method.
+type GetIamPolicyRequest struct {
+	// REQUIRED: The resource for which the policy is being requested.
+	// `resource` is usually specified as a path. For example, a Project
+	// resource is specified as `projects/{project}`.
+	Resource string `protobuf:"bytes,1,opt,name=resource" json:"resource,omitempty"`
+}
+
+func (m *GetIamPolicyRequest) Reset()                    { *m = GetIamPolicyRequest{} }
+func (m *GetIamPolicyRequest) String() string            { return proto.CompactTextString(m) }
+func (*GetIamPolicyRequest) ProtoMessage()               {}
+func (*GetIamPolicyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *GetIamPolicyRequest) GetResource() string {
+	if m != nil {
+		return m.Resource
+	}
+	return ""
+}
+
+// Request message for `TestIamPermissions` method.
+type TestIamPermissionsRequest struct {
+	// REQUIRED: The resource for which the policy detail is being requested.
+	// `resource` is usually specified as a path. For example, a Project
+	// resource is specified as `projects/{project}`.
+	Resource string `protobuf:"bytes,1,opt,name=resource" json:"resource,omitempty"`
+	// The set of permissions to check for the `resource`. Permissions with
+	// wildcards (such as '*' or 'storage.*') are not allowed. For more
+	// information see
+	// [IAM Overview](https://cloud.google.com/iam/docs/overview#permissions).
+	Permissions []string `protobuf:"bytes,2,rep,name=permissions" json:"permissions,omitempty"`
+}
+
+func (m *TestIamPermissionsRequest) Reset()                    { *m = TestIamPermissionsRequest{} }
+func (m *TestIamPermissionsRequest) String() string            { return proto.CompactTextString(m) }
+func (*TestIamPermissionsRequest) ProtoMessage()               {}
+func (*TestIamPermissionsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+func (m *TestIamPermissionsRequest) GetResource() string {
+	if m != nil {
+		return m.Resource
+	}
+	return ""
+}
+
+func (m *TestIamPermissionsRequest) GetPermissions() []string {
+	if m != nil {
+		return m.Permissions
+	}
+	return nil
+}
+
+// Response message for `TestIamPermissions` method.
+type TestIamPermissionsResponse struct {
+	// A subset of `TestPermissionsRequest.permissions` that the caller is
+	// allowed.
+	Permissions []string `protobuf:"bytes,1,rep,name=permissions" json:"permissions,omitempty"`
+}
+
+func (m *TestIamPermissionsResponse) Reset()                    { *m = TestIamPermissionsResponse{} }
+func (m *TestIamPermissionsResponse) String() string            { return proto.CompactTextString(m) }
+func (*TestIamPermissionsResponse) ProtoMessage()               {}
+func (*TestIamPermissionsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+func (m *TestIamPermissionsResponse) GetPermissions() []string {
+	if m != nil {
+		return m.Permissions
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*SetIamPolicyRequest)(nil), "google.iam.v1.SetIamPolicyRequest")
+	proto.RegisterType((*GetIamPolicyRequest)(nil), "google.iam.v1.GetIamPolicyRequest")
+	proto.RegisterType((*TestIamPermissionsRequest)(nil), "google.iam.v1.TestIamPermissionsRequest")
+	proto.RegisterType((*TestIamPermissionsResponse)(nil), "google.iam.v1.TestIamPermissionsResponse")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for IAMPolicy service
+
+type IAMPolicyClient interface {
+	// Sets the access control policy on the specified resource. Replaces any
+	// existing policy.
+	SetIamPolicy(ctx context.Context, in *SetIamPolicyRequest, opts ...grpc.CallOption) (*Policy, error)
+	// Gets the access control policy for a resource.
+	// Returns an empty policy if the resource exists and does not have a policy
+	// set.
+	GetIamPolicy(ctx context.Context, in *GetIamPolicyRequest, opts ...grpc.CallOption) (*Policy, error)
+	// Returns permissions that a caller has on the specified resource.
+	// If the resource does not exist, this will return an empty set of
+	// permissions, not a NOT_FOUND error.
+	TestIamPermissions(ctx context.Context, in *TestIamPermissionsRequest, opts ...grpc.CallOption) (*TestIamPermissionsResponse, error)
+}
+
+type iAMPolicyClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewIAMPolicyClient(cc *grpc.ClientConn) IAMPolicyClient {
+	return &iAMPolicyClient{cc}
+}
+
+func (c *iAMPolicyClient) SetIamPolicy(ctx context.Context, in *SetIamPolicyRequest, opts ...grpc.CallOption) (*Policy, error) {
+	out := new(Policy)
+	err := grpc.Invoke(ctx, "/google.iam.v1.IAMPolicy/SetIamPolicy", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *iAMPolicyClient) GetIamPolicy(ctx context.Context, in *GetIamPolicyRequest, opts ...grpc.CallOption) (*Policy, error) {
+	out := new(Policy)
+	err := grpc.Invoke(ctx, "/google.iam.v1.IAMPolicy/GetIamPolicy", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *iAMPolicyClient) TestIamPermissions(ctx context.Context, in *TestIamPermissionsRequest, opts ...grpc.CallOption) (*TestIamPermissionsResponse, error) {
+	out := new(TestIamPermissionsResponse)
+	err := grpc.Invoke(ctx, "/google.iam.v1.IAMPolicy/TestIamPermissions", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for IAMPolicy service
+
+type IAMPolicyServer interface {
+	// Sets the access control policy on the specified resource. Replaces any
+	// existing policy.
+	SetIamPolicy(context.Context, *SetIamPolicyRequest) (*Policy, error)
+	// Gets the access control policy for a resource.
+	// Returns an empty policy if the resource exists and does not have a policy
+	// set.
+	GetIamPolicy(context.Context, *GetIamPolicyRequest) (*Policy, error)
+	// Returns permissions that a caller has on the specified resource.
+	// If the resource does not exist, this will return an empty set of
+	// permissions, not a NOT_FOUND error.
+	TestIamPermissions(context.Context, *TestIamPermissionsRequest) (*TestIamPermissionsResponse, error)
+}
+
+func RegisterIAMPolicyServer(s *grpc.Server, srv IAMPolicyServer) {
+	s.RegisterService(&_IAMPolicy_serviceDesc, srv)
+}
+
+func _IAMPolicy_SetIamPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(SetIamPolicyRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(IAMPolicyServer).SetIamPolicy(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.iam.v1.IAMPolicy/SetIamPolicy",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(IAMPolicyServer).SetIamPolicy(ctx, req.(*SetIamPolicyRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _IAMPolicy_GetIamPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetIamPolicyRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(IAMPolicyServer).GetIamPolicy(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.iam.v1.IAMPolicy/GetIamPolicy",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(IAMPolicyServer).GetIamPolicy(ctx, req.(*GetIamPolicyRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _IAMPolicy_TestIamPermissions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(TestIamPermissionsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(IAMPolicyServer).TestIamPermissions(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.iam.v1.IAMPolicy/TestIamPermissions",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(IAMPolicyServer).TestIamPermissions(ctx, req.(*TestIamPermissionsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _IAMPolicy_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "google.iam.v1.IAMPolicy",
+	HandlerType: (*IAMPolicyServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "SetIamPolicy",
+			Handler:    _IAMPolicy_SetIamPolicy_Handler,
+		},
+		{
+			MethodName: "GetIamPolicy",
+			Handler:    _IAMPolicy_GetIamPolicy_Handler,
+		},
+		{
+			MethodName: "TestIamPermissions",
+			Handler:    _IAMPolicy_TestIamPermissions_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "google/iam/v1/iam_policy.proto",
+}
+
+func init() { proto.RegisterFile("google/iam/v1/iam_policy.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 396 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x53, 0xcf, 0x4a, 0xe3, 0x40,
+	0x18, 0x67, 0x52, 0x28, 0xdb, 0xe9, 0xee, 0xc2, 0xa6, 0x2c, 0xd4, 0x20, 0x25, 0x8c, 0x1e, 0xd2,
+	0x80, 0x13, 0x53, 0x6f, 0x15, 0x05, 0xeb, 0x21, 0xf4, 0x20, 0x94, 0x2a, 0x82, 0x5e, 0x74, 0xac,
+	0x43, 0x18, 0x48, 0x32, 0x31, 0x33, 0x2d, 0x88, 0x78, 0xf1, 0x15, 0xf4, 0xe4, 0x23, 0xf8, 0x3a,
+	0xbe, 0x82, 0x0f, 0xe1, 0x51, 0x92, 0x89, 0x35, 0x6d, 0xaa, 0x54, 0xf0, 0x54, 0x3a, 0xf3, 0xfb,
+	0xf7, 0xfd, 0xbe, 0x0c, 0x6c, 0xf9, 0x9c, 0xfb, 0x01, 0x75, 0x18, 0x09, 0x9d, 0x89, 0x9b, 0xfe,
+	0x9c, 0xc5, 0x3c, 0x60, 0xa3, 0x6b, 0x1c, 0x27, 0x5c, 0x72, 0xfd, 0x8f, 0xba, 0xc7, 0x8c, 0x84,
+	0x78, 0xe2, 0x1a, 0xab, 0x39, 0x9c, 0xc4, 0xcc, 0x21, 0x51, 0xc4, 0x25, 0x91, 0x8c, 0x47, 0x42,
+	0x81, 0x0d, 0x63, 0x56, 0xac, 0x28, 0x84, 0xce, 0x61, 0xe3, 0x90, 0xca, 0x3e, 0x09, 0x07, 0xd9,
+	0xe9, 0x90, 0x5e, 0x8d, 0xa9, 0x90, 0xba, 0x01, 0x7f, 0x25, 0x54, 0xf0, 0x71, 0x32, 0xa2, 0x4d,
+	0x60, 0x02, 0xab, 0x36, 0x9c, 0xfe, 0xd7, 0x37, 0x60, 0x55, 0x49, 0x34, 0x35, 0x13, 0x58, 0xf5,
+	0xce, 0x7f, 0x3c, 0x13, 0x06, 0xe7, 0x4a, 0x39, 0x08, 0xb9, 0xb0, 0xe1, 0x7d, 0xcf, 0x01, 0x9d,
+	0xc0, 0x95, 0x23, 0x2a, 0x32, 0x0e, 0x4d, 0x42, 0x26, 0x44, 0x3a, 0xcc, 0x32, 0xd1, 0x4c, 0x58,
+	0x8f, 0x3f, 0x18, 0x4d, 0xcd, 0xac, 0x58, 0xb5, 0x61, 0xf1, 0x08, 0xed, 0x42, 0x63, 0x91, 0xb4,
+	0x88, 0x79, 0x24, 0x4a, 0x7c, 0x50, 0xe2, 0x77, 0x1e, 0x2a, 0xb0, 0xd6, 0xdf, 0x3b, 0x50, 0xb3,
+	0xe8, 0x12, 0xfe, 0x2e, 0xb6, 0xa7, 0xa3, 0xb9, 0x2a, 0x16, 0x54, 0x6b, 0x2c, 0xae, 0x0b, 0xb5,
+	0xef, 0x9e, 0x5f, 0xee, 0xb5, 0x35, 0xd4, 0x4a, 0x57, 0x74, 0xf3, 0x3e, 0xd1, 0x8e, 0x6d, 0xdf,
+	0x76, 0x45, 0x41, 0xa5, 0x0b, 0xec, 0xd4, 0xd5, 0xfb, 0xca, 0xd5, 0xfb, 0x11, 0x57, 0x7f, 0xce,
+	0xf5, 0x11, 0x40, 0xbd, 0x5c, 0x9d, 0x6e, 0xcd, 0x09, 0x7f, 0xba, 0x38, 0xa3, 0xbd, 0x04, 0x52,
+	0xed, 0x01, 0x39, 0x59, 0xac, 0x36, 0x5a, 0x2f, 0xc7, 0x92, 0x25, 0x56, 0x17, 0xd8, 0xbd, 0x18,
+	0xfe, 0x1b, 0xf1, 0x70, 0xd6, 0xa0, 0xf7, 0x77, 0x9a, 0x7f, 0x90, 0x7e, 0xeb, 0x03, 0x70, 0xba,
+	0x99, 0x03, 0x7c, 0x1e, 0x90, 0xc8, 0xc7, 0x3c, 0xf1, 0x1d, 0x9f, 0x46, 0xd9, 0x4b, 0x70, 0xd4,
+	0x15, 0x89, 0x99, 0xc8, 0x1f, 0xca, 0x36, 0x23, 0xe1, 0x2b, 0x00, 0x4f, 0x5a, 0xc3, 0x53, 0xac,
+	0xfd, 0x80, 0x8f, 0x2f, 0x71, 0x9f, 0x84, 0xf8, 0xd8, 0xbd, 0xa8, 0x66, 0xac, 0xad, 0xb7, 0x00,
+	0x00, 0x00, 0xff, 0xff, 0x6c, 0x3a, 0x2b, 0x4d, 0xaa, 0x03, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/genproto/googleapis/iam/v1/policy.pb.go b/vendor/google.golang.org/genproto/googleapis/iam/v1/policy.pb.go
new file mode 100644
index 0000000..a22ae91
--- /dev/null
+++ b/vendor/google.golang.org/genproto/googleapis/iam/v1/policy.pb.go
@@ -0,0 +1,269 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/iam/v1/policy.proto
+
+package iam
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import _ "google.golang.org/genproto/googleapis/api/annotations"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// The type of action performed on a Binding in a policy.
+type BindingDelta_Action int32
+
+const (
+	// Unspecified.
+	BindingDelta_ACTION_UNSPECIFIED BindingDelta_Action = 0
+	// Addition of a Binding.
+	BindingDelta_ADD BindingDelta_Action = 1
+	// Removal of a Binding.
+	BindingDelta_REMOVE BindingDelta_Action = 2
+)
+
+var BindingDelta_Action_name = map[int32]string{
+	0: "ACTION_UNSPECIFIED",
+	1: "ADD",
+	2: "REMOVE",
+}
+var BindingDelta_Action_value = map[string]int32{
+	"ACTION_UNSPECIFIED": 0,
+	"ADD":                1,
+	"REMOVE":             2,
+}
+
+func (x BindingDelta_Action) String() string {
+	return proto.EnumName(BindingDelta_Action_name, int32(x))
+}
+func (BindingDelta_Action) EnumDescriptor() ([]byte, []int) { return fileDescriptor1, []int{3, 0} }
+
+// Defines an Identity and Access Management (IAM) policy. It is used to
+// specify access control policies for Cloud Platform resources.
+//
+//
+// A `Policy` consists of a list of `bindings`. A `Binding` binds a list of
+// `members` to a `role`, where the members can be user accounts, Google groups,
+// Google domains, and service accounts. A `role` is a named list of permissions
+// defined by IAM.
+//
+// **Example**
+//
+//     {
+//       "bindings": [
+//         {
+//           "role": "roles/owner",
+//           "members": [
+//             "user:mike@example.com",
+//             "group:admins@example.com",
+//             "domain:google.com",
+//             "serviceAccount:my-other-app@appspot.gserviceaccount.com",
+//           ]
+//         },
+//         {
+//           "role": "roles/viewer",
+//           "members": ["user:sean@example.com"]
+//         }
+//       ]
+//     }
+//
+// For a description of IAM and its features, see the
+// [IAM developer's guide](https://cloud.google.com/iam).
+type Policy struct {
+	// Version of the `Policy`. The default version is 0.
+	Version int32 `protobuf:"varint,1,opt,name=version" json:"version,omitempty"`
+	// Associates a list of `members` to a `role`.
+	// Multiple `bindings` must not be specified for the same `role`.
+	// `bindings` with no members will result in an error.
+	Bindings []*Binding `protobuf:"bytes,4,rep,name=bindings" json:"bindings,omitempty"`
+	// `etag` is used for optimistic concurrency control as a way to help
+	// prevent simultaneous updates of a policy from overwriting each other.
+	// It is strongly suggested that systems make use of the `etag` in the
+	// read-modify-write cycle to perform policy updates in order to avoid race
+	// conditions: An `etag` is returned in the response to `getIamPolicy`, and
+	// systems are expected to put that etag in the request to `setIamPolicy` to
+	// ensure that their change will be applied to the same version of the policy.
+	//
+	// If no `etag` is provided in the call to `setIamPolicy`, then the existing
+	// policy is overwritten blindly.
+	Etag []byte `protobuf:"bytes,3,opt,name=etag,proto3" json:"etag,omitempty"`
+}
+
+func (m *Policy) Reset()                    { *m = Policy{} }
+func (m *Policy) String() string            { return proto.CompactTextString(m) }
+func (*Policy) ProtoMessage()               {}
+func (*Policy) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
+
+func (m *Policy) GetVersion() int32 {
+	if m != nil {
+		return m.Version
+	}
+	return 0
+}
+
+func (m *Policy) GetBindings() []*Binding {
+	if m != nil {
+		return m.Bindings
+	}
+	return nil
+}
+
+func (m *Policy) GetEtag() []byte {
+	if m != nil {
+		return m.Etag
+	}
+	return nil
+}
+
+// Associates `members` with a `role`.
+type Binding struct {
+	// Role that is assigned to `members`.
+	// For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
+	// Required
+	Role string `protobuf:"bytes,1,opt,name=role" json:"role,omitempty"`
+	// Specifies the identities requesting access for a Cloud Platform resource.
+	// `members` can have the following values:
+	//
+	// * `allUsers`: A special identifier that represents anyone who is
+	//    on the internet; with or without a Google account.
+	//
+	// * `allAuthenticatedUsers`: A special identifier that represents anyone
+	//    who is authenticated with a Google account or a service account.
+	//
+	// * `user:{emailid}`: An email address that represents a specific Google
+	//    account. For example, `alice@gmail.com` or `joe@example.com`.
+	//
+	//
+	// * `serviceAccount:{emailid}`: An email address that represents a service
+	//    account. For example, `my-other-app@appspot.gserviceaccount.com`.
+	//
+	// * `group:{emailid}`: An email address that represents a Google group.
+	//    For example, `admins@example.com`.
+	//
+	// * `domain:{domain}`: A Google Apps domain name that represents all the
+	//    users of that domain. For example, `google.com` or `example.com`.
+	//
+	//
+	Members []string `protobuf:"bytes,2,rep,name=members" json:"members,omitempty"`
+}
+
+func (m *Binding) Reset()                    { *m = Binding{} }
+func (m *Binding) String() string            { return proto.CompactTextString(m) }
+func (*Binding) ProtoMessage()               {}
+func (*Binding) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
+
+func (m *Binding) GetRole() string {
+	if m != nil {
+		return m.Role
+	}
+	return ""
+}
+
+func (m *Binding) GetMembers() []string {
+	if m != nil {
+		return m.Members
+	}
+	return nil
+}
+
+// The difference delta between two policies.
+type PolicyDelta struct {
+	// The delta for Bindings between two policies.
+	BindingDeltas []*BindingDelta `protobuf:"bytes,1,rep,name=binding_deltas,json=bindingDeltas" json:"binding_deltas,omitempty"`
+}
+
+func (m *PolicyDelta) Reset()                    { *m = PolicyDelta{} }
+func (m *PolicyDelta) String() string            { return proto.CompactTextString(m) }
+func (*PolicyDelta) ProtoMessage()               {}
+func (*PolicyDelta) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{2} }
+
+func (m *PolicyDelta) GetBindingDeltas() []*BindingDelta {
+	if m != nil {
+		return m.BindingDeltas
+	}
+	return nil
+}
+
+// One delta entry for Binding. Each individual change (only one member in each
+// entry) to a binding will be a separate entry.
+type BindingDelta struct {
+	// The action that was performed on a Binding.
+	// Required
+	Action BindingDelta_Action `protobuf:"varint,1,opt,name=action,enum=google.iam.v1.BindingDelta_Action" json:"action,omitempty"`
+	// Role that is assigned to `members`.
+	// For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
+	// Required
+	Role string `protobuf:"bytes,2,opt,name=role" json:"role,omitempty"`
+	// A single identity requesting access for a Cloud Platform resource.
+	// Follows the same format of Binding.members.
+	// Required
+	Member string `protobuf:"bytes,3,opt,name=member" json:"member,omitempty"`
+}
+
+func (m *BindingDelta) Reset()                    { *m = BindingDelta{} }
+func (m *BindingDelta) String() string            { return proto.CompactTextString(m) }
+func (*BindingDelta) ProtoMessage()               {}
+func (*BindingDelta) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{3} }
+
+func (m *BindingDelta) GetAction() BindingDelta_Action {
+	if m != nil {
+		return m.Action
+	}
+	return BindingDelta_ACTION_UNSPECIFIED
+}
+
+func (m *BindingDelta) GetRole() string {
+	if m != nil {
+		return m.Role
+	}
+	return ""
+}
+
+func (m *BindingDelta) GetMember() string {
+	if m != nil {
+		return m.Member
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*Policy)(nil), "google.iam.v1.Policy")
+	proto.RegisterType((*Binding)(nil), "google.iam.v1.Binding")
+	proto.RegisterType((*PolicyDelta)(nil), "google.iam.v1.PolicyDelta")
+	proto.RegisterType((*BindingDelta)(nil), "google.iam.v1.BindingDelta")
+	proto.RegisterEnum("google.iam.v1.BindingDelta_Action", BindingDelta_Action_name, BindingDelta_Action_value)
+}
+
+func init() { proto.RegisterFile("google/iam/v1/policy.proto", fileDescriptor1) }
+
+var fileDescriptor1 = []byte{
+	// 387 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x52, 0x4d, 0x8f, 0xd3, 0x30,
+	0x10, 0xc5, 0xed, 0x92, 0xd2, 0xd9, 0x0f, 0x15, 0x23, 0x55, 0xd1, 0xc2, 0xa1, 0xca, 0x29, 0x27,
+	0x87, 0x16, 0x21, 0x24, 0x38, 0x35, 0x4d, 0x40, 0x39, 0xb0, 0x1b, 0x0c, 0xec, 0x81, 0xcb, 0xca,
+	0x69, 0x2d, 0xcb, 0x28, 0xb6, 0xa3, 0x24, 0x54, 0xe2, 0x2f, 0x21, 0xf1, 0xff, 0x38, 0xa2, 0xd8,
+	0xee, 0xaa, 0x95, 0x10, 0xb7, 0x79, 0x79, 0xef, 0x65, 0xde, 0xcc, 0x18, 0xae, 0x85, 0x31, 0xa2,
+	0xe6, 0x89, 0x64, 0x2a, 0xd9, 0x2f, 0x93, 0xc6, 0xd4, 0x72, 0xfb, 0x93, 0x34, 0xad, 0xe9, 0x0d,
+	0xbe, 0x74, 0x1c, 0x91, 0x4c, 0x91, 0xfd, 0xf2, 0xfa, 0x85, 0x97, 0xb2, 0x46, 0x26, 0x4c, 0x6b,
+	0xd3, 0xb3, 0x5e, 0x1a, 0xdd, 0x39, 0x71, 0xf4, 0x1d, 0x82, 0xd2, 0x9a, 0x71, 0x08, 0x93, 0x3d,
+	0x6f, 0x3b, 0x69, 0x74, 0x88, 0x16, 0x28, 0x7e, 0x4c, 0x0f, 0x10, 0xaf, 0xe0, 0x49, 0x25, 0xf5,
+	0x4e, 0x6a, 0xd1, 0x85, 0x67, 0x8b, 0x71, 0x7c, 0xbe, 0x9a, 0x93, 0x93, 0x1e, 0x24, 0x75, 0x34,
+	0x7d, 0xd0, 0x61, 0x0c, 0x67, 0xbc, 0x67, 0x22, 0x1c, 0x2f, 0x50, 0x7c, 0x41, 0x6d, 0x1d, 0xbd,
+	0x81, 0x89, 0x17, 0x0e, 0x74, 0x6b, 0x6a, 0x6e, 0x3b, 0x4d, 0xa9, 0xad, 0x87, 0x00, 0x8a, 0xab,
+	0x8a, 0xb7, 0x5d, 0x38, 0x5a, 0x8c, 0xe3, 0x29, 0x3d, 0xc0, 0xe8, 0x13, 0x9c, 0xbb, 0x90, 0x19,
+	0xaf, 0x7b, 0x86, 0x53, 0xb8, 0xf2, 0x7d, 0xee, 0x77, 0xc3, 0x87, 0x2e, 0x44, 0x36, 0xd5, 0xf3,
+	0x7f, 0xa7, 0xb2, 0x26, 0x7a, 0x59, 0x1d, 0xa1, 0x2e, 0xfa, 0x8d, 0xe0, 0xe2, 0x98, 0xc7, 0x6f,
+	0x21, 0x60, 0xdb, 0xfe, 0x30, 0xfd, 0xd5, 0x2a, 0xfa, 0xcf, 0xcf, 0xc8, 0xda, 0x2a, 0xa9, 0x77,
+	0x3c, 0x4c, 0x33, 0x3a, 0x9a, 0x66, 0x0e, 0x81, 0x8b, 0x6f, 0x57, 0x30, 0xa5, 0x1e, 0x45, 0xaf,
+	0x21, 0x70, 0x6e, 0x3c, 0x07, 0xbc, 0xde, 0x7c, 0x29, 0x6e, 0x6f, 0xee, 0xbf, 0xde, 0x7c, 0x2e,
+	0xf3, 0x4d, 0xf1, 0xbe, 0xc8, 0xb3, 0xd9, 0x23, 0x3c, 0x81, 0xf1, 0x3a, 0xcb, 0x66, 0x08, 0x03,
+	0x04, 0x34, 0xff, 0x78, 0x7b, 0x97, 0xcf, 0x46, 0xa9, 0x82, 0xa7, 0x5b, 0xa3, 0x4e, 0x33, 0xa5,
+	0x7e, 0x2b, 0xe5, 0x70, 0xc9, 0x12, 0x7d, 0x7b, 0xe9, 0x59, 0x61, 0x6a, 0xa6, 0x05, 0x31, 0xad,
+	0x48, 0x04, 0xd7, 0xf6, 0xce, 0x89, 0xa3, 0x58, 0x23, 0x3b, 0xff, 0x66, 0xde, 0x49, 0xa6, 0xfe,
+	0x20, 0xf4, 0x6b, 0xf4, 0xec, 0x83, 0x73, 0x6d, 0x6a, 0xf3, 0x63, 0x47, 0x0a, 0xa6, 0xc8, 0xdd,
+	0xb2, 0x0a, 0xac, 0xeb, 0xd5, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8c, 0x4a, 0x85, 0x10, 0x68,
+	0x02, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/genproto/googleapis/pubsub/v1/pubsub.pb.go b/vendor/google.golang.org/genproto/googleapis/pubsub/v1/pubsub.pb.go
new file mode 100644
index 0000000..ab4768d
--- /dev/null
+++ b/vendor/google.golang.org/genproto/googleapis/pubsub/v1/pubsub.pb.go
@@ -0,0 +1,2523 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/pubsub/v1/pubsub.proto
+
+/*
+Package pubsub is a generated protocol buffer package.
+
+It is generated from these files:
+	google/pubsub/v1/pubsub.proto
+
+It has these top-level messages:
+	Topic
+	PubsubMessage
+	GetTopicRequest
+	UpdateTopicRequest
+	PublishRequest
+	PublishResponse
+	ListTopicsRequest
+	ListTopicsResponse
+	ListTopicSubscriptionsRequest
+	ListTopicSubscriptionsResponse
+	DeleteTopicRequest
+	Subscription
+	PushConfig
+	ReceivedMessage
+	GetSubscriptionRequest
+	UpdateSubscriptionRequest
+	ListSubscriptionsRequest
+	ListSubscriptionsResponse
+	DeleteSubscriptionRequest
+	ModifyPushConfigRequest
+	PullRequest
+	PullResponse
+	ModifyAckDeadlineRequest
+	AcknowledgeRequest
+	StreamingPullRequest
+	StreamingPullResponse
+	CreateSnapshotRequest
+	UpdateSnapshotRequest
+	Snapshot
+	ListSnapshotsRequest
+	ListSnapshotsResponse
+	DeleteSnapshotRequest
+	SeekRequest
+	SeekResponse
+*/
+package pubsub
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import _ "google.golang.org/genproto/googleapis/api/annotations"
+import google_protobuf1 "github.com/golang/protobuf/ptypes/duration"
+import google_protobuf2 "github.com/golang/protobuf/ptypes/empty"
+import google_protobuf3 "google.golang.org/genproto/protobuf/field_mask"
+import google_protobuf4 "github.com/golang/protobuf/ptypes/timestamp"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// A topic resource.
+type Topic struct {
+	// The name of the topic. It must have the format
+	// `"projects/{project}/topics/{topic}"`. `{topic}` must start with a letter,
+	// and contain only letters (`[A-Za-z]`), numbers (`[0-9]`), dashes (`-`),
+	// underscores (`_`), periods (`.`), tildes (`~`), plus (`+`) or percent
+	// signs (`%`). It must be between 3 and 255 characters in length, and it
+	// must not start with `"goog"`.
+	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	// User labels.
+	Labels map[string]string `protobuf:"bytes,2,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+}
+
+func (m *Topic) Reset()                    { *m = Topic{} }
+func (m *Topic) String() string            { return proto.CompactTextString(m) }
+func (*Topic) ProtoMessage()               {}
+func (*Topic) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *Topic) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *Topic) GetLabels() map[string]string {
+	if m != nil {
+		return m.Labels
+	}
+	return nil
+}
+
+// A message data and its attributes. The message payload must not be empty;
+// it must contain either a non-empty data field, or at least one attribute.
+type PubsubMessage struct {
+	// The message payload.
+	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
+	// Optional attributes for this message.
+	Attributes map[string]string `protobuf:"bytes,2,rep,name=attributes" json:"attributes,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	// ID of this message, assigned by the server when the message is published.
+	// Guaranteed to be unique within the topic. This value may be read by a
+	// subscriber that receives a `PubsubMessage` via a `Pull` call or a push
+	// delivery. It must not be populated by the publisher in a `Publish` call.
+	MessageId string `protobuf:"bytes,3,opt,name=message_id,json=messageId" json:"message_id,omitempty"`
+	// The time at which the message was published, populated by the server when
+	// it receives the `Publish` call. It must not be populated by the
+	// publisher in a `Publish` call.
+	PublishTime *google_protobuf4.Timestamp `protobuf:"bytes,4,opt,name=publish_time,json=publishTime" json:"publish_time,omitempty"`
+}
+
+func (m *PubsubMessage) Reset()                    { *m = PubsubMessage{} }
+func (m *PubsubMessage) String() string            { return proto.CompactTextString(m) }
+func (*PubsubMessage) ProtoMessage()               {}
+func (*PubsubMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *PubsubMessage) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+func (m *PubsubMessage) GetAttributes() map[string]string {
+	if m != nil {
+		return m.Attributes
+	}
+	return nil
+}
+
+func (m *PubsubMessage) GetMessageId() string {
+	if m != nil {
+		return m.MessageId
+	}
+	return ""
+}
+
+func (m *PubsubMessage) GetPublishTime() *google_protobuf4.Timestamp {
+	if m != nil {
+		return m.PublishTime
+	}
+	return nil
+}
+
+// Request for the GetTopic method.
+type GetTopicRequest struct {
+	// The name of the topic to get.
+	// Format is `projects/{project}/topics/{topic}`.
+	Topic string `protobuf:"bytes,1,opt,name=topic" json:"topic,omitempty"`
+}
+
+func (m *GetTopicRequest) Reset()                    { *m = GetTopicRequest{} }
+func (m *GetTopicRequest) String() string            { return proto.CompactTextString(m) }
+func (*GetTopicRequest) ProtoMessage()               {}
+func (*GetTopicRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+func (m *GetTopicRequest) GetTopic() string {
+	if m != nil {
+		return m.Topic
+	}
+	return ""
+}
+
+// Request for the UpdateTopic method.
+type UpdateTopicRequest struct {
+	// The topic to update.
+	Topic *Topic `protobuf:"bytes,1,opt,name=topic" json:"topic,omitempty"`
+	// Indicates which fields in the provided topic to update.
+	// Must be specified and non-empty.
+	UpdateMask *google_protobuf3.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask" json:"update_mask,omitempty"`
+}
+
+func (m *UpdateTopicRequest) Reset()                    { *m = UpdateTopicRequest{} }
+func (m *UpdateTopicRequest) String() string            { return proto.CompactTextString(m) }
+func (*UpdateTopicRequest) ProtoMessage()               {}
+func (*UpdateTopicRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+func (m *UpdateTopicRequest) GetTopic() *Topic {
+	if m != nil {
+		return m.Topic
+	}
+	return nil
+}
+
+func (m *UpdateTopicRequest) GetUpdateMask() *google_protobuf3.FieldMask {
+	if m != nil {
+		return m.UpdateMask
+	}
+	return nil
+}
+
+// Request for the Publish method.
+type PublishRequest struct {
+	// The messages in the request will be published on this topic.
+	// Format is `projects/{project}/topics/{topic}`.
+	Topic string `protobuf:"bytes,1,opt,name=topic" json:"topic,omitempty"`
+	// The messages to publish.
+	Messages []*PubsubMessage `protobuf:"bytes,2,rep,name=messages" json:"messages,omitempty"`
+}
+
+func (m *PublishRequest) Reset()                    { *m = PublishRequest{} }
+func (m *PublishRequest) String() string            { return proto.CompactTextString(m) }
+func (*PublishRequest) ProtoMessage()               {}
+func (*PublishRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+
+func (m *PublishRequest) GetTopic() string {
+	if m != nil {
+		return m.Topic
+	}
+	return ""
+}
+
+func (m *PublishRequest) GetMessages() []*PubsubMessage {
+	if m != nil {
+		return m.Messages
+	}
+	return nil
+}
+
+// Response for the `Publish` method.
+type PublishResponse struct {
+	// The server-assigned ID of each published message, in the same order as
+	// the messages in the request. IDs are guaranteed to be unique within
+	// the topic.
+	MessageIds []string `protobuf:"bytes,1,rep,name=message_ids,json=messageIds" json:"message_ids,omitempty"`
+}
+
+func (m *PublishResponse) Reset()                    { *m = PublishResponse{} }
+func (m *PublishResponse) String() string            { return proto.CompactTextString(m) }
+func (*PublishResponse) ProtoMessage()               {}
+func (*PublishResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+
+func (m *PublishResponse) GetMessageIds() []string {
+	if m != nil {
+		return m.MessageIds
+	}
+	return nil
+}
+
+// Request for the `ListTopics` method.
+type ListTopicsRequest struct {
+	// The name of the cloud project that topics belong to.
+	// Format is `projects/{project}`.
+	Project string `protobuf:"bytes,1,opt,name=project" json:"project,omitempty"`
+	// Maximum number of topics to return.
+	PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize" json:"page_size,omitempty"`
+	// The value returned by the last `ListTopicsResponse`; indicates that this is
+	// a continuation of a prior `ListTopics` call, and that the system should
+	// return the next page of data.
+	PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken" json:"page_token,omitempty"`
+}
+
+func (m *ListTopicsRequest) Reset()                    { *m = ListTopicsRequest{} }
+func (m *ListTopicsRequest) String() string            { return proto.CompactTextString(m) }
+func (*ListTopicsRequest) ProtoMessage()               {}
+func (*ListTopicsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
+
+func (m *ListTopicsRequest) GetProject() string {
+	if m != nil {
+		return m.Project
+	}
+	return ""
+}
+
+func (m *ListTopicsRequest) GetPageSize() int32 {
+	if m != nil {
+		return m.PageSize
+	}
+	return 0
+}
+
+func (m *ListTopicsRequest) GetPageToken() string {
+	if m != nil {
+		return m.PageToken
+	}
+	return ""
+}
+
+// Response for the `ListTopics` method.
+type ListTopicsResponse struct {
+	// The resulting topics.
+	Topics []*Topic `protobuf:"bytes,1,rep,name=topics" json:"topics,omitempty"`
+	// If not empty, indicates that there may be more topics that match the
+	// request; this value should be passed in a new `ListTopicsRequest`.
+	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken" json:"next_page_token,omitempty"`
+}
+
+func (m *ListTopicsResponse) Reset()                    { *m = ListTopicsResponse{} }
+func (m *ListTopicsResponse) String() string            { return proto.CompactTextString(m) }
+func (*ListTopicsResponse) ProtoMessage()               {}
+func (*ListTopicsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+
+func (m *ListTopicsResponse) GetTopics() []*Topic {
+	if m != nil {
+		return m.Topics
+	}
+	return nil
+}
+
+func (m *ListTopicsResponse) GetNextPageToken() string {
+	if m != nil {
+		return m.NextPageToken
+	}
+	return ""
+}
+
+// Request for the `ListTopicSubscriptions` method.
+type ListTopicSubscriptionsRequest struct {
+	// The name of the topic that subscriptions are attached to.
+	// Format is `projects/{project}/topics/{topic}`.
+	Topic string `protobuf:"bytes,1,opt,name=topic" json:"topic,omitempty"`
+	// Maximum number of subscription names to return.
+	PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize" json:"page_size,omitempty"`
+	// The value returned by the last `ListTopicSubscriptionsResponse`; indicates
+	// that this is a continuation of a prior `ListTopicSubscriptions` call, and
+	// that the system should return the next page of data.
+	PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken" json:"page_token,omitempty"`
+}
+
+func (m *ListTopicSubscriptionsRequest) Reset()                    { *m = ListTopicSubscriptionsRequest{} }
+func (m *ListTopicSubscriptionsRequest) String() string            { return proto.CompactTextString(m) }
+func (*ListTopicSubscriptionsRequest) ProtoMessage()               {}
+func (*ListTopicSubscriptionsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
+
+func (m *ListTopicSubscriptionsRequest) GetTopic() string {
+	if m != nil {
+		return m.Topic
+	}
+	return ""
+}
+
+func (m *ListTopicSubscriptionsRequest) GetPageSize() int32 {
+	if m != nil {
+		return m.PageSize
+	}
+	return 0
+}
+
+func (m *ListTopicSubscriptionsRequest) GetPageToken() string {
+	if m != nil {
+		return m.PageToken
+	}
+	return ""
+}
+
+// Response for the `ListTopicSubscriptions` method.
+type ListTopicSubscriptionsResponse struct {
+	// The names of the subscriptions that match the request.
+	Subscriptions []string `protobuf:"bytes,1,rep,name=subscriptions" json:"subscriptions,omitempty"`
+	// If not empty, indicates that there may be more subscriptions that match
+	// the request; this value should be passed in a new
+	// `ListTopicSubscriptionsRequest` to get more subscriptions.
+	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken" json:"next_page_token,omitempty"`
+}
+
+func (m *ListTopicSubscriptionsResponse) Reset()                    { *m = ListTopicSubscriptionsResponse{} }
+func (m *ListTopicSubscriptionsResponse) String() string            { return proto.CompactTextString(m) }
+func (*ListTopicSubscriptionsResponse) ProtoMessage()               {}
+func (*ListTopicSubscriptionsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
+
+func (m *ListTopicSubscriptionsResponse) GetSubscriptions() []string {
+	if m != nil {
+		return m.Subscriptions
+	}
+	return nil
+}
+
+func (m *ListTopicSubscriptionsResponse) GetNextPageToken() string {
+	if m != nil {
+		return m.NextPageToken
+	}
+	return ""
+}
+
+// Request for the `DeleteTopic` method.
+type DeleteTopicRequest struct {
+	// Name of the topic to delete.
+	// Format is `projects/{project}/topics/{topic}`.
+	Topic string `protobuf:"bytes,1,opt,name=topic" json:"topic,omitempty"`
+}
+
+func (m *DeleteTopicRequest) Reset()                    { *m = DeleteTopicRequest{} }
+func (m *DeleteTopicRequest) String() string            { return proto.CompactTextString(m) }
+func (*DeleteTopicRequest) ProtoMessage()               {}
+func (*DeleteTopicRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
+
+func (m *DeleteTopicRequest) GetTopic() string {
+	if m != nil {
+		return m.Topic
+	}
+	return ""
+}
+
+// A subscription resource.
+type Subscription struct {
+	// The name of the subscription. It must have the format
+	// `"projects/{project}/subscriptions/{subscription}"`. `{subscription}` must
+	// start with a letter, and contain only letters (`[A-Za-z]`), numbers
+	// (`[0-9]`), dashes (`-`), underscores (`_`), periods (`.`), tildes (`~`),
+	// plus (`+`) or percent signs (`%`). It must be between 3 and 255 characters
+	// in length, and it must not start with `"goog"`.
+	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	// The name of the topic from which this subscription is receiving messages.
+	// Format is `projects/{project}/topics/{topic}`.
+	// The value of this field will be `_deleted-topic_` if the topic has been
+	// deleted.
+	Topic string `protobuf:"bytes,2,opt,name=topic" json:"topic,omitempty"`
+	// If push delivery is used with this subscription, this field is
+	// used to configure it. An empty `pushConfig` signifies that the subscriber
+	// will pull and ack messages using API methods.
+	PushConfig *PushConfig `protobuf:"bytes,4,opt,name=push_config,json=pushConfig" json:"push_config,omitempty"`
+	// This value is the maximum time after a subscriber receives a message
+	// before the subscriber should acknowledge the message. After message
+	// delivery but before the ack deadline expires and before the message is
+	// acknowledged, it is an outstanding message and will not be delivered
+	// again during that time (on a best-effort basis).
+	//
+	// For pull subscriptions, this value is used as the initial value for the ack
+	// deadline. To override this value for a given message, call
+	// `ModifyAckDeadline` with the corresponding `ack_id` if using
+	// pull.
+	// The minimum custom deadline you can specify is 10 seconds.
+	// The maximum custom deadline you can specify is 600 seconds (10 minutes).
+	// If this parameter is 0, a default value of 10 seconds is used.
+	//
+	// For push delivery, this value is also used to set the request timeout for
+	// the call to the push endpoint.
+	//
+	// If the subscriber never acknowledges the message, the Pub/Sub
+	// system will eventually redeliver the message.
+	AckDeadlineSeconds int32 `protobuf:"varint,5,opt,name=ack_deadline_seconds,json=ackDeadlineSeconds" json:"ack_deadline_seconds,omitempty"`
+	// Indicates whether to retain acknowledged messages. If true, then
+	// messages are not expunged from the subscription's backlog, even if they are
+	// acknowledged, until they fall out of the `message_retention_duration`
+	// window.
+	RetainAckedMessages bool `protobuf:"varint,7,opt,name=retain_acked_messages,json=retainAckedMessages" json:"retain_acked_messages,omitempty"`
+	// How long to retain unacknowledged messages in the subscription's backlog,
+	// from the moment a message is published.
+	// If `retain_acked_messages` is true, then this also configures the retention
+	// of acknowledged messages, and thus configures how far back in time a `Seek`
+	// can be done. Defaults to 7 days. Cannot be more than 7 days or less than 10
+	// minutes.
+	MessageRetentionDuration *google_protobuf1.Duration `protobuf:"bytes,8,opt,name=message_retention_duration,json=messageRetentionDuration" json:"message_retention_duration,omitempty"`
+	// User labels.
+	Labels map[string]string `protobuf:"bytes,9,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+}
+
+func (m *Subscription) Reset()                    { *m = Subscription{} }
+func (m *Subscription) String() string            { return proto.CompactTextString(m) }
+func (*Subscription) ProtoMessage()               {}
+func (*Subscription) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
+
+func (m *Subscription) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *Subscription) GetTopic() string {
+	if m != nil {
+		return m.Topic
+	}
+	return ""
+}
+
+func (m *Subscription) GetPushConfig() *PushConfig {
+	if m != nil {
+		return m.PushConfig
+	}
+	return nil
+}
+
+func (m *Subscription) GetAckDeadlineSeconds() int32 {
+	if m != nil {
+		return m.AckDeadlineSeconds
+	}
+	return 0
+}
+
+func (m *Subscription) GetRetainAckedMessages() bool {
+	if m != nil {
+		return m.RetainAckedMessages
+	}
+	return false
+}
+
+func (m *Subscription) GetMessageRetentionDuration() *google_protobuf1.Duration {
+	if m != nil {
+		return m.MessageRetentionDuration
+	}
+	return nil
+}
+
+func (m *Subscription) GetLabels() map[string]string {
+	if m != nil {
+		return m.Labels
+	}
+	return nil
+}
+
+// Configuration for a push delivery endpoint.
+type PushConfig struct {
+	// A URL locating the endpoint to which messages should be pushed.
+	// For example, a Webhook endpoint might use "https://example.com/push".
+	PushEndpoint string `protobuf:"bytes,1,opt,name=push_endpoint,json=pushEndpoint" json:"push_endpoint,omitempty"`
+	// Endpoint configuration attributes.
+	//
+	// Every endpoint has a set of API supported attributes that can be used to
+	// control different aspects of the message delivery.
+	//
+	// The currently supported attribute is `x-goog-version`, which you can
+	// use to change the format of the pushed message. This attribute
+	// indicates the version of the data expected by the endpoint. This
+	// controls the shape of the pushed message (i.e., its fields and metadata).
+	// The endpoint version is based on the version of the Pub/Sub API.
+	//
+	// If not present during the `CreateSubscription` call, it will default to
+	// the version of the API used to make such call. If not present during a
+	// `ModifyPushConfig` call, its value will not be changed. `GetSubscription`
+	// calls will always return a valid version, even if the subscription was
+	// created without this attribute.
+	//
+	// The possible values for this attribute are:
+	//
+	// * `v1beta1`: uses the push format defined in the v1beta1 Pub/Sub API.
+	// * `v1` or `v1beta2`: uses the push format defined in the v1 Pub/Sub API.
+	Attributes map[string]string `protobuf:"bytes,2,rep,name=attributes" json:"attributes,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+}
+
+func (m *PushConfig) Reset()                    { *m = PushConfig{} }
+func (m *PushConfig) String() string            { return proto.CompactTextString(m) }
+func (*PushConfig) ProtoMessage()               {}
+func (*PushConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
+
+func (m *PushConfig) GetPushEndpoint() string {
+	if m != nil {
+		return m.PushEndpoint
+	}
+	return ""
+}
+
+func (m *PushConfig) GetAttributes() map[string]string {
+	if m != nil {
+		return m.Attributes
+	}
+	return nil
+}
+
+// A message and its corresponding acknowledgment ID.
+type ReceivedMessage struct {
+	// This ID can be used to acknowledge the received message.
+	AckId string `protobuf:"bytes,1,opt,name=ack_id,json=ackId" json:"ack_id,omitempty"`
+	// The message.
+	Message *PubsubMessage `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
+}
+
+func (m *ReceivedMessage) Reset()                    { *m = ReceivedMessage{} }
+func (m *ReceivedMessage) String() string            { return proto.CompactTextString(m) }
+func (*ReceivedMessage) ProtoMessage()               {}
+func (*ReceivedMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
+
+func (m *ReceivedMessage) GetAckId() string {
+	if m != nil {
+		return m.AckId
+	}
+	return ""
+}
+
+func (m *ReceivedMessage) GetMessage() *PubsubMessage {
+	if m != nil {
+		return m.Message
+	}
+	return nil
+}
+
+// Request for the GetSubscription method.
+type GetSubscriptionRequest struct {
+	// The name of the subscription to get.
+	// Format is `projects/{project}/subscriptions/{sub}`.
+	Subscription string `protobuf:"bytes,1,opt,name=subscription" json:"subscription,omitempty"`
+}
+
+func (m *GetSubscriptionRequest) Reset()                    { *m = GetSubscriptionRequest{} }
+func (m *GetSubscriptionRequest) String() string            { return proto.CompactTextString(m) }
+func (*GetSubscriptionRequest) ProtoMessage()               {}
+func (*GetSubscriptionRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }
+
+func (m *GetSubscriptionRequest) GetSubscription() string {
+	if m != nil {
+		return m.Subscription
+	}
+	return ""
+}
+
+// Request for the UpdateSubscription method.
+type UpdateSubscriptionRequest struct {
+	// The updated subscription object.
+	Subscription *Subscription `protobuf:"bytes,1,opt,name=subscription" json:"subscription,omitempty"`
+	// Indicates which fields in the provided subscription to update.
+	// Must be specified and non-empty.
+	UpdateMask *google_protobuf3.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask" json:"update_mask,omitempty"`
+}
+
+func (m *UpdateSubscriptionRequest) Reset()                    { *m = UpdateSubscriptionRequest{} }
+func (m *UpdateSubscriptionRequest) String() string            { return proto.CompactTextString(m) }
+func (*UpdateSubscriptionRequest) ProtoMessage()               {}
+func (*UpdateSubscriptionRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
+
+func (m *UpdateSubscriptionRequest) GetSubscription() *Subscription {
+	if m != nil {
+		return m.Subscription
+	}
+	return nil
+}
+
+func (m *UpdateSubscriptionRequest) GetUpdateMask() *google_protobuf3.FieldMask {
+	if m != nil {
+		return m.UpdateMask
+	}
+	return nil
+}
+
+// Request for the `ListSubscriptions` method.
+type ListSubscriptionsRequest struct {
+	// The name of the cloud project that subscriptions belong to.
+	// Format is `projects/{project}`.
+	Project string `protobuf:"bytes,1,opt,name=project" json:"project,omitempty"`
+	// Maximum number of subscriptions to return.
+	PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize" json:"page_size,omitempty"`
+	// The value returned by the last `ListSubscriptionsResponse`; indicates that
+	// this is a continuation of a prior `ListSubscriptions` call, and that the
+	// system should return the next page of data.
+	PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken" json:"page_token,omitempty"`
+}
+
+func (m *ListSubscriptionsRequest) Reset()                    { *m = ListSubscriptionsRequest{} }
+func (m *ListSubscriptionsRequest) String() string            { return proto.CompactTextString(m) }
+func (*ListSubscriptionsRequest) ProtoMessage()               {}
+func (*ListSubscriptionsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
+
+func (m *ListSubscriptionsRequest) GetProject() string {
+	if m != nil {
+		return m.Project
+	}
+	return ""
+}
+
+func (m *ListSubscriptionsRequest) GetPageSize() int32 {
+	if m != nil {
+		return m.PageSize
+	}
+	return 0
+}
+
+func (m *ListSubscriptionsRequest) GetPageToken() string {
+	if m != nil {
+		return m.PageToken
+	}
+	return ""
+}
+
+// Response for the `ListSubscriptions` method.
+type ListSubscriptionsResponse struct {
+	// The subscriptions that match the request.
+	Subscriptions []*Subscription `protobuf:"bytes,1,rep,name=subscriptions" json:"subscriptions,omitempty"`
+	// If not empty, indicates that there may be more subscriptions that match
+	// the request; this value should be passed in a new
+	// `ListSubscriptionsRequest` to get more subscriptions.
+	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken" json:"next_page_token,omitempty"`
+}
+
+func (m *ListSubscriptionsResponse) Reset()                    { *m = ListSubscriptionsResponse{} }
+func (m *ListSubscriptionsResponse) String() string            { return proto.CompactTextString(m) }
+func (*ListSubscriptionsResponse) ProtoMessage()               {}
+func (*ListSubscriptionsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }
+
+func (m *ListSubscriptionsResponse) GetSubscriptions() []*Subscription {
+	if m != nil {
+		return m.Subscriptions
+	}
+	return nil
+}
+
+func (m *ListSubscriptionsResponse) GetNextPageToken() string {
+	if m != nil {
+		return m.NextPageToken
+	}
+	return ""
+}
+
+// Request for the DeleteSubscription method.
+type DeleteSubscriptionRequest struct {
+	// The subscription to delete.
+	// Format is `projects/{project}/subscriptions/{sub}`.
+	Subscription string `protobuf:"bytes,1,opt,name=subscription" json:"subscription,omitempty"`
+}
+
+func (m *DeleteSubscriptionRequest) Reset()                    { *m = DeleteSubscriptionRequest{} }
+func (m *DeleteSubscriptionRequest) String() string            { return proto.CompactTextString(m) }
+func (*DeleteSubscriptionRequest) ProtoMessage()               {}
+func (*DeleteSubscriptionRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
+
+func (m *DeleteSubscriptionRequest) GetSubscription() string {
+	if m != nil {
+		return m.Subscription
+	}
+	return ""
+}
+
+// Request for the ModifyPushConfig method.
+type ModifyPushConfigRequest struct {
+	// The name of the subscription.
+	// Format is `projects/{project}/subscriptions/{sub}`.
+	Subscription string `protobuf:"bytes,1,opt,name=subscription" json:"subscription,omitempty"`
+	// The push configuration for future deliveries.
+	//
+	// An empty `pushConfig` indicates that the Pub/Sub system should
+	// stop pushing messages from the given subscription and allow
+	// messages to be pulled and acknowledged - effectively pausing
+	// the subscription if `Pull` is not called.
+	PushConfig *PushConfig `protobuf:"bytes,2,opt,name=push_config,json=pushConfig" json:"push_config,omitempty"`
+}
+
+func (m *ModifyPushConfigRequest) Reset()                    { *m = ModifyPushConfigRequest{} }
+func (m *ModifyPushConfigRequest) String() string            { return proto.CompactTextString(m) }
+func (*ModifyPushConfigRequest) ProtoMessage()               {}
+func (*ModifyPushConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }
+
+func (m *ModifyPushConfigRequest) GetSubscription() string {
+	if m != nil {
+		return m.Subscription
+	}
+	return ""
+}
+
+func (m *ModifyPushConfigRequest) GetPushConfig() *PushConfig {
+	if m != nil {
+		return m.PushConfig
+	}
+	return nil
+}
+
+// Request for the `Pull` method.
+type PullRequest struct {
+	// The subscription from which messages should be pulled.
+	// Format is `projects/{project}/subscriptions/{sub}`.
+	Subscription string `protobuf:"bytes,1,opt,name=subscription" json:"subscription,omitempty"`
+	// If this field set to true, the system will respond immediately even if
+	// it there are no messages available to return in the `Pull` response.
+	// Otherwise, the system may wait (for a bounded amount of time) until at
+	// least one message is available, rather than returning no messages. The
+	// client may cancel the request if it does not wish to wait any longer for
+	// the response.
+	ReturnImmediately bool `protobuf:"varint,2,opt,name=return_immediately,json=returnImmediately" json:"return_immediately,omitempty"`
+	// The maximum number of messages returned for this request. The Pub/Sub
+	// system may return fewer than the number specified.
+	MaxMessages int32 `protobuf:"varint,3,opt,name=max_messages,json=maxMessages" json:"max_messages,omitempty"`
+}
+
+func (m *PullRequest) Reset()                    { *m = PullRequest{} }
+func (m *PullRequest) String() string            { return proto.CompactTextString(m) }
+func (*PullRequest) ProtoMessage()               {}
+func (*PullRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }
+
+func (m *PullRequest) GetSubscription() string {
+	if m != nil {
+		return m.Subscription
+	}
+	return ""
+}
+
+func (m *PullRequest) GetReturnImmediately() bool {
+	if m != nil {
+		return m.ReturnImmediately
+	}
+	return false
+}
+
+func (m *PullRequest) GetMaxMessages() int32 {
+	if m != nil {
+		return m.MaxMessages
+	}
+	return 0
+}
+
+// Response for the `Pull` method.
+type PullResponse struct {
+	// Received Pub/Sub messages. The Pub/Sub system will return zero messages if
+	// there are no more available in the backlog. The Pub/Sub system may return
+	// fewer than the `maxMessages` requested even if there are more messages
+	// available in the backlog.
+	ReceivedMessages []*ReceivedMessage `protobuf:"bytes,1,rep,name=received_messages,json=receivedMessages" json:"received_messages,omitempty"`
+}
+
+func (m *PullResponse) Reset()                    { *m = PullResponse{} }
+func (m *PullResponse) String() string            { return proto.CompactTextString(m) }
+func (*PullResponse) ProtoMessage()               {}
+func (*PullResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }
+
+func (m *PullResponse) GetReceivedMessages() []*ReceivedMessage {
+	if m != nil {
+		return m.ReceivedMessages
+	}
+	return nil
+}
+
+// Request for the ModifyAckDeadline method.
+type ModifyAckDeadlineRequest struct {
+	// The name of the subscription.
+	// Format is `projects/{project}/subscriptions/{sub}`.
+	Subscription string `protobuf:"bytes,1,opt,name=subscription" json:"subscription,omitempty"`
+	// List of acknowledgment IDs.
+	AckIds []string `protobuf:"bytes,4,rep,name=ack_ids,json=ackIds" json:"ack_ids,omitempty"`
+	// The new ack deadline with respect to the time this request was sent to
+	// the Pub/Sub system. For example, if the value is 10, the new
+	// ack deadline will expire 10 seconds after the `ModifyAckDeadline` call
+	// was made. Specifying zero may immediately make the message available for
+	// another pull request.
+	// The minimum deadline you can specify is 0 seconds.
+	// The maximum deadline you can specify is 600 seconds (10 minutes).
+	AckDeadlineSeconds int32 `protobuf:"varint,3,opt,name=ack_deadline_seconds,json=ackDeadlineSeconds" json:"ack_deadline_seconds,omitempty"`
+}
+
+func (m *ModifyAckDeadlineRequest) Reset()                    { *m = ModifyAckDeadlineRequest{} }
+func (m *ModifyAckDeadlineRequest) String() string            { return proto.CompactTextString(m) }
+func (*ModifyAckDeadlineRequest) ProtoMessage()               {}
+func (*ModifyAckDeadlineRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} }
+
+func (m *ModifyAckDeadlineRequest) GetSubscription() string {
+	if m != nil {
+		return m.Subscription
+	}
+	return ""
+}
+
+func (m *ModifyAckDeadlineRequest) GetAckIds() []string {
+	if m != nil {
+		return m.AckIds
+	}
+	return nil
+}
+
+func (m *ModifyAckDeadlineRequest) GetAckDeadlineSeconds() int32 {
+	if m != nil {
+		return m.AckDeadlineSeconds
+	}
+	return 0
+}
+
+// Request for the Acknowledge method.
+type AcknowledgeRequest struct {
+	// The subscription whose message is being acknowledged.
+	// Format is `projects/{project}/subscriptions/{sub}`.
+	Subscription string `protobuf:"bytes,1,opt,name=subscription" json:"subscription,omitempty"`
+	// The acknowledgment ID for the messages being acknowledged that was returned
+	// by the Pub/Sub system in the `Pull` response. Must not be empty.
+	AckIds []string `protobuf:"bytes,2,rep,name=ack_ids,json=ackIds" json:"ack_ids,omitempty"`
+}
+
+func (m *AcknowledgeRequest) Reset()                    { *m = AcknowledgeRequest{} }
+func (m *AcknowledgeRequest) String() string            { return proto.CompactTextString(m) }
+func (*AcknowledgeRequest) ProtoMessage()               {}
+func (*AcknowledgeRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} }
+
+func (m *AcknowledgeRequest) GetSubscription() string {
+	if m != nil {
+		return m.Subscription
+	}
+	return ""
+}
+
+func (m *AcknowledgeRequest) GetAckIds() []string {
+	if m != nil {
+		return m.AckIds
+	}
+	return nil
+}
+
+// Request for the `StreamingPull` streaming RPC method. This request is used to
+// establish the initial stream as well as to stream acknowledgements and ack
+// deadline modifications from the client to the server.
+type StreamingPullRequest struct {
+	// The subscription for which to initialize the new stream. This must be
+	// provided in the first request on the stream, and must not be set in
+	// subsequent requests from client to server.
+	// Format is `projects/{project}/subscriptions/{sub}`.
+	Subscription string `protobuf:"bytes,1,opt,name=subscription" json:"subscription,omitempty"`
+	// List of acknowledgement IDs for acknowledging previously received messages
+	// (received on this stream or a different stream). If an ack ID has expired,
+	// the corresponding message may be redelivered later. Acknowledging a message
+	// more than once will not result in an error. If the acknowledgement ID is
+	// malformed, the stream will be aborted with status `INVALID_ARGUMENT`.
+	AckIds []string `protobuf:"bytes,2,rep,name=ack_ids,json=ackIds" json:"ack_ids,omitempty"`
+	// The list of new ack deadlines for the IDs listed in
+	// `modify_deadline_ack_ids`. The size of this list must be the same as the
+	// size of `modify_deadline_ack_ids`. If it differs the stream will be aborted
+	// with `INVALID_ARGUMENT`. Each element in this list is applied to the
+	// element in the same position in `modify_deadline_ack_ids`. The new ack
+	// deadline is with respect to the time this request was sent to the Pub/Sub
+	// system. Must be >= 0. For example, if the value is 10, the new ack deadline
+	// will expire 10 seconds after this request is received. If the value is 0,
+	// the message is immediately made available for another streaming or
+	// non-streaming pull request. If the value is < 0 (an error), the stream will
+	// be aborted with status `INVALID_ARGUMENT`.
+	ModifyDeadlineSeconds []int32 `protobuf:"varint,3,rep,packed,name=modify_deadline_seconds,json=modifyDeadlineSeconds" json:"modify_deadline_seconds,omitempty"`
+	// List of acknowledgement IDs whose deadline will be modified based on the
+	// corresponding element in `modify_deadline_seconds`. This field can be used
+	// to indicate that more time is needed to process a message by the
+	// subscriber, or to make the message available for redelivery if the
+	// processing was interrupted.
+	ModifyDeadlineAckIds []string `protobuf:"bytes,4,rep,name=modify_deadline_ack_ids,json=modifyDeadlineAckIds" json:"modify_deadline_ack_ids,omitempty"`
+	// The ack deadline to use for the stream. This must be provided in the
+	// first request on the stream, but it can also be updated on subsequent
+	// requests from client to server. The minimum deadline you can specify is 10
+	// seconds. The maximum deadline you can specify is 600 seconds (10 minutes).
+	StreamAckDeadlineSeconds int32 `protobuf:"varint,5,opt,name=stream_ack_deadline_seconds,json=streamAckDeadlineSeconds" json:"stream_ack_deadline_seconds,omitempty"`
+}
+
+func (m *StreamingPullRequest) Reset()                    { *m = StreamingPullRequest{} }
+func (m *StreamingPullRequest) String() string            { return proto.CompactTextString(m) }
+func (*StreamingPullRequest) ProtoMessage()               {}
+func (*StreamingPullRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} }
+
+func (m *StreamingPullRequest) GetSubscription() string {
+	if m != nil {
+		return m.Subscription
+	}
+	return ""
+}
+
+func (m *StreamingPullRequest) GetAckIds() []string {
+	if m != nil {
+		return m.AckIds
+	}
+	return nil
+}
+
+func (m *StreamingPullRequest) GetModifyDeadlineSeconds() []int32 {
+	if m != nil {
+		return m.ModifyDeadlineSeconds
+	}
+	return nil
+}
+
+func (m *StreamingPullRequest) GetModifyDeadlineAckIds() []string {
+	if m != nil {
+		return m.ModifyDeadlineAckIds
+	}
+	return nil
+}
+
+func (m *StreamingPullRequest) GetStreamAckDeadlineSeconds() int32 {
+	if m != nil {
+		return m.StreamAckDeadlineSeconds
+	}
+	return 0
+}
+
+// Response for the `StreamingPull` method. This response is used to stream
+// messages from the server to the client.
+type StreamingPullResponse struct {
+	// Received Pub/Sub messages. This will not be empty.
+	ReceivedMessages []*ReceivedMessage `protobuf:"bytes,1,rep,name=received_messages,json=receivedMessages" json:"received_messages,omitempty"`
+}
+
+func (m *StreamingPullResponse) Reset()                    { *m = StreamingPullResponse{} }
+func (m *StreamingPullResponse) String() string            { return proto.CompactTextString(m) }
+func (*StreamingPullResponse) ProtoMessage()               {}
+func (*StreamingPullResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} }
+
+func (m *StreamingPullResponse) GetReceivedMessages() []*ReceivedMessage {
+	if m != nil {
+		return m.ReceivedMessages
+	}
+	return nil
+}
+
+// Request for the `CreateSnapshot` method.
+type CreateSnapshotRequest struct {
+	// Optional user-provided name for this snapshot.
+	// If the name is not provided in the request, the server will assign a random
+	// name for this snapshot on the same project as the subscription.
+	// Note that for REST API requests, you must specify a name.
+	// Format is `projects/{project}/snapshots/{snap}`.
+	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	// The subscription whose backlog the snapshot retains.
+	// Specifically, the created snapshot is guaranteed to retain:
+	//  (a) The existing backlog on the subscription. More precisely, this is
+	//      defined as the messages in the subscription's backlog that are
+	//      unacknowledged upon the successful completion of the
+	//      `CreateSnapshot` request; as well as:
+	//  (b) Any messages published to the subscription's topic following the
+	//      successful completion of the CreateSnapshot request.
+	// Format is `projects/{project}/subscriptions/{sub}`.
+	Subscription string `protobuf:"bytes,2,opt,name=subscription" json:"subscription,omitempty"`
+}
+
+func (m *CreateSnapshotRequest) Reset()                    { *m = CreateSnapshotRequest{} }
+func (m *CreateSnapshotRequest) String() string            { return proto.CompactTextString(m) }
+func (*CreateSnapshotRequest) ProtoMessage()               {}
+func (*CreateSnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} }
+
+func (m *CreateSnapshotRequest) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *CreateSnapshotRequest) GetSubscription() string {
+	if m != nil {
+		return m.Subscription
+	}
+	return ""
+}
+
+// Request for the UpdateSnapshot method.
+type UpdateSnapshotRequest struct {
+	// The updated snpashot object.
+	Snapshot *Snapshot `protobuf:"bytes,1,opt,name=snapshot" json:"snapshot,omitempty"`
+	// Indicates which fields in the provided snapshot to update.
+	// Must be specified and non-empty.
+	UpdateMask *google_protobuf3.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask" json:"update_mask,omitempty"`
+}
+
+func (m *UpdateSnapshotRequest) Reset()                    { *m = UpdateSnapshotRequest{} }
+func (m *UpdateSnapshotRequest) String() string            { return proto.CompactTextString(m) }
+func (*UpdateSnapshotRequest) ProtoMessage()               {}
+func (*UpdateSnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} }
+
+func (m *UpdateSnapshotRequest) GetSnapshot() *Snapshot {
+	if m != nil {
+		return m.Snapshot
+	}
+	return nil
+}
+
+func (m *UpdateSnapshotRequest) GetUpdateMask() *google_protobuf3.FieldMask {
+	if m != nil {
+		return m.UpdateMask
+	}
+	return nil
+}
+
+// A snapshot resource.
+type Snapshot struct {
+	// The name of the snapshot.
+	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	// The name of the topic from which this snapshot is retaining messages.
+	Topic string `protobuf:"bytes,2,opt,name=topic" json:"topic,omitempty"`
+	// The snapshot is guaranteed to exist up until this time.
+	// A newly-created snapshot expires no later than 7 days from the time of its
+	// creation. Its exact lifetime is determined at creation by the existing
+	// backlog in the source subscription. Specifically, the lifetime of the
+	// snapshot is `7 days - (age of oldest unacked message in the subscription)`.
+	// For example, consider a subscription whose oldest unacked message is 3 days
+	// old. If a snapshot is created from this subscription, the snapshot -- which
+	// will always capture this 3-day-old backlog as long as the snapshot
+	// exists -- will expire in 4 days.
+	ExpireTime *google_protobuf4.Timestamp `protobuf:"bytes,3,opt,name=expire_time,json=expireTime" json:"expire_time,omitempty"`
+	// User labels.
+	Labels map[string]string `protobuf:"bytes,4,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+}
+
+func (m *Snapshot) Reset()                    { *m = Snapshot{} }
+func (m *Snapshot) String() string            { return proto.CompactTextString(m) }
+func (*Snapshot) ProtoMessage()               {}
+func (*Snapshot) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} }
+
+func (m *Snapshot) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *Snapshot) GetTopic() string {
+	if m != nil {
+		return m.Topic
+	}
+	return ""
+}
+
+func (m *Snapshot) GetExpireTime() *google_protobuf4.Timestamp {
+	if m != nil {
+		return m.ExpireTime
+	}
+	return nil
+}
+
+func (m *Snapshot) GetLabels() map[string]string {
+	if m != nil {
+		return m.Labels
+	}
+	return nil
+}
+
+// Request for the `ListSnapshots` method.
+type ListSnapshotsRequest struct {
+	// The name of the cloud project that snapshots belong to.
+	// Format is `projects/{project}`.
+	Project string `protobuf:"bytes,1,opt,name=project" json:"project,omitempty"`
+	// Maximum number of snapshots to return.
+	PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize" json:"page_size,omitempty"`
+	// The value returned by the last `ListSnapshotsResponse`; indicates that this
+	// is a continuation of a prior `ListSnapshots` call, and that the system
+	// should return the next page of data.
+	PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken" json:"page_token,omitempty"`
+}
+
+func (m *ListSnapshotsRequest) Reset()                    { *m = ListSnapshotsRequest{} }
+func (m *ListSnapshotsRequest) String() string            { return proto.CompactTextString(m) }
+func (*ListSnapshotsRequest) ProtoMessage()               {}
+func (*ListSnapshotsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{29} }
+
+func (m *ListSnapshotsRequest) GetProject() string {
+	if m != nil {
+		return m.Project
+	}
+	return ""
+}
+
+func (m *ListSnapshotsRequest) GetPageSize() int32 {
+	if m != nil {
+		return m.PageSize
+	}
+	return 0
+}
+
+func (m *ListSnapshotsRequest) GetPageToken() string {
+	if m != nil {
+		return m.PageToken
+	}
+	return ""
+}
+
+// Response for the `ListSnapshots` method.
+type ListSnapshotsResponse struct {
+	// The resulting snapshots.
+	Snapshots []*Snapshot `protobuf:"bytes,1,rep,name=snapshots" json:"snapshots,omitempty"`
+	// If not empty, indicates that there may be more snapshot that match the
+	// request; this value should be passed in a new `ListSnapshotsRequest`.
+	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken" json:"next_page_token,omitempty"`
+}
+
+func (m *ListSnapshotsResponse) Reset()                    { *m = ListSnapshotsResponse{} }
+func (m *ListSnapshotsResponse) String() string            { return proto.CompactTextString(m) }
+func (*ListSnapshotsResponse) ProtoMessage()               {}
+func (*ListSnapshotsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{30} }
+
+func (m *ListSnapshotsResponse) GetSnapshots() []*Snapshot {
+	if m != nil {
+		return m.Snapshots
+	}
+	return nil
+}
+
+func (m *ListSnapshotsResponse) GetNextPageToken() string {
+	if m != nil {
+		return m.NextPageToken
+	}
+	return ""
+}
+
+// Request for the `DeleteSnapshot` method.
+type DeleteSnapshotRequest struct {
+	// The name of the snapshot to delete.
+	// Format is `projects/{project}/snapshots/{snap}`.
+	Snapshot string `protobuf:"bytes,1,opt,name=snapshot" json:"snapshot,omitempty"`
+}
+
+func (m *DeleteSnapshotRequest) Reset()                    { *m = DeleteSnapshotRequest{} }
+func (m *DeleteSnapshotRequest) String() string            { return proto.CompactTextString(m) }
+func (*DeleteSnapshotRequest) ProtoMessage()               {}
+func (*DeleteSnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} }
+
+func (m *DeleteSnapshotRequest) GetSnapshot() string {
+	if m != nil {
+		return m.Snapshot
+	}
+	return ""
+}
+
+// Request for the `Seek` method.
+type SeekRequest struct {
+	// The subscription to affect.
+	Subscription string `protobuf:"bytes,1,opt,name=subscription" json:"subscription,omitempty"`
+	// Types that are valid to be assigned to Target:
+	//	*SeekRequest_Time
+	//	*SeekRequest_Snapshot
+	Target isSeekRequest_Target `protobuf_oneof:"target"`
+}
+
+func (m *SeekRequest) Reset()                    { *m = SeekRequest{} }
+func (m *SeekRequest) String() string            { return proto.CompactTextString(m) }
+func (*SeekRequest) ProtoMessage()               {}
+func (*SeekRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{32} }
+
+type isSeekRequest_Target interface {
+	isSeekRequest_Target()
+}
+
+type SeekRequest_Time struct {
+	Time *google_protobuf4.Timestamp `protobuf:"bytes,2,opt,name=time,oneof"`
+}
+type SeekRequest_Snapshot struct {
+	Snapshot string `protobuf:"bytes,3,opt,name=snapshot,oneof"`
+}
+
+func (*SeekRequest_Time) isSeekRequest_Target()     {}
+func (*SeekRequest_Snapshot) isSeekRequest_Target() {}
+
+func (m *SeekRequest) GetTarget() isSeekRequest_Target {
+	if m != nil {
+		return m.Target
+	}
+	return nil
+}
+
+func (m *SeekRequest) GetSubscription() string {
+	if m != nil {
+		return m.Subscription
+	}
+	return ""
+}
+
+func (m *SeekRequest) GetTime() *google_protobuf4.Timestamp {
+	if x, ok := m.GetTarget().(*SeekRequest_Time); ok {
+		return x.Time
+	}
+	return nil
+}
+
+func (m *SeekRequest) GetSnapshot() string {
+	if x, ok := m.GetTarget().(*SeekRequest_Snapshot); ok {
+		return x.Snapshot
+	}
+	return ""
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*SeekRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _SeekRequest_OneofMarshaler, _SeekRequest_OneofUnmarshaler, _SeekRequest_OneofSizer, []interface{}{
+		(*SeekRequest_Time)(nil),
+		(*SeekRequest_Snapshot)(nil),
+	}
+}
+
+func _SeekRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*SeekRequest)
+	// target
+	switch x := m.Target.(type) {
+	case *SeekRequest_Time:
+		b.EncodeVarint(2<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Time); err != nil {
+			return err
+		}
+	case *SeekRequest_Snapshot:
+		b.EncodeVarint(3<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.Snapshot)
+	case nil:
+	default:
+		return fmt.Errorf("SeekRequest.Target has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _SeekRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*SeekRequest)
+	switch tag {
+	case 2: // target.time
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(google_protobuf4.Timestamp)
+		err := b.DecodeMessage(msg)
+		m.Target = &SeekRequest_Time{msg}
+		return true, err
+	case 3: // target.snapshot
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.Target = &SeekRequest_Snapshot{x}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _SeekRequest_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*SeekRequest)
+	// target
+	switch x := m.Target.(type) {
+	case *SeekRequest_Time:
+		s := proto.Size(x.Time)
+		n += proto.SizeVarint(2<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *SeekRequest_Snapshot:
+		n += proto.SizeVarint(3<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.Snapshot)))
+		n += len(x.Snapshot)
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+type SeekResponse struct {
+}
+
+func (m *SeekResponse) Reset()                    { *m = SeekResponse{} }
+func (m *SeekResponse) String() string            { return proto.CompactTextString(m) }
+func (*SeekResponse) ProtoMessage()               {}
+func (*SeekResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{33} }
+
+func init() {
+	proto.RegisterType((*Topic)(nil), "google.pubsub.v1.Topic")
+	proto.RegisterType((*PubsubMessage)(nil), "google.pubsub.v1.PubsubMessage")
+	proto.RegisterType((*GetTopicRequest)(nil), "google.pubsub.v1.GetTopicRequest")
+	proto.RegisterType((*UpdateTopicRequest)(nil), "google.pubsub.v1.UpdateTopicRequest")
+	proto.RegisterType((*PublishRequest)(nil), "google.pubsub.v1.PublishRequest")
+	proto.RegisterType((*PublishResponse)(nil), "google.pubsub.v1.PublishResponse")
+	proto.RegisterType((*ListTopicsRequest)(nil), "google.pubsub.v1.ListTopicsRequest")
+	proto.RegisterType((*ListTopicsResponse)(nil), "google.pubsub.v1.ListTopicsResponse")
+	proto.RegisterType((*ListTopicSubscriptionsRequest)(nil), "google.pubsub.v1.ListTopicSubscriptionsRequest")
+	proto.RegisterType((*ListTopicSubscriptionsResponse)(nil), "google.pubsub.v1.ListTopicSubscriptionsResponse")
+	proto.RegisterType((*DeleteTopicRequest)(nil), "google.pubsub.v1.DeleteTopicRequest")
+	proto.RegisterType((*Subscription)(nil), "google.pubsub.v1.Subscription")
+	proto.RegisterType((*PushConfig)(nil), "google.pubsub.v1.PushConfig")
+	proto.RegisterType((*ReceivedMessage)(nil), "google.pubsub.v1.ReceivedMessage")
+	proto.RegisterType((*GetSubscriptionRequest)(nil), "google.pubsub.v1.GetSubscriptionRequest")
+	proto.RegisterType((*UpdateSubscriptionRequest)(nil), "google.pubsub.v1.UpdateSubscriptionRequest")
+	proto.RegisterType((*ListSubscriptionsRequest)(nil), "google.pubsub.v1.ListSubscriptionsRequest")
+	proto.RegisterType((*ListSubscriptionsResponse)(nil), "google.pubsub.v1.ListSubscriptionsResponse")
+	proto.RegisterType((*DeleteSubscriptionRequest)(nil), "google.pubsub.v1.DeleteSubscriptionRequest")
+	proto.RegisterType((*ModifyPushConfigRequest)(nil), "google.pubsub.v1.ModifyPushConfigRequest")
+	proto.RegisterType((*PullRequest)(nil), "google.pubsub.v1.PullRequest")
+	proto.RegisterType((*PullResponse)(nil), "google.pubsub.v1.PullResponse")
+	proto.RegisterType((*ModifyAckDeadlineRequest)(nil), "google.pubsub.v1.ModifyAckDeadlineRequest")
+	proto.RegisterType((*AcknowledgeRequest)(nil), "google.pubsub.v1.AcknowledgeRequest")
+	proto.RegisterType((*StreamingPullRequest)(nil), "google.pubsub.v1.StreamingPullRequest")
+	proto.RegisterType((*StreamingPullResponse)(nil), "google.pubsub.v1.StreamingPullResponse")
+	proto.RegisterType((*CreateSnapshotRequest)(nil), "google.pubsub.v1.CreateSnapshotRequest")
+	proto.RegisterType((*UpdateSnapshotRequest)(nil), "google.pubsub.v1.UpdateSnapshotRequest")
+	proto.RegisterType((*Snapshot)(nil), "google.pubsub.v1.Snapshot")
+	proto.RegisterType((*ListSnapshotsRequest)(nil), "google.pubsub.v1.ListSnapshotsRequest")
+	proto.RegisterType((*ListSnapshotsResponse)(nil), "google.pubsub.v1.ListSnapshotsResponse")
+	proto.RegisterType((*DeleteSnapshotRequest)(nil), "google.pubsub.v1.DeleteSnapshotRequest")
+	proto.RegisterType((*SeekRequest)(nil), "google.pubsub.v1.SeekRequest")
+	proto.RegisterType((*SeekResponse)(nil), "google.pubsub.v1.SeekResponse")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for Subscriber service
+
+type SubscriberClient interface {
+	// Creates a subscription to a given topic.
+	// If the subscription already exists, returns `ALREADY_EXISTS`.
+	// If the corresponding topic doesn't exist, returns `NOT_FOUND`.
+	//
+	// If the name is not provided in the request, the server will assign a random
+	// name for this subscription on the same project as the topic, conforming
+	// to the
+	// [resource name format](https://cloud.google.com/pubsub/docs/overview#names).
+	// The generated name is populated in the returned Subscription object.
+	// Note that for REST API requests, you must specify a name in the request.
+	CreateSubscription(ctx context.Context, in *Subscription, opts ...grpc.CallOption) (*Subscription, error)
+	// Gets the configuration details of a subscription.
+	GetSubscription(ctx context.Context, in *GetSubscriptionRequest, opts ...grpc.CallOption) (*Subscription, error)
+	// Updates an existing subscription. Note that certain properties of a
+	// subscription, such as its topic, are not modifiable.
+	// NOTE:  The style guide requires body: "subscription" instead of body: "*".
+	// Keeping the latter for internal consistency in V1, however it should be
+	// corrected in V2.  See
+	// https://cloud.google.com/apis/design/standard_methods#update for details.
+	UpdateSubscription(ctx context.Context, in *UpdateSubscriptionRequest, opts ...grpc.CallOption) (*Subscription, error)
+	// Lists matching subscriptions.
+	ListSubscriptions(ctx context.Context, in *ListSubscriptionsRequest, opts ...grpc.CallOption) (*ListSubscriptionsResponse, error)
+	// Deletes an existing subscription. All messages retained in the subscription
+	// are immediately dropped. Calls to `Pull` after deletion will return
+	// `NOT_FOUND`. After a subscription is deleted, a new one may be created with
+	// the same name, but the new one has no association with the old
+	// subscription or its topic unless the same topic is specified.
+	DeleteSubscription(ctx context.Context, in *DeleteSubscriptionRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error)
+	// Modifies the ack deadline for a specific message. This method is useful
+	// to indicate that more time is needed to process a message by the
+	// subscriber, or to make the message available for redelivery if the
+	// processing was interrupted. Note that this does not modify the
+	// subscription-level `ackDeadlineSeconds` used for subsequent messages.
+	ModifyAckDeadline(ctx context.Context, in *ModifyAckDeadlineRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error)
+	// Acknowledges the messages associated with the `ack_ids` in the
+	// `AcknowledgeRequest`. The Pub/Sub system can remove the relevant messages
+	// from the subscription.
+	//
+	// Acknowledging a message whose ack deadline has expired may succeed,
+	// but such a message may be redelivered later. Acknowledging a message more
+	// than once will not result in an error.
+	Acknowledge(ctx context.Context, in *AcknowledgeRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error)
+	// Pulls messages from the server. Returns an empty list if there are no
+	// messages available in the backlog. The server may return `UNAVAILABLE` if
+	// there are too many concurrent pull requests pending for the given
+	// subscription.
+	Pull(ctx context.Context, in *PullRequest, opts ...grpc.CallOption) (*PullResponse, error)
+	// (EXPERIMENTAL) StreamingPull is an experimental feature. This RPC will
+	// respond with UNIMPLEMENTED errors unless you have been invited to test
+	// this feature. Contact cloud-pubsub@google.com with any questions.
+	//
+	// Establishes a stream with the server, which sends messages down to the
+	// client. The client streams acknowledgements and ack deadline modifications
+	// back to the server. The server will close the stream and return the status
+	// on any error. The server may close the stream with status `OK` to reassign
+	// server-side resources, in which case, the client should re-establish the
+	// stream. `UNAVAILABLE` may also be returned in the case of a transient error
+	// (e.g., a server restart). These should also be retried by the client. Flow
+	// control can be achieved by configuring the underlying RPC channel.
+	StreamingPull(ctx context.Context, opts ...grpc.CallOption) (Subscriber_StreamingPullClient, error)
+	// Modifies the `PushConfig` for a specified subscription.
+	//
+	// This may be used to change a push subscription to a pull one (signified by
+	// an empty `PushConfig`) or vice versa, or change the endpoint URL and other
+	// attributes of a push subscription. Messages will accumulate for delivery
+	// continuously through the call regardless of changes to the `PushConfig`.
+	ModifyPushConfig(ctx context.Context, in *ModifyPushConfigRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error)
+	// Lists the existing snapshots.
+	ListSnapshots(ctx context.Context, in *ListSnapshotsRequest, opts ...grpc.CallOption) (*ListSnapshotsResponse, error)
+	// Creates a snapshot from the requested subscription.
+	// If the snapshot already exists, returns `ALREADY_EXISTS`.
+	// If the requested subscription doesn't exist, returns `NOT_FOUND`.
+	//
+	// If the name is not provided in the request, the server will assign a random
+	// name for this snapshot on the same project as the subscription, conforming
+	// to the
+	// [resource name format](https://cloud.google.com/pubsub/docs/overview#names).
+	// The generated name is populated in the returned Snapshot object.
+	// Note that for REST API requests, you must specify a name in the request.
+	CreateSnapshot(ctx context.Context, in *CreateSnapshotRequest, opts ...grpc.CallOption) (*Snapshot, error)
+	// Updates an existing snapshot. Note that certain properties of a snapshot
+	// are not modifiable.
+	// NOTE:  The style guide requires body: "snapshot" instead of body: "*".
+	// Keeping the latter for internal consistency in V1, however it should be
+	// corrected in V2.  See
+	// https://cloud.google.com/apis/design/standard_methods#update for details.
+	UpdateSnapshot(ctx context.Context, in *UpdateSnapshotRequest, opts ...grpc.CallOption) (*Snapshot, error)
+	// Removes an existing snapshot. All messages retained in the snapshot
+	// are immediately dropped. After a snapshot is deleted, a new one may be
+	// created with the same name, but the new one has no association with the old
+	// snapshot or its subscription, unless the same subscription is specified.
+	DeleteSnapshot(ctx context.Context, in *DeleteSnapshotRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error)
+	// Seeks an existing subscription to a point in time or to a given snapshot,
+	// whichever is provided in the request.
+	Seek(ctx context.Context, in *SeekRequest, opts ...grpc.CallOption) (*SeekResponse, error)
+}
+
+type subscriberClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewSubscriberClient(cc *grpc.ClientConn) SubscriberClient {
+	return &subscriberClient{cc}
+}
+
+func (c *subscriberClient) CreateSubscription(ctx context.Context, in *Subscription, opts ...grpc.CallOption) (*Subscription, error) {
+	out := new(Subscription)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Subscriber/CreateSubscription", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *subscriberClient) GetSubscription(ctx context.Context, in *GetSubscriptionRequest, opts ...grpc.CallOption) (*Subscription, error) {
+	out := new(Subscription)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Subscriber/GetSubscription", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *subscriberClient) UpdateSubscription(ctx context.Context, in *UpdateSubscriptionRequest, opts ...grpc.CallOption) (*Subscription, error) {
+	out := new(Subscription)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Subscriber/UpdateSubscription", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *subscriberClient) ListSubscriptions(ctx context.Context, in *ListSubscriptionsRequest, opts ...grpc.CallOption) (*ListSubscriptionsResponse, error) {
+	out := new(ListSubscriptionsResponse)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Subscriber/ListSubscriptions", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *subscriberClient) DeleteSubscription(ctx context.Context, in *DeleteSubscriptionRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) {
+	out := new(google_protobuf2.Empty)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Subscriber/DeleteSubscription", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *subscriberClient) ModifyAckDeadline(ctx context.Context, in *ModifyAckDeadlineRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) {
+	out := new(google_protobuf2.Empty)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Subscriber/ModifyAckDeadline", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *subscriberClient) Acknowledge(ctx context.Context, in *AcknowledgeRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) {
+	out := new(google_protobuf2.Empty)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Subscriber/Acknowledge", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *subscriberClient) Pull(ctx context.Context, in *PullRequest, opts ...grpc.CallOption) (*PullResponse, error) {
+	out := new(PullResponse)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Subscriber/Pull", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *subscriberClient) StreamingPull(ctx context.Context, opts ...grpc.CallOption) (Subscriber_StreamingPullClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_Subscriber_serviceDesc.Streams[0], c.cc, "/google.pubsub.v1.Subscriber/StreamingPull", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &subscriberStreamingPullClient{stream}
+	return x, nil
+}
+
+type Subscriber_StreamingPullClient interface {
+	Send(*StreamingPullRequest) error
+	Recv() (*StreamingPullResponse, error)
+	grpc.ClientStream
+}
+
+type subscriberStreamingPullClient struct {
+	grpc.ClientStream
+}
+
+func (x *subscriberStreamingPullClient) Send(m *StreamingPullRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *subscriberStreamingPullClient) Recv() (*StreamingPullResponse, error) {
+	m := new(StreamingPullResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *subscriberClient) ModifyPushConfig(ctx context.Context, in *ModifyPushConfigRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) {
+	out := new(google_protobuf2.Empty)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Subscriber/ModifyPushConfig", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *subscriberClient) ListSnapshots(ctx context.Context, in *ListSnapshotsRequest, opts ...grpc.CallOption) (*ListSnapshotsResponse, error) {
+	out := new(ListSnapshotsResponse)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Subscriber/ListSnapshots", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *subscriberClient) CreateSnapshot(ctx context.Context, in *CreateSnapshotRequest, opts ...grpc.CallOption) (*Snapshot, error) {
+	out := new(Snapshot)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Subscriber/CreateSnapshot", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *subscriberClient) UpdateSnapshot(ctx context.Context, in *UpdateSnapshotRequest, opts ...grpc.CallOption) (*Snapshot, error) {
+	out := new(Snapshot)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Subscriber/UpdateSnapshot", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *subscriberClient) DeleteSnapshot(ctx context.Context, in *DeleteSnapshotRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) {
+	out := new(google_protobuf2.Empty)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Subscriber/DeleteSnapshot", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *subscriberClient) Seek(ctx context.Context, in *SeekRequest, opts ...grpc.CallOption) (*SeekResponse, error) {
+	out := new(SeekResponse)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Subscriber/Seek", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for Subscriber service
+
+type SubscriberServer interface {
+	// Creates a subscription to a given topic.
+	// If the subscription already exists, returns `ALREADY_EXISTS`.
+	// If the corresponding topic doesn't exist, returns `NOT_FOUND`.
+	//
+	// If the name is not provided in the request, the server will assign a random
+	// name for this subscription on the same project as the topic, conforming
+	// to the
+	// [resource name format](https://cloud.google.com/pubsub/docs/overview#names).
+	// The generated name is populated in the returned Subscription object.
+	// Note that for REST API requests, you must specify a name in the request.
+	CreateSubscription(context.Context, *Subscription) (*Subscription, error)
+	// Gets the configuration details of a subscription.
+	GetSubscription(context.Context, *GetSubscriptionRequest) (*Subscription, error)
+	// Updates an existing subscription. Note that certain properties of a
+	// subscription, such as its topic, are not modifiable.
+	// NOTE:  The style guide requires body: "subscription" instead of body: "*".
+	// Keeping the latter for internal consistency in V1, however it should be
+	// corrected in V2.  See
+	// https://cloud.google.com/apis/design/standard_methods#update for details.
+	UpdateSubscription(context.Context, *UpdateSubscriptionRequest) (*Subscription, error)
+	// Lists matching subscriptions.
+	ListSubscriptions(context.Context, *ListSubscriptionsRequest) (*ListSubscriptionsResponse, error)
+	// Deletes an existing subscription. All messages retained in the subscription
+	// are immediately dropped. Calls to `Pull` after deletion will return
+	// `NOT_FOUND`. After a subscription is deleted, a new one may be created with
+	// the same name, but the new one has no association with the old
+	// subscription or its topic unless the same topic is specified.
+	DeleteSubscription(context.Context, *DeleteSubscriptionRequest) (*google_protobuf2.Empty, error)
+	// Modifies the ack deadline for a specific message. This method is useful
+	// to indicate that more time is needed to process a message by the
+	// subscriber, or to make the message available for redelivery if the
+	// processing was interrupted. Note that this does not modify the
+	// subscription-level `ackDeadlineSeconds` used for subsequent messages.
+	ModifyAckDeadline(context.Context, *ModifyAckDeadlineRequest) (*google_protobuf2.Empty, error)
+	// Acknowledges the messages associated with the `ack_ids` in the
+	// `AcknowledgeRequest`. The Pub/Sub system can remove the relevant messages
+	// from the subscription.
+	//
+	// Acknowledging a message whose ack deadline has expired may succeed,
+	// but such a message may be redelivered later. Acknowledging a message more
+	// than once will not result in an error.
+	Acknowledge(context.Context, *AcknowledgeRequest) (*google_protobuf2.Empty, error)
+	// Pulls messages from the server. Returns an empty list if there are no
+	// messages available in the backlog. The server may return `UNAVAILABLE` if
+	// there are too many concurrent pull requests pending for the given
+	// subscription.
+	Pull(context.Context, *PullRequest) (*PullResponse, error)
+	// (EXPERIMENTAL) StreamingPull is an experimental feature. This RPC will
+	// respond with UNIMPLEMENTED errors unless you have been invited to test
+	// this feature. Contact cloud-pubsub@google.com with any questions.
+	//
+	// Establishes a stream with the server, which sends messages down to the
+	// client. The client streams acknowledgements and ack deadline modifications
+	// back to the server. The server will close the stream and return the status
+	// on any error. The server may close the stream with status `OK` to reassign
+	// server-side resources, in which case, the client should re-establish the
+	// stream. `UNAVAILABLE` may also be returned in the case of a transient error
+	// (e.g., a server restart). These should also be retried by the client. Flow
+	// control can be achieved by configuring the underlying RPC channel.
+	StreamingPull(Subscriber_StreamingPullServer) error
+	// Modifies the `PushConfig` for a specified subscription.
+	//
+	// This may be used to change a push subscription to a pull one (signified by
+	// an empty `PushConfig`) or vice versa, or change the endpoint URL and other
+	// attributes of a push subscription. Messages will accumulate for delivery
+	// continuously through the call regardless of changes to the `PushConfig`.
+	ModifyPushConfig(context.Context, *ModifyPushConfigRequest) (*google_protobuf2.Empty, error)
+	// Lists the existing snapshots.
+	ListSnapshots(context.Context, *ListSnapshotsRequest) (*ListSnapshotsResponse, error)
+	// Creates a snapshot from the requested subscription.
+	// If the snapshot already exists, returns `ALREADY_EXISTS`.
+	// If the requested subscription doesn't exist, returns `NOT_FOUND`.
+	//
+	// If the name is not provided in the request, the server will assign a random
+	// name for this snapshot on the same project as the subscription, conforming
+	// to the
+	// [resource name format](https://cloud.google.com/pubsub/docs/overview#names).
+	// The generated name is populated in the returned Snapshot object.
+	// Note that for REST API requests, you must specify a name in the request.
+	CreateSnapshot(context.Context, *CreateSnapshotRequest) (*Snapshot, error)
+	// Updates an existing snapshot. Note that certain properties of a snapshot
+	// are not modifiable.
+	// NOTE:  The style guide requires body: "snapshot" instead of body: "*".
+	// Keeping the latter for internal consistency in V1, however it should be
+	// corrected in V2.  See
+	// https://cloud.google.com/apis/design/standard_methods#update for details.
+	UpdateSnapshot(context.Context, *UpdateSnapshotRequest) (*Snapshot, error)
+	// Removes an existing snapshot. All messages retained in the snapshot
+	// are immediately dropped. After a snapshot is deleted, a new one may be
+	// created with the same name, but the new one has no association with the old
+	// snapshot or its subscription, unless the same subscription is specified.
+	DeleteSnapshot(context.Context, *DeleteSnapshotRequest) (*google_protobuf2.Empty, error)
+	// Seeks an existing subscription to a point in time or to a given snapshot,
+	// whichever is provided in the request.
+	Seek(context.Context, *SeekRequest) (*SeekResponse, error)
+}
+
+func RegisterSubscriberServer(s *grpc.Server, srv SubscriberServer) {
+	s.RegisterService(&_Subscriber_serviceDesc, srv)
+}
+
+func _Subscriber_CreateSubscription_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(Subscription)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SubscriberServer).CreateSubscription(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Subscriber/CreateSubscription",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SubscriberServer).CreateSubscription(ctx, req.(*Subscription))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Subscriber_GetSubscription_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetSubscriptionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SubscriberServer).GetSubscription(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Subscriber/GetSubscription",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SubscriberServer).GetSubscription(ctx, req.(*GetSubscriptionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Subscriber_UpdateSubscription_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(UpdateSubscriptionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SubscriberServer).UpdateSubscription(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Subscriber/UpdateSubscription",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SubscriberServer).UpdateSubscription(ctx, req.(*UpdateSubscriptionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Subscriber_ListSubscriptions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ListSubscriptionsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SubscriberServer).ListSubscriptions(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Subscriber/ListSubscriptions",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SubscriberServer).ListSubscriptions(ctx, req.(*ListSubscriptionsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Subscriber_DeleteSubscription_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DeleteSubscriptionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SubscriberServer).DeleteSubscription(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Subscriber/DeleteSubscription",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SubscriberServer).DeleteSubscription(ctx, req.(*DeleteSubscriptionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Subscriber_ModifyAckDeadline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ModifyAckDeadlineRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SubscriberServer).ModifyAckDeadline(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Subscriber/ModifyAckDeadline",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SubscriberServer).ModifyAckDeadline(ctx, req.(*ModifyAckDeadlineRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Subscriber_Acknowledge_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AcknowledgeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SubscriberServer).Acknowledge(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Subscriber/Acknowledge",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SubscriberServer).Acknowledge(ctx, req.(*AcknowledgeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Subscriber_Pull_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(PullRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SubscriberServer).Pull(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Subscriber/Pull",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SubscriberServer).Pull(ctx, req.(*PullRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Subscriber_StreamingPull_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(SubscriberServer).StreamingPull(&subscriberStreamingPullServer{stream})
+}
+
+type Subscriber_StreamingPullServer interface {
+	Send(*StreamingPullResponse) error
+	Recv() (*StreamingPullRequest, error)
+	grpc.ServerStream
+}
+
+type subscriberStreamingPullServer struct {
+	grpc.ServerStream
+}
+
+func (x *subscriberStreamingPullServer) Send(m *StreamingPullResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *subscriberStreamingPullServer) Recv() (*StreamingPullRequest, error) {
+	m := new(StreamingPullRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func _Subscriber_ModifyPushConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ModifyPushConfigRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SubscriberServer).ModifyPushConfig(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Subscriber/ModifyPushConfig",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SubscriberServer).ModifyPushConfig(ctx, req.(*ModifyPushConfigRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Subscriber_ListSnapshots_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ListSnapshotsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SubscriberServer).ListSnapshots(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Subscriber/ListSnapshots",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SubscriberServer).ListSnapshots(ctx, req.(*ListSnapshotsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Subscriber_CreateSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CreateSnapshotRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SubscriberServer).CreateSnapshot(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Subscriber/CreateSnapshot",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SubscriberServer).CreateSnapshot(ctx, req.(*CreateSnapshotRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Subscriber_UpdateSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(UpdateSnapshotRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SubscriberServer).UpdateSnapshot(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Subscriber/UpdateSnapshot",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SubscriberServer).UpdateSnapshot(ctx, req.(*UpdateSnapshotRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Subscriber_DeleteSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DeleteSnapshotRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SubscriberServer).DeleteSnapshot(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Subscriber/DeleteSnapshot",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SubscriberServer).DeleteSnapshot(ctx, req.(*DeleteSnapshotRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Subscriber_Seek_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(SeekRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SubscriberServer).Seek(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Subscriber/Seek",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SubscriberServer).Seek(ctx, req.(*SeekRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Subscriber_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "google.pubsub.v1.Subscriber",
+	HandlerType: (*SubscriberServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "CreateSubscription",
+			Handler:    _Subscriber_CreateSubscription_Handler,
+		},
+		{
+			MethodName: "GetSubscription",
+			Handler:    _Subscriber_GetSubscription_Handler,
+		},
+		{
+			MethodName: "UpdateSubscription",
+			Handler:    _Subscriber_UpdateSubscription_Handler,
+		},
+		{
+			MethodName: "ListSubscriptions",
+			Handler:    _Subscriber_ListSubscriptions_Handler,
+		},
+		{
+			MethodName: "DeleteSubscription",
+			Handler:    _Subscriber_DeleteSubscription_Handler,
+		},
+		{
+			MethodName: "ModifyAckDeadline",
+			Handler:    _Subscriber_ModifyAckDeadline_Handler,
+		},
+		{
+			MethodName: "Acknowledge",
+			Handler:    _Subscriber_Acknowledge_Handler,
+		},
+		{
+			MethodName: "Pull",
+			Handler:    _Subscriber_Pull_Handler,
+		},
+		{
+			MethodName: "ModifyPushConfig",
+			Handler:    _Subscriber_ModifyPushConfig_Handler,
+		},
+		{
+			MethodName: "ListSnapshots",
+			Handler:    _Subscriber_ListSnapshots_Handler,
+		},
+		{
+			MethodName: "CreateSnapshot",
+			Handler:    _Subscriber_CreateSnapshot_Handler,
+		},
+		{
+			MethodName: "UpdateSnapshot",
+			Handler:    _Subscriber_UpdateSnapshot_Handler,
+		},
+		{
+			MethodName: "DeleteSnapshot",
+			Handler:    _Subscriber_DeleteSnapshot_Handler,
+		},
+		{
+			MethodName: "Seek",
+			Handler:    _Subscriber_Seek_Handler,
+		},
+	},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "StreamingPull",
+			Handler:       _Subscriber_StreamingPull_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
+	},
+	Metadata: "google/pubsub/v1/pubsub.proto",
+}
+
+// Client API for Publisher service
+
+type PublisherClient interface {
+	// Creates the given topic with the given name.
+	CreateTopic(ctx context.Context, in *Topic, opts ...grpc.CallOption) (*Topic, error)
+	// Updates an existing topic. Note that certain properties of a topic are not
+	// modifiable.  Options settings follow the style guide:
+	// NOTE:  The style guide requires body: "topic" instead of body: "*".
+	// Keeping the latter for internal consistency in V1, however it should be
+	// corrected in V2.  See
+	// https://cloud.google.com/apis/design/standard_methods#update for details.
+	UpdateTopic(ctx context.Context, in *UpdateTopicRequest, opts ...grpc.CallOption) (*Topic, error)
+	// Adds one or more messages to the topic. Returns `NOT_FOUND` if the topic
+	// does not exist. The message payload must not be empty; it must contain
+	//  either a non-empty data field, or at least one attribute.
+	Publish(ctx context.Context, in *PublishRequest, opts ...grpc.CallOption) (*PublishResponse, error)
+	// Gets the configuration of a topic.
+	GetTopic(ctx context.Context, in *GetTopicRequest, opts ...grpc.CallOption) (*Topic, error)
+	// Lists matching topics.
+	ListTopics(ctx context.Context, in *ListTopicsRequest, opts ...grpc.CallOption) (*ListTopicsResponse, error)
+	// Lists the name of the subscriptions for this topic.
+	ListTopicSubscriptions(ctx context.Context, in *ListTopicSubscriptionsRequest, opts ...grpc.CallOption) (*ListTopicSubscriptionsResponse, error)
+	// Deletes the topic with the given name. Returns `NOT_FOUND` if the topic
+	// does not exist. After a topic is deleted, a new topic may be created with
+	// the same name; this is an entirely new topic with none of the old
+	// configuration or subscriptions. Existing subscriptions to this topic are
+	// not deleted, but their `topic` field is set to `_deleted-topic_`.
+	DeleteTopic(ctx context.Context, in *DeleteTopicRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error)
+}
+
+type publisherClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewPublisherClient(cc *grpc.ClientConn) PublisherClient {
+	return &publisherClient{cc}
+}
+
+func (c *publisherClient) CreateTopic(ctx context.Context, in *Topic, opts ...grpc.CallOption) (*Topic, error) {
+	out := new(Topic)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Publisher/CreateTopic", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *publisherClient) UpdateTopic(ctx context.Context, in *UpdateTopicRequest, opts ...grpc.CallOption) (*Topic, error) {
+	out := new(Topic)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Publisher/UpdateTopic", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *publisherClient) Publish(ctx context.Context, in *PublishRequest, opts ...grpc.CallOption) (*PublishResponse, error) {
+	out := new(PublishResponse)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Publisher/Publish", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *publisherClient) GetTopic(ctx context.Context, in *GetTopicRequest, opts ...grpc.CallOption) (*Topic, error) {
+	out := new(Topic)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Publisher/GetTopic", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *publisherClient) ListTopics(ctx context.Context, in *ListTopicsRequest, opts ...grpc.CallOption) (*ListTopicsResponse, error) {
+	out := new(ListTopicsResponse)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Publisher/ListTopics", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *publisherClient) ListTopicSubscriptions(ctx context.Context, in *ListTopicSubscriptionsRequest, opts ...grpc.CallOption) (*ListTopicSubscriptionsResponse, error) {
+	out := new(ListTopicSubscriptionsResponse)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Publisher/ListTopicSubscriptions", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *publisherClient) DeleteTopic(ctx context.Context, in *DeleteTopicRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) {
+	out := new(google_protobuf2.Empty)
+	err := grpc.Invoke(ctx, "/google.pubsub.v1.Publisher/DeleteTopic", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for Publisher service
+
+type PublisherServer interface {
+	// Creates the given topic with the given name.
+	CreateTopic(context.Context, *Topic) (*Topic, error)
+	// Updates an existing topic. Note that certain properties of a topic are not
+	// modifiable.  Options settings follow the style guide:
+	// NOTE:  The style guide requires body: "topic" instead of body: "*".
+	// Keeping the latter for internal consistency in V1, however it should be
+	// corrected in V2.  See
+	// https://cloud.google.com/apis/design/standard_methods#update for details.
+	UpdateTopic(context.Context, *UpdateTopicRequest) (*Topic, error)
+	// Adds one or more messages to the topic. Returns `NOT_FOUND` if the topic
+	// does not exist. The message payload must not be empty; it must contain
+	//  either a non-empty data field, or at least one attribute.
+	Publish(context.Context, *PublishRequest) (*PublishResponse, error)
+	// Gets the configuration of a topic.
+	GetTopic(context.Context, *GetTopicRequest) (*Topic, error)
+	// Lists matching topics.
+	ListTopics(context.Context, *ListTopicsRequest) (*ListTopicsResponse, error)
+	// Lists the name of the subscriptions for this topic.
+	ListTopicSubscriptions(context.Context, *ListTopicSubscriptionsRequest) (*ListTopicSubscriptionsResponse, error)
+	// Deletes the topic with the given name. Returns `NOT_FOUND` if the topic
+	// does not exist. After a topic is deleted, a new topic may be created with
+	// the same name; this is an entirely new topic with none of the old
+	// configuration or subscriptions. Existing subscriptions to this topic are
+	// not deleted, but their `topic` field is set to `_deleted-topic_`.
+	DeleteTopic(context.Context, *DeleteTopicRequest) (*google_protobuf2.Empty, error)
+}
+
+func RegisterPublisherServer(s *grpc.Server, srv PublisherServer) {
+	s.RegisterService(&_Publisher_serviceDesc, srv)
+}
+
+func _Publisher_CreateTopic_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(Topic)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(PublisherServer).CreateTopic(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Publisher/CreateTopic",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(PublisherServer).CreateTopic(ctx, req.(*Topic))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Publisher_UpdateTopic_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(UpdateTopicRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(PublisherServer).UpdateTopic(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Publisher/UpdateTopic",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(PublisherServer).UpdateTopic(ctx, req.(*UpdateTopicRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Publisher_Publish_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(PublishRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(PublisherServer).Publish(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Publisher/Publish",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(PublisherServer).Publish(ctx, req.(*PublishRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Publisher_GetTopic_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetTopicRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(PublisherServer).GetTopic(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Publisher/GetTopic",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(PublisherServer).GetTopic(ctx, req.(*GetTopicRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Publisher_ListTopics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ListTopicsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(PublisherServer).ListTopics(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Publisher/ListTopics",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(PublisherServer).ListTopics(ctx, req.(*ListTopicsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Publisher_ListTopicSubscriptions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ListTopicSubscriptionsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(PublisherServer).ListTopicSubscriptions(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Publisher/ListTopicSubscriptions",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(PublisherServer).ListTopicSubscriptions(ctx, req.(*ListTopicSubscriptionsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Publisher_DeleteTopic_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DeleteTopicRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(PublisherServer).DeleteTopic(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/google.pubsub.v1.Publisher/DeleteTopic",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(PublisherServer).DeleteTopic(ctx, req.(*DeleteTopicRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Publisher_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "google.pubsub.v1.Publisher",
+	HandlerType: (*PublisherServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "CreateTopic",
+			Handler:    _Publisher_CreateTopic_Handler,
+		},
+		{
+			MethodName: "UpdateTopic",
+			Handler:    _Publisher_UpdateTopic_Handler,
+		},
+		{
+			MethodName: "Publish",
+			Handler:    _Publisher_Publish_Handler,
+		},
+		{
+			MethodName: "GetTopic",
+			Handler:    _Publisher_GetTopic_Handler,
+		},
+		{
+			MethodName: "ListTopics",
+			Handler:    _Publisher_ListTopics_Handler,
+		},
+		{
+			MethodName: "ListTopicSubscriptions",
+			Handler:    _Publisher_ListTopicSubscriptions_Handler,
+		},
+		{
+			MethodName: "DeleteTopic",
+			Handler:    _Publisher_DeleteTopic_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "google/pubsub/v1/pubsub.proto",
+}
+
+func init() { proto.RegisterFile("google/pubsub/v1/pubsub.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 2011 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x59, 0xcb, 0x73, 0xdb, 0xc6,
+	0x19, 0xcf, 0x92, 0x7a, 0x50, 0x1f, 0xf4, 0xf2, 0x56, 0xb2, 0x69, 0xf8, 0x25, 0xc1, 0x8a, 0x45,
+	0x33, 0x36, 0x29, 0x33, 0x13, 0x37, 0xb6, 0x2a, 0x67, 0x24, 0xcb, 0x75, 0xdc, 0xb1, 0x1b, 0x15,
+	0x72, 0xdb, 0x99, 0x1e, 0xca, 0x01, 0x89, 0x35, 0x8d, 0x90, 0x04, 0x10, 0x00, 0x54, 0xad, 0xb4,
+	0x9e, 0x49, 0x93, 0x4e, 0x67, 0x3a, 0xf5, 0xa1, 0x69, 0x6e, 0x9d, 0x1c, 0x3a, 0xd3, 0x5b, 0x8f,
+	0x9d, 0xe9, 0xb5, 0xff, 0x44, 0xff, 0x85, 0x1e, 0x7b, 0x6f, 0x8f, 0x99, 0x7d, 0x00, 0xc4, 0x63,
+	0x41, 0x8a, 0xb2, 0x7d, 0x03, 0xf6, 0xfb, 0x76, 0xbf, 0xdf, 0xf7, 0xfe, 0x80, 0x85, 0x4b, 0x1d,
+	0xc7, 0xe9, 0xf4, 0x48, 0xdd, 0x1d, 0xb4, 0xfc, 0x41, 0xab, 0x7e, 0x74, 0x4b, 0x3c, 0xd5, 0x5c,
+	0xcf, 0x09, 0x1c, 0xbc, 0xcc, 0xc9, 0x35, 0xb1, 0x78, 0x74, 0x4b, 0xbd, 0x28, 0x36, 0x18, 0xae,
+	0x55, 0x37, 0x6c, 0xdb, 0x09, 0x8c, 0xc0, 0x72, 0x6c, 0x9f, 0xf3, 0xab, 0x97, 0xc3, 0xe3, 0xe8,
+	0x5b, 0x6b, 0xf0, 0xac, 0x6e, 0x0e, 0x3c, 0xc6, 0x20, 0xe8, 0x17, 0xd2, 0x74, 0xd2, 0x77, 0x83,
+	0x63, 0x41, 0x5c, 0x4b, 0x13, 0x9f, 0x59, 0xa4, 0x67, 0x36, 0xfb, 0x86, 0xdf, 0x15, 0x1c, 0x57,
+	0xd2, 0x1c, 0x81, 0xd5, 0x27, 0x7e, 0x60, 0xf4, 0x5d, 0xce, 0xa0, 0x7d, 0x83, 0x60, 0xfa, 0xa9,
+	0xe3, 0x5a, 0x6d, 0x8c, 0x61, 0xca, 0x36, 0xfa, 0xa4, 0x8c, 0xd6, 0x50, 0x65, 0x4e, 0x67, 0xcf,
+	0x78, 0x1b, 0x66, 0x7a, 0x46, 0x8b, 0xf4, 0xfc, 0x72, 0x61, 0xad, 0x58, 0x51, 0x1a, 0x57, 0x6b,
+	0x69, 0xf5, 0x6a, 0x6c, 0x73, 0xed, 0x31, 0xe3, 0x7a, 0x60, 0x07, 0xde, 0xb1, 0x2e, 0xb6, 0xa8,
+	0x77, 0x40, 0x89, 0x2d, 0xe3, 0x65, 0x28, 0x76, 0xc9, 0xb1, 0x38, 0x9e, 0x3e, 0xe2, 0x15, 0x98,
+	0x3e, 0x32, 0x7a, 0x03, 0x52, 0x2e, 0xb0, 0x35, 0xfe, 0x72, 0xb7, 0xf0, 0x21, 0xd2, 0xbe, 0x2e,
+	0xc0, 0xc2, 0x01, 0x13, 0xf1, 0x84, 0xf8, 0xbe, 0xd1, 0x21, 0x14, 0x9d, 0x69, 0x04, 0x06, 0xdb,
+	0x3e, 0xaf, 0xb3, 0x67, 0xfc, 0x09, 0x80, 0x11, 0x04, 0x9e, 0xd5, 0x1a, 0x04, 0x24, 0x44, 0x58,
+	0xcf, 0x22, 0x4c, 0x1c, 0x54, 0xdb, 0x8d, 0x76, 0x70, 0xb4, 0xb1, 0x23, 0xf0, 0x25, 0x80, 0x3e,
+	0x67, 0x6b, 0x5a, 0x66, 0xb9, 0xc8, 0x50, 0xcd, 0x89, 0x95, 0x47, 0x26, 0xde, 0x81, 0x79, 0x77,
+	0xd0, 0xea, 0x59, 0xfe, 0xf3, 0x26, 0x35, 0x63, 0x79, 0x6a, 0x0d, 0x55, 0x94, 0x86, 0x1a, 0x49,
+	0x14, 0x36, 0xae, 0x3d, 0x0d, 0x6d, 0xac, 0x2b, 0x82, 0x9f, 0xae, 0xa8, 0x3b, 0xb0, 0x94, 0x12,
+	0x3e, 0x91, 0x4d, 0x36, 0x61, 0xe9, 0x21, 0x09, 0x98, 0xb9, 0x75, 0xf2, 0xd9, 0x80, 0xf8, 0x01,
+	0x65, 0x0e, 0xe8, 0xbb, 0x38, 0x80, 0xbf, 0x68, 0x5f, 0x20, 0xc0, 0x3f, 0x75, 0x4d, 0x23, 0x20,
+	0x09, 0xe6, 0x9b, 0x71, 0x66, 0xa5, 0x71, 0x2e, 0xc7, 0x95, 0xe2, 0x14, 0xbc, 0x0d, 0xca, 0x80,
+	0x1d, 0xc2, 0xc2, 0x89, 0xc1, 0x91, 0xe9, 0xfa, 0x43, 0x1a, 0x71, 0x4f, 0x0c, 0xbf, 0xab, 0x03,
+	0x67, 0xa7, 0xcf, 0x5a, 0x1b, 0x16, 0x0f, 0xb8, 0xe6, 0x23, 0xa1, 0xe2, 0x6d, 0x28, 0x09, 0xf3,
+	0x86, 0xfe, 0xbb, 0x32, 0xc6, 0x7f, 0x7a, 0xb4, 0x41, 0x6b, 0xc0, 0x52, 0x24, 0xc4, 0x77, 0x1d,
+	0xdb, 0x27, 0xf8, 0x0a, 0x28, 0x43, 0x07, 0xfa, 0x65, 0xb4, 0x56, 0xac, 0xcc, 0xe9, 0x10, 0x79,
+	0xd0, 0xd7, 0x2c, 0x38, 0xf3, 0xd8, 0xf2, 0xb9, 0x15, 0xfd, 0x10, 0x5b, 0x19, 0x66, 0x5d, 0xcf,
+	0xf9, 0x94, 0xb4, 0x03, 0x81, 0x2e, 0x7c, 0xc5, 0x17, 0x60, 0xce, 0xa5, 0x87, 0xf9, 0xd6, 0xe7,
+	0xdc, 0x23, 0xd3, 0x7a, 0x89, 0x2e, 0x1c, 0x5a, 0x9f, 0x13, 0x1a, 0x2d, 0x8c, 0x18, 0x38, 0x5d,
+	0x62, 0x87, 0xd1, 0x42, 0x57, 0x9e, 0xd2, 0x05, 0xad, 0x0f, 0x38, 0x2e, 0x4a, 0x20, 0xac, 0xc3,
+	0x0c, 0x53, 0x9d, 0x83, 0x1b, 0xe1, 0x06, 0xc1, 0x86, 0xaf, 0xc1, 0x92, 0x4d, 0x5e, 0x04, 0xcd,
+	0x98, 0x28, 0x1e, 0x1a, 0x0b, 0x74, 0xf9, 0x20, 0x12, 0xf7, 0x19, 0x5c, 0x8a, 0xc4, 0x1d, 0x0e,
+	0x5a, 0x7e, 0xdb, 0xb3, 0x5c, 0x56, 0x68, 0x46, 0x7b, 0xe0, 0x75, 0x34, 0xb4, 0xe1, 0x72, 0x9e,
+	0x48, 0xa1, 0xed, 0x06, 0x2c, 0xf8, 0x71, 0x82, 0xf0, 0x48, 0x72, 0xf1, 0xc4, 0x2a, 0x56, 0x01,
+	0xef, 0x93, 0x1e, 0x49, 0xc5, 0xb5, 0x3c, 0x09, 0xfe, 0x59, 0x84, 0xf9, 0x38, 0x26, 0x69, 0x79,
+	0x8b, 0xb6, 0x16, 0xe2, 0x26, 0xd9, 0x01, 0xc5, 0x1d, 0xf8, 0xcf, 0x9b, 0x6d, 0xc7, 0x7e, 0x66,
+	0x75, 0x44, 0x96, 0x5f, 0x94, 0xc5, 0xa5, 0xff, 0xfc, 0x3e, 0xe3, 0xd1, 0xc1, 0x8d, 0x9e, 0xf1,
+	0x16, 0xac, 0x18, 0xed, 0x6e, 0xd3, 0x24, 0x86, 0xd9, 0xb3, 0x6c, 0xd2, 0xf4, 0x49, 0xdb, 0xb1,
+	0x4d, 0xbf, 0x3c, 0xcd, 0x8c, 0x8b, 0x8d, 0x76, 0x77, 0x5f, 0x90, 0x0e, 0x39, 0x05, 0x37, 0x60,
+	0xd5, 0x23, 0x81, 0x61, 0xd9, 0x4d, 0xa3, 0xdd, 0x25, 0x66, 0x33, 0x4a, 0x89, 0xd9, 0x35, 0x54,
+	0x29, 0xe9, 0xdf, 0xe3, 0xc4, 0x5d, 0x4a, 0x13, 0x59, 0xe0, 0xe3, 0x9f, 0x83, 0x1a, 0x46, 0xba,
+	0x47, 0x02, 0x62, 0x53, 0x1d, 0x9b, 0x61, 0xef, 0x28, 0x97, 0x18, 0xe6, 0xf3, 0x99, 0x6c, 0xdd,
+	0x17, 0x0c, 0x7a, 0x59, 0x6c, 0xd6, 0xc3, 0xbd, 0x21, 0x05, 0xef, 0x45, 0x25, 0x7f, 0x8e, 0x05,
+	0x68, 0x35, 0xab, 0x78, 0xdc, 0xae, 0x6f, 0xba, 0xf2, 0xff, 0x0b, 0x01, 0x0c, 0x0d, 0x8b, 0xaf,
+	0xc2, 0x02, 0xf3, 0x05, 0xb1, 0x4d, 0xd7, 0xb1, 0xec, 0x30, 0x41, 0xe7, 0xe9, 0xe2, 0x03, 0xb1,
+	0x86, 0x1f, 0x4b, 0xfa, 0xc0, 0x8d, 0x51, 0xfe, 0x1a, 0xd5, 0x04, 0x5e, 0xb7, 0x4c, 0xb7, 0x61,
+	0x49, 0x27, 0x6d, 0x62, 0x1d, 0x45, 0xce, 0xc2, 0xab, 0x30, 0x43, 0x23, 0xc2, 0x32, 0xc3, 0x10,
+	0x35, 0xda, 0xdd, 0x47, 0x26, 0xbe, 0x03, 0xb3, 0xc2, 0x0b, 0xa2, 0xba, 0x8e, 0xad, 0x7d, 0x21,
+	0xbf, 0xf6, 0x03, 0x38, 0xfb, 0x90, 0x04, 0x71, 0x3f, 0x84, 0xd9, 0xa0, 0xc1, 0x7c, 0x3c, 0xb9,
+	0x42, 0x7b, 0xc5, 0xd7, 0xb4, 0x6f, 0x11, 0x9c, 0xe7, 0x0d, 0x42, 0x76, 0xc2, 0x9e, 0xe4, 0x04,
+	0xa5, 0x71, 0x79, 0x74, 0x18, 0x24, 0x25, 0xbc, 0x5e, 0xf3, 0x70, 0xa1, 0x4c, 0xcb, 0x8a, 0xb4,
+	0x88, 0xbd, 0x9d, 0x52, 0xfd, 0x07, 0x04, 0xe7, 0x25, 0x22, 0x45, 0x11, 0xdb, 0x97, 0x15, 0xb1,
+	0xf1, 0x16, 0x39, 0x65, 0x91, 0xfb, 0x08, 0xce, 0xf3, 0x22, 0x77, 0x5a, 0xef, 0xfe, 0x06, 0xce,
+	0x3d, 0x71, 0x4c, 0xeb, 0xd9, 0x71, 0xac, 0x3e, 0x9d, 0x7c, 0x7b, 0xba, 0xfa, 0x15, 0x26, 0xab,
+	0x7e, 0xda, 0x57, 0x08, 0x94, 0x83, 0x41, 0xaf, 0x37, 0x89, 0xc8, 0x9b, 0x80, 0x3d, 0x12, 0x0c,
+	0x3c, 0xbb, 0x69, 0xf5, 0xfb, 0xc4, 0xb4, 0x8c, 0x80, 0xf4, 0x8e, 0x99, 0xe4, 0x92, 0x7e, 0x86,
+	0x53, 0x1e, 0x0d, 0x09, 0x78, 0x1d, 0xe6, 0xfb, 0xc6, 0x8b, 0x61, 0x95, 0x2c, 0x32, 0x67, 0x2b,
+	0x7d, 0xe3, 0x45, 0x58, 0x1d, 0xb5, 0x5f, 0xc2, 0x3c, 0x07, 0x21, 0x5c, 0xf8, 0x63, 0x38, 0xe3,
+	0x89, 0xa4, 0x1c, 0xee, 0xe3, 0x6e, 0x5c, 0xcf, 0xaa, 0x96, 0xca, 0x5f, 0x7d, 0xd9, 0x4b, 0x2e,
+	0xf8, 0x34, 0x60, 0xca, 0xdc, 0xc8, 0xbb, 0xc3, 0x72, 0x3e, 0x89, 0xca, 0xe7, 0x60, 0x96, 0x97,
+	0x04, 0xbf, 0x3c, 0xc5, 0x5a, 0xe2, 0x0c, 0xab, 0x09, 0x7e, 0x6e, 0xf7, 0x28, 0xe6, 0x75, 0x0f,
+	0xed, 0x27, 0x80, 0x77, 0xdb, 0x5d, 0xdb, 0xf9, 0x55, 0x8f, 0x98, 0x9d, 0xd3, 0x82, 0x28, 0xc4,
+	0x41, 0x68, 0xbf, 0x2d, 0xc0, 0xca, 0x61, 0xe0, 0x11, 0xa3, 0x6f, 0xd9, 0x9d, 0x49, 0xbd, 0x99,
+	0x77, 0x2a, 0xbe, 0x0d, 0xe7, 0xfa, 0xcc, 0x66, 0x32, 0xed, 0x8a, 0x95, 0x69, 0x7d, 0x95, 0x93,
+	0xd3, 0xed, 0xf1, 0x83, 0xec, 0xbe, 0xa4, 0xed, 0x56, 0x92, 0xfb, 0x76, 0xb9, 0xb8, 0x1d, 0xb8,
+	0xe0, 0x33, 0x1d, 0x9a, 0x23, 0xda, 0x71, 0x99, 0xb3, 0xec, 0x66, 0xcd, 0xda, 0x81, 0xd5, 0x94,
+	0x09, 0xde, 0x52, 0x2c, 0x7d, 0x02, 0xab, 0xf7, 0x3d, 0x42, 0x8b, 0xb1, 0x6d, 0xb8, 0xfe, 0x73,
+	0x27, 0x08, 0x8d, 0x2d, 0x9b, 0x58, 0xd2, 0x0e, 0x28, 0x48, 0x0a, 0xc0, 0x2b, 0x04, 0xab, 0xa2,
+	0xbc, 0xa7, 0x4e, 0xbc, 0x0d, 0x25, 0x5f, 0x2c, 0x89, 0xb2, 0xae, 0x4a, 0x8a, 0x58, 0xb8, 0x29,
+	0xe2, 0x7d, 0xbd, 0x72, 0xfe, 0x5f, 0x04, 0xa5, 0xf0, 0xcc, 0x09, 0xa6, 0xb0, 0x6d, 0x50, 0xc8,
+	0x0b, 0xd7, 0xf2, 0x08, 0xff, 0xd6, 0x2a, 0x8e, 0xfd, 0xd6, 0x02, 0xce, 0x4e, 0x17, 0xf0, 0xbd,
+	0x68, 0x88, 0x99, 0x62, 0x8e, 0xb9, 0x96, 0xaf, 0xe6, 0x9b, 0x1e, 0x60, 0x7a, 0xb0, 0xc2, 0x5a,
+	0x89, 0x38, 0xfe, 0x2d, 0x77, 0xae, 0x63, 0x58, 0x4d, 0x49, 0x13, 0x51, 0xfa, 0x21, 0xcc, 0x85,
+	0xee, 0x0b, 0xa3, 0x73, 0x94, 0xaf, 0x87, 0xcc, 0x27, 0x6e, 0x54, 0xef, 0xc3, 0xaa, 0x68, 0x54,
+	0xa9, 0x28, 0x53, 0x53, 0x51, 0x36, 0x37, 0x8c, 0x24, 0xed, 0x8f, 0x08, 0x94, 0x43, 0x42, 0xba,
+	0x93, 0x14, 0x94, 0x2d, 0x98, 0x62, 0x21, 0x50, 0x18, 0x17, 0x02, 0x1f, 0xbf, 0xa3, 0x33, 0x4e,
+	0x7c, 0x31, 0x86, 0x80, 0x99, 0xec, 0xe3, 0x77, 0x86, 0x18, 0xf6, 0x4a, 0x30, 0x13, 0x18, 0x5e,
+	0x87, 0x04, 0xda, 0x22, 0xcc, 0x73, 0x30, 0xdc, 0x68, 0x8d, 0xff, 0x2d, 0x03, 0x88, 0xb6, 0xdb,
+	0x22, 0x1e, 0xfe, 0x3d, 0x02, 0x2c, 0x52, 0x33, 0x8e, 0x67, 0x4c, 0xe3, 0x57, 0xc7, 0xd0, 0xb5,
+	0xad, 0x2f, 0xff, 0xfd, 0x9f, 0x6f, 0x0a, 0x55, 0xf5, 0xdd, 0xfa, 0xd1, 0xad, 0xfa, 0xaf, 0x69,
+	0x0a, 0xec, 0x88, 0x50, 0xf0, 0xeb, 0xd5, 0x7a, 0x62, 0x6a, 0xa8, 0x57, 0x5f, 0xde, 0x45, 0x55,
+	0xfc, 0x67, 0xc4, 0xbe, 0xfd, 0x13, 0x28, 0x2a, 0x59, 0x29, 0xf2, 0x91, 0x70, 0x2c, 0x9e, 0x0f,
+	0x18, 0x9e, 0x3a, 0xbe, 0xc9, 0xf0, 0xc4, 0xe5, 0x8f, 0xc2, 0x85, 0xff, 0x1a, 0xfd, 0x66, 0x48,
+	0xe0, 0x7a, 0x2f, 0x2b, 0x2d, 0x77, 0xd6, 0x1c, 0x0b, 0x6d, 0x87, 0x41, 0xfb, 0x7e, 0xa3, 0x91,
+	0x81, 0x56, 0x3b, 0x89, 0xdd, 0xbe, 0x45, 0xfc, 0x73, 0x3f, 0x31, 0xd7, 0x61, 0xc9, 0x17, 0x4d,
+	0xde, 0xbc, 0xa9, 0xbe, 0x77, 0x22, 0x5e, 0x1e, 0x3e, 0x5a, 0x8d, 0xa1, 0xad, 0xe0, 0x6b, 0x0c,
+	0xad, 0xc0, 0x16, 0xc3, 0xf8, 0x32, 0x09, 0x12, 0xff, 0x09, 0x85, 0x1f, 0xb4, 0xe3, 0x2c, 0x98,
+	0x3b, 0x11, 0xaa, 0x67, 0x33, 0xe9, 0xf0, 0xa0, 0xef, 0x06, 0xc7, 0xa1, 0x53, 0xab, 0x13, 0x3a,
+	0xf5, 0x6f, 0x08, 0xce, 0x64, 0x06, 0x1b, 0x99, 0xc5, 0xf2, 0xa6, 0x9f, 0x5c, 0x40, 0x3f, 0x62,
+	0x80, 0xf6, 0xb5, 0x8f, 0x26, 0x02, 0x74, 0xb7, 0x9f, 0x96, 0x43, 0xfd, 0xfa, 0x35, 0x02, 0x25,
+	0x36, 0xf3, 0xe0, 0x8d, 0x2c, 0xbe, 0xec, 0x48, 0x94, 0x8b, 0x6c, 0x9f, 0x21, 0xbb, 0xa7, 0xdd,
+	0x99, 0x0c, 0x99, 0x31, 0x94, 0x40, 0x31, 0xfd, 0x0e, 0xc1, 0x14, 0x9d, 0x13, 0xf0, 0x25, 0xd9,
+	0xac, 0x1c, 0x8d, 0x50, 0xb2, 0x90, 0x8f, 0x8f, 0x17, 0x61, 0xc8, 0x6b, 0x8d, 0xc9, 0xd0, 0xb8,
+	0x83, 0x5e, 0x8f, 0xc2, 0x30, 0x61, 0x21, 0x31, 0xb6, 0x60, 0x59, 0xeb, 0x93, 0x8c, 0x76, 0xea,
+	0xe6, 0x58, 0x3e, 0x0e, 0xb0, 0x82, 0xb6, 0x10, 0xcd, 0xfd, 0xe5, 0xf4, 0x47, 0x06, 0xbe, 0x9e,
+	0x17, 0x25, 0x99, 0x0f, 0x91, 0x5c, 0x57, 0x3c, 0x62, 0xca, 0xdf, 0xd7, 0xee, 0x9d, 0x26, 0x48,
+	0x86, 0x62, 0xa8, 0x21, 0x5e, 0x21, 0x58, 0x48, 0xb4, 0x46, 0x99, 0x25, 0x64, 0x9d, 0x5a, 0x66,
+	0x09, 0x69, 0x8f, 0xd5, 0xaa, 0x0c, 0xed, 0x06, 0xd6, 0xf2, 0xf3, 0x3d, 0x12, 0xfe, 0x15, 0x82,
+	0xc5, 0xe4, 0x98, 0x87, 0x25, 0x72, 0xa4, 0x83, 0xa0, 0x3a, 0xa2, 0x71, 0x6b, 0x37, 0x18, 0x86,
+	0x6b, 0xea, 0xba, 0xbc, 0x99, 0x84, 0xf2, 0x45, 0x41, 0x7c, 0x85, 0x60, 0x31, 0x39, 0x1a, 0xca,
+	0x50, 0x48, 0x87, 0xc7, 0x91, 0x28, 0x44, 0xb5, 0x69, 0x54, 0xb9, 0xdf, 0xc2, 0xd1, 0x6a, 0x1c,
+	0x9c, 0x2f, 0x10, 0x2c, 0x26, 0x67, 0x08, 0x19, 0x1c, 0xe9, 0x94, 0x91, 0x1b, 0x42, 0x37, 0x19,
+	0x94, 0xcd, 0xea, 0xbb, 0x09, 0x28, 0x79, 0x28, 0x58, 0xda, 0xd2, 0x19, 0x40, 0x96, 0xb6, 0xb1,
+	0x41, 0x45, 0xda, 0xa9, 0x62, 0xa3, 0xc3, 0x69, 0xd3, 0xd6, 0x27, 0xa4, 0x7b, 0x17, 0x55, 0x1b,
+	0x7f, 0x99, 0x85, 0x39, 0xf1, 0x33, 0x9b, 0x78, 0xf8, 0x53, 0x50, 0x78, 0x24, 0xf0, 0x9b, 0x99,
+	0xbc, 0x7f, 0xc4, 0x6a, 0x1e, 0x41, 0xbb, 0xce, 0xd0, 0x5c, 0x55, 0x2f, 0x4b, 0xa3, 0x82, 0xff,
+	0x59, 0x16, 0x3e, 0x78, 0x09, 0x4a, 0xec, 0xb2, 0x40, 0x56, 0x4a, 0xb3, 0x77, 0x09, 0xf9, 0x82,
+	0xeb, 0x4c, 0xf0, 0xf5, 0xc6, 0x06, 0x13, 0xcc, 0x04, 0xd5, 0x46, 0x8a, 0xff, 0x12, 0xc1, 0xac,
+	0x50, 0x1c, 0xaf, 0x49, 0xff, 0x7f, 0xc5, 0x6e, 0x11, 0xd4, 0xf5, 0x11, 0x1c, 0xc2, 0x11, 0x0d,
+	0x86, 0xe0, 0x86, 0xb6, 0x39, 0x44, 0x20, 0x17, 0x2e, 0xae, 0x66, 0x28, 0x08, 0x07, 0x4a, 0xe1,
+	0xd5, 0x0a, 0x5e, 0x97, 0xce, 0x55, 0x27, 0xd3, 0x7e, 0x93, 0xc9, 0x5e, 0xc7, 0x57, 0xc6, 0xc8,
+	0xa6, 0x81, 0x0f, 0xc3, 0xcb, 0x01, 0x7c, 0x55, 0x5e, 0x71, 0x12, 0xb7, 0x14, 0xea, 0xc6, 0x68,
+	0x26, 0xa1, 0x7e, 0x12, 0x82, 0xac, 0x26, 0x89, 0x7b, 0x85, 0x7f, 0x20, 0x38, 0x2b, 0xff, 0x7b,
+	0x8f, 0xeb, 0x23, 0x24, 0x49, 0xa7, 0xa4, 0xad, 0x93, 0x6f, 0x10, 0x30, 0x93, 0x33, 0x67, 0xbe,
+	0xa5, 0x52, 0x13, 0x53, 0x00, 0x4a, 0xec, 0x06, 0x40, 0x16, 0xac, 0xd9, 0x0b, 0x82, 0xdc, 0x4a,
+	0x21, 0x4c, 0x55, 0x1d, 0xe7, 0xad, 0xbd, 0x63, 0x58, 0x69, 0x3b, 0xfd, 0x8c, 0xac, 0x3d, 0x85,
+	0xff, 0x9d, 0x3d, 0xa0, 0xc7, 0x1e, 0xa0, 0x5f, 0xdc, 0x16, 0x0c, 0x1d, 0xa7, 0x67, 0xd8, 0x9d,
+	0x9a, 0xe3, 0x75, 0xea, 0x1d, 0x62, 0x33, 0xa1, 0x75, 0x4e, 0x32, 0x5c, 0xcb, 0x1f, 0x5e, 0x1c,
+	0x6f, 0xf3, 0xa7, 0xff, 0x23, 0xf4, 0xf7, 0xc2, 0xd9, 0x87, 0x7c, 0xef, 0xfd, 0x9e, 0x33, 0x30,
+	0x69, 0x4c, 0x1f, 0x0e, 0x5a, 0xb5, 0x9f, 0xdd, 0x6a, 0xcd, 0xb0, 0xed, 0xef, 0x7f, 0x17, 0x00,
+	0x00, 0xff, 0xff, 0x68, 0xa2, 0x62, 0x98, 0x76, 0x1e, 0x00, 0x00,
+}
diff --git a/vendor/gopkg.in/yaml.v2/emitterc.go b/vendor/gopkg.in/yaml.v2/emitterc.go
index dcaf502..41de8b8 100644
--- a/vendor/gopkg.in/yaml.v2/emitterc.go
+++ b/vendor/gopkg.in/yaml.v2/emitterc.go
@@ -995,9 +995,9 @@
 		space_break    = false
 
 		preceded_by_whitespace = false
-		followed_by_whitespace = false
-		previous_space         = false
-		previous_break         = false
+		followed_by_whitespace  = false
+		previous_space          = false
+		previous_break          = false
 	)
 
 	emitter.scalar_data.value = value