54 files changed, 15199 insertions, 0 deletions

diff --git a/vendor/google.golang.org/appengine/.travis.yml b/vendor/google.golang.org/appengine/.travis.yml
new file mode 100644
index 0000000..70ffe89
--- /dev/null
+++ b/vendor/google.golang.org/appengine/.travis.yml
@@ -0,0 +1,20 @@
+language: go
+
+go_import_path: google.golang.org/appengine
+
+install:
+  - ./travis_install.sh
+
+script:
+  - ./travis_test.sh
+
+matrix:
+  include:
+    - go: 1.8.x
+      env: GOAPP=true
+    - go: 1.9.x
+      env: GOAPP=true
+    - go: 1.10.x
+      env: GOAPP=false
+    - go: 1.11.x
+      env: GO111MODULE=on
diff --git a/vendor/google.golang.org/appengine/CONTRIBUTING.md b/vendor/google.golang.org/appengine/CONTRIBUTING.md
new file mode 100644
index 0000000..ffc2985
--- /dev/null
+++ b/vendor/google.golang.org/appengine/CONTRIBUTING.md
@@ -0,0 +1,90 @@
+# Contributing
+
+1. Sign one of the contributor license agreements below.
+1. Get the package:
+
+    `go get -d google.golang.org/appengine`
+1. Change into the checked out source:
+
+    `cd $GOPATH/src/google.golang.org/appengine`
+1. Fork the repo.
+1. Set your fork as a remote:
+
+    `git remote add fork git@github.com:GITHUB_USERNAME/appengine.git`
+1. Make changes, commit to your fork.
+1. Send a pull request with your changes. 
+   The first line of your commit message is conventionally a one-line summary of the change, prefixed by the primary affected package, and is used as the title of your pull request.
+
+# Testing
+
+## Running system tests
+
+Download and install the [Go App Engine SDK](https://cloud.google.com/appengine/docs/go/download). Make sure the `go_appengine` dir is in your `PATH`.
+
+Set the `APPENGINE_DEV_APPSERVER` environment variable to `/path/to/go_appengine/dev_appserver.py`.
+
+Run tests with `goapp test`:
+
+```
+goapp test -v google.golang.org/appengine/...
+```
+
+## Contributor License Agreements
+
+Before we can accept your pull requests you'll need to sign a Contributor
+License Agreement (CLA):
+
+- **If you are an individual writing original source code** and **you own the
+intellectual property**, then you'll need to sign an [individual CLA][indvcla].
+- **If you work for a company that wants to allow you to contribute your work**,
+then you'll need to sign a [corporate CLA][corpcla].
+
+You can sign these electronically (just scroll to the bottom). After that,
+we'll be able to accept your pull requests.
+
+## Contributor Code of Conduct
+
+As contributors and maintainers of this project,
+and in the interest of fostering an open and welcoming community,
+we pledge to respect all people who contribute through reporting issues,
+posting feature requests, updating documentation,
+submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project
+a harassment-free experience for everyone,
+regardless of level of experience, gender, gender identity and expression,
+sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information,
+such as physical or electronic
+addresses, without explicit permission
+* Other unethical or unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct.
+By adopting this Code of Conduct,
+project maintainers commit themselves to fairly and consistently
+applying these principles to every aspect of managing this project.
+Project maintainers who do not follow or enforce the Code of Conduct
+may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior
+may be reported by opening an issue
+or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.2.0,
+available at [http://contributor-covenant.org/version/1/2/0/](http://contributor-covenant.org/version/1/2/0/)
+
+[indvcla]: https://developers.google.com/open-source/cla/individual
+[corpcla]: https://developers.google.com/open-source/cla/corporate
diff --git a/vendor/google.golang.org/appengine/LICENSE b/vendor/google.golang.org/appengine/LICENSE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/vendor/google.golang.org/appengine/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/vendor/google.golang.org/appengine/README.md b/vendor/google.golang.org/appengine/README.md
new file mode 100644
index 0000000..d86768a
--- /dev/null
+++ b/vendor/google.golang.org/appengine/README.md
@@ -0,0 +1,73 @@
+# Go App Engine packages
+
+[![Build Status](https://travis-ci.org/golang/appengine.svg)](https://travis-ci.org/golang/appengine)
+
+This repository supports the Go runtime on *App Engine standard*.
+It provides APIs for interacting with App Engine services.
+Its canonical import path is `google.golang.org/appengine`.
+
+See https://cloud.google.com/appengine/docs/go/
+for more information.
+
+File issue reports and feature requests on the [GitHub's issue
+tracker](https://github.com/golang/appengine/issues).
+
+## Upgrading an App Engine app to the flexible environment
+
+This package does not work on *App Engine flexible*.
+
+There are many differences between the App Engine standard environment and
+the flexible environment.
+
+See the [documentation on upgrading to the flexible environment](https://cloud.google.com/appengine/docs/flexible/go/upgrading).
+
+## Directory structure
+
+The top level directory of this repository is the `appengine` package. It
+contains the
+basic APIs (e.g. `appengine.NewContext`) that apply across APIs. Specific API
+packages are in subdirectories (e.g. `datastore`).
+
+There is an `internal` subdirectory that contains service protocol buffers,
+plus packages required for connectivity to make API calls. App Engine apps
+should not directly import any package under `internal`.
+
+## Updating from legacy (`import "appengine"`) packages
+
+If you're currently using the bare `appengine` packages
+(that is, not these ones, imported via `google.golang.org/appengine`),
+then you can use the `aefix` tool to help automate an upgrade to these packages.
+
+Run `go get google.golang.org/appengine/cmd/aefix` to install it.
+
+### 1. Update import paths
+
+The import paths for App Engine packages are now fully qualified, based at `google.golang.org/appengine`.
+You will need to update your code to use import paths starting with that; for instance,
+code importing `appengine/datastore` will now need to import `google.golang.org/appengine/datastore`.
+
+### 2. Update code using deprecated, removed or modified APIs
+
+Most App Engine services are available with exactly the same API.
+A few APIs were cleaned up, and there are some differences:
+
+* `appengine.Context` has been replaced with the `Context` type from `golang.org/x/net/context`.
+* Logging methods that were on `appengine.Context` are now functions in `google.golang.org/appengine/log`.
+* `appengine.Timeout` has been removed. Use `context.WithTimeout` instead.
+* `appengine.Datacenter` now takes a `context.Context` argument.
+* `datastore.PropertyLoadSaver` has been simplified to use slices in place of channels.
+* `delay.Call` now returns an error.
+* `search.FieldLoadSaver` now handles document metadata.
+* `urlfetch.Transport` no longer has a Deadline field; set a deadline on the
+  `context.Context` instead.
+* `aetest` no longer declares its own Context type, and uses the standard one instead.
+* `taskqueue.QueueStats` no longer takes a maxTasks argument. That argument has been
+  deprecated and unused for a long time.
+* `appengine.BackendHostname` and `appengine.BackendInstance` were for the deprecated backends feature.
+  Use `appengine.ModuleHostname`and `appengine.ModuleName` instead.
+* Most of `appengine/file` and parts of `appengine/blobstore` are deprecated.
+  Use [Google Cloud Storage](https://godoc.org/cloud.google.com/go/storage) if the
+  feature you require is not present in the new
+  [blobstore package](https://google.golang.org/appengine/blobstore).
+* `appengine/socket` is not required on App Engine flexible environment / Managed VMs.
+  Use the standard `net` package instead.
diff --git a/vendor/google.golang.org/appengine/appengine.go b/vendor/google.golang.org/appengine/appengine.go
new file mode 100644
index 0000000..0cca033
--- /dev/null
+++ b/vendor/google.golang.org/appengine/appengine.go
@@ -0,0 +1,137 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// Package appengine provides basic functionality for Google App Engine.
+//
+// For more information on how to write Go apps for Google App Engine, see:
+// https://cloud.google.com/appengine/docs/go/
+package appengine // import "google.golang.org/appengine"
+
+import (
+        "net/http"
+
+        "github.com/golang/protobuf/proto"
+        "golang.org/x/net/context"
+
+        "google.golang.org/appengine/internal"
+)
+
+// The gophers party all night; the rabbits provide the beats.
+
+// Main is the principal entry point for an app running in App Engine.
+//
+// On App Engine Flexible it installs a trivial health checker if one isn't
+// already registered, and starts listening on port 8080 (overridden by the
+// $PORT environment variable).
+//
+// See https://cloud.google.com/appengine/docs/flexible/custom-runtimes#health_check_requests
+// for details on how to do your own health checking.
+//
+// On App Engine Standard it ensures the server has started and is prepared to
+// receive requests.
+//
+// Main never returns.
+//
+// Main is designed so that the app's main package looks like this:
+//
+//      package main
+//
+//      import (
+//              "google.golang.org/appengine"
+//
+//              _ "myapp/package0"
+//              _ "myapp/package1"
+//      )
+//
+//      func main() {
+//              appengine.Main()
+//      }
+//
+// The "myapp/packageX" packages are expected to register HTTP handlers
+// in their init functions.
+func Main() {
+        internal.Main()
+}
+
+// IsDevAppServer reports whether the App Engine app is running in the
+// development App Server.
+func IsDevAppServer() bool {
+        return internal.IsDevAppServer()
+}
+
+// IsStandard reports whether the App Engine app is running in the standard
+// environment. This includes both the first generation runtimes (<= Go 1.9)
+// and the second generation runtimes (>= Go 1.11).
+func IsStandard() bool {
+        return internal.IsStandard()
+}
+
+// IsFlex reports whether the App Engine app is running in the flexible environment.
+func IsFlex() bool {
+        return internal.IsFlex()
+}
+
+// IsAppEngine reports whether the App Engine app is running on App Engine, in either
+// the standard or flexible environment.
+func IsAppEngine() bool {
+        return internal.IsAppEngine()
+}
+
+// IsSecondGen reports whether the App Engine app is running on the second generation
+// runtimes (>= Go 1.11).
+func IsSecondGen() bool {
+        return internal.IsSecondGen()
+}
+
+// NewContext returns a context for an in-flight HTTP request.
+// This function is cheap.
+func NewContext(req *http.Request) context.Context {
+        return internal.ReqContext(req)
+}
+
+// WithContext returns a copy of the parent context
+// and associates it with an in-flight HTTP request.
+// This function is cheap.
+func WithContext(parent context.Context, req *http.Request) context.Context {
+        return internal.WithContext(parent, req)
+}
+
+// TODO(dsymonds): Add a Call function here? Otherwise other packages can't access internal.Call.
+
+// BlobKey is a key for a blobstore blob.
+//
+// Conceptually, this type belongs in the blobstore package, but it lives in
+// the appengine package to avoid a circular dependency: blobstore depends on
+// datastore, and datastore needs to refer to the BlobKey type.
+type BlobKey string
+
+// GeoPoint represents a location as latitude/longitude in degrees.
+type GeoPoint struct {
+        Lat, Lng float64
+}
+
+// Valid returns whether a GeoPoint is within [-90, 90] latitude and [-180, 180] longitude.
+func (g GeoPoint) Valid() bool {
+        return -90 <= g.Lat && g.Lat <= 90 && -180 <= g.Lng && g.Lng <= 180
+}
+
+// APICallFunc defines a function type for handling an API call.
+// See WithCallOverride.
+type APICallFunc func(ctx context.Context, service, method string, in, out proto.Message) error
+
+// WithAPICallFunc returns a copy of the parent context
+// that will cause API calls to invoke f instead of their normal operation.
+//
+// This is intended for advanced users only.
+func WithAPICallFunc(ctx context.Context, f APICallFunc) context.Context {
+        return internal.WithCallOverride(ctx, internal.CallOverrideFunc(f))
+}
+
+// APICall performs an API call.
+//
+// This is not intended for general use; it is exported for use in conjunction
+// with WithAPICallFunc.
+func APICall(ctx context.Context, service, method string, in, out proto.Message) error {
+        return internal.Call(ctx, service, method, in, out)
+}
diff --git a/vendor/google.golang.org/appengine/appengine_vm.go b/vendor/google.golang.org/appengine/appengine_vm.go
new file mode 100644
index 0000000..f4b645a
--- /dev/null
+++ b/vendor/google.golang.org/appengine/appengine_vm.go
@@ -0,0 +1,20 @@
+// Copyright 2015 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build !appengine
+
+package appengine
+
+import (
+        "golang.org/x/net/context"
+
+        "google.golang.org/appengine/internal"
+)
+
+// BackgroundContext returns a context not associated with a request.
+// This should only be used when not servicing a request.
+// This only works in App Engine "flexible environment".
+func BackgroundContext() context.Context {
+        return internal.BackgroundContext()
+}
diff --git a/vendor/google.golang.org/appengine/datastore/datastore.go b/vendor/google.golang.org/appengine/datastore/datastore.go
new file mode 100644
index 0000000..576bc50
--- /dev/null
+++ b/vendor/google.golang.org/appengine/datastore/datastore.go
@@ -0,0 +1,407 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package datastore
+
+import (
+        "errors"
+        "fmt"
+        "reflect"
+
+        "github.com/golang/protobuf/proto"
+        "golang.org/x/net/context"
+
+        "google.golang.org/appengine"
+        "google.golang.org/appengine/internal"
+        pb "google.golang.org/appengine/internal/datastore"
+)
+
+var (
+        // ErrInvalidEntityType is returned when functions like Get or Next are
+        // passed a dst or src argument of invalid type.
+        ErrInvalidEntityType = errors.New("datastore: invalid entity type")
+        // ErrInvalidKey is returned when an invalid key is presented.
+        ErrInvalidKey = errors.New("datastore: invalid key")
+        // ErrNoSuchEntity is returned when no entity was found for a given key.
+        ErrNoSuchEntity = errors.New("datastore: no such entity")
+)
+
+// ErrFieldMismatch is returned when a field is to be loaded into a different
+// type than the one it was stored from, or when a field is missing or
+// unexported in the destination struct.
+// StructType is the type of the struct pointed to by the destination argument
+// passed to Get or to Iterator.Next.
+type ErrFieldMismatch struct {
+        StructType reflect.Type
+        FieldName  string
+        Reason     string
+}
+
+func (e *ErrFieldMismatch) Error() string {
+        return fmt.Sprintf("datastore: cannot load field %q into a %q: %s",
+                e.FieldName, e.StructType, e.Reason)
+}
+
+// protoToKey converts a Reference proto to a *Key. If the key is invalid,
+// protoToKey will return the invalid key along with ErrInvalidKey.
+func protoToKey(r *pb.Reference) (k *Key, err error) {
+        appID := r.GetApp()
+        namespace := r.GetNameSpace()
+        for _, e := range r.Path.Element {
+                k = &Key{
+                        kind:      e.GetType(),
+                        stringID:  e.GetName(),
+                        intID:     e.GetId(),
+                        parent:    k,
+                        appID:     appID,
+                        namespace: namespace,
+                }
+                if !k.valid() {
+                        return k, ErrInvalidKey
+                }
+        }
+        return
+}
+
+// keyToProto converts a *Key to a Reference proto.
+func keyToProto(defaultAppID string, k *Key) *pb.Reference {
+        appID := k.appID
+        if appID == "" {
+                appID = defaultAppID
+        }
+        n := 0
+        for i := k; i != nil; i = i.parent {
+                n++
+        }
+        e := make([]*pb.Path_Element, n)
+        for i := k; i != nil; i = i.parent {
+                n--
+                e[n] = &pb.Path_Element{
+                        Type: &i.kind,
+                }
+                // At most one of {Name,Id} should be set.
+                // Neither will be set for incomplete keys.
+                if i.stringID != "" {
+                        e[n].Name = &i.stringID
+                } else if i.intID != 0 {
+                        e[n].Id = &i.intID
+                }
+        }
+        var namespace *string
+        if k.namespace != "" {
+                namespace = proto.String(k.namespace)
+        }
+        return &pb.Reference{
+                App:       proto.String(appID),
+                NameSpace: namespace,
+                Path: &pb.Path{
+                        Element: e,
+                },
+        }
+}
+
+// multiKeyToProto is a batch version of keyToProto.
+func multiKeyToProto(appID string, key []*Key) []*pb.Reference {
+        ret := make([]*pb.Reference, len(key))
+        for i, k := range key {
+                ret[i] = keyToProto(appID, k)
+        }
+        return ret
+}
+
+// multiValid is a batch version of Key.valid. It returns an error, not a
+// []bool.
+func multiValid(key []*Key) error {
+        invalid := false
+        for _, k := range key {
+                if !k.valid() {
+                        invalid = true
+                        break
+                }
+        }
+        if !invalid {
+                return nil
+        }
+        err := make(appengine.MultiError, len(key))
+        for i, k := range key {
+                if !k.valid() {
+                        err[i] = ErrInvalidKey
+                }
+        }
+        return err
+}
+
+// It's unfortunate that the two semantically equivalent concepts pb.Reference
+// and pb.PropertyValue_ReferenceValue aren't the same type. For example, the
+// two have different protobuf field numbers.
+
+// referenceValueToKey is the same as protoToKey except the input is a
+// PropertyValue_ReferenceValue instead of a Reference.
+func referenceValueToKey(r *pb.PropertyValue_ReferenceValue) (k *Key, err error) {
+        appID := r.GetApp()
+        namespace := r.GetNameSpace()
+        for _, e := range r.Pathelement {
+                k = &Key{
+                        kind:      e.GetType(),
+                        stringID:  e.GetName(),
+                        intID:     e.GetId(),
+                        parent:    k,
+                        appID:     appID,
+                        namespace: namespace,
+                }
+                if !k.valid() {
+                        return nil, ErrInvalidKey
+                }
+        }
+        return
+}
+
+// keyToReferenceValue is the same as keyToProto except the output is a
+// PropertyValue_ReferenceValue instead of a Reference.
+func keyToReferenceValue(defaultAppID string, k *Key) *pb.PropertyValue_ReferenceValue {
+        ref := keyToProto(defaultAppID, k)
+        pe := make([]*pb.PropertyValue_ReferenceValue_PathElement, len(ref.Path.Element))
+        for i, e := range ref.Path.Element {
+                pe[i] = &pb.PropertyValue_ReferenceValue_PathElement{
+                        Type: e.Type,
+                        Id:   e.Id,
+                        Name: e.Name,
+                }
+        }
+        return &pb.PropertyValue_ReferenceValue{
+                App:         ref.App,
+                NameSpace:   ref.NameSpace,
+                Pathelement: pe,
+        }
+}
+
+type multiArgType int
+
+const (
+        multiArgTypeInvalid multiArgType = iota
+        multiArgTypePropertyLoadSaver
+        multiArgTypeStruct
+        multiArgTypeStructPtr
+        multiArgTypeInterface
+)
+
+// checkMultiArg checks that v has type []S, []*S, []I, or []P, for some struct
+// type S, for some interface type I, or some non-interface non-pointer type P
+// such that P or *P implements PropertyLoadSaver.
+//
+// It returns what category the slice's elements are, and the reflect.Type
+// that represents S, I or P.
+//
+// As a special case, PropertyList is an invalid type for v.
+func checkMultiArg(v reflect.Value) (m multiArgType, elemType reflect.Type) {
+        if v.Kind() != reflect.Slice {
+                return multiArgTypeInvalid, nil
+        }
+        if v.Type() == typeOfPropertyList {
+                return multiArgTypeInvalid, nil
+        }
+        elemType = v.Type().Elem()
+        if reflect.PtrTo(elemType).Implements(typeOfPropertyLoadSaver) {
+                return multiArgTypePropertyLoadSaver, elemType
+        }
+        switch elemType.Kind() {
+        case reflect.Struct:
+                return multiArgTypeStruct, elemType
+        case reflect.Interface:
+                return multiArgTypeInterface, elemType
+        case reflect.Ptr:
+                elemType = elemType.Elem()
+                if elemType.Kind() == reflect.Struct {
+                        return multiArgTypeStructPtr, elemType
+                }
+        }
+        return multiArgTypeInvalid, nil
+}
+
+// Get loads the entity stored for k into dst, which must be a struct pointer
+// or implement PropertyLoadSaver. If there is no such entity for the key, Get
+// returns ErrNoSuchEntity.
+//
+// The values of dst's unmatched struct fields are not modified, and matching
+// slice-typed fields are not reset before appending to them. In particular, it
+// is recommended to pass a pointer to a zero valued struct on each Get call.
+//
+// ErrFieldMismatch is returned when a field is to be loaded into a different
+// type than the one it was stored from, or when a field is missing or
+// unexported in the destination struct. ErrFieldMismatch is only returned if
+// dst is a struct pointer.
+func Get(c context.Context, key *Key, dst interface{}) error {
+        if dst == nil { // GetMulti catches nil interface; we need to catch nil ptr here
+                return ErrInvalidEntityType
+        }
+        err := GetMulti(c, []*Key{key}, []interface{}{dst})
+        if me, ok := err.(appengine.MultiError); ok {
+                return me[0]
+        }
+        return err
+}
+
+// GetMulti is a batch version of Get.
+//
+// dst must be a []S, []*S, []I or []P, for some struct type S, some interface
+// type I, or some non-interface non-pointer type P such that P or *P
+// implements PropertyLoadSaver. If an []I, each element must be a valid dst
+// for Get: it must be a struct pointer or implement PropertyLoadSaver.
+//
+// As a special case, PropertyList is an invalid type for dst, even though a
+// PropertyList is a slice of structs. It is treated as invalid to avoid being
+// mistakenly passed when []PropertyList was intended.
+func GetMulti(c context.Context, key []*Key, dst interface{}) error {
+        v := reflect.ValueOf(dst)
+        multiArgType, _ := checkMultiArg(v)
+        if multiArgType == multiArgTypeInvalid {
+                return errors.New("datastore: dst has invalid type")
+        }
+        if len(key) != v.Len() {
+                return errors.New("datastore: key and dst slices have different length")
+        }
+        if len(key) == 0 {
+                return nil
+        }
+        if err := multiValid(key); err != nil {
+                return err
+        }
+        req := &pb.GetRequest{
+                Key: multiKeyToProto(internal.FullyQualifiedAppID(c), key),
+        }
+        res := &pb.GetResponse{}
+        if err := internal.Call(c, "datastore_v3", "Get", req, res); err != nil {
+                return err
+        }
+        if len(key) != len(res.Entity) {
+                return errors.New("datastore: internal error: server returned the wrong number of entities")
+        }
+        multiErr, any := make(appengine.MultiError, len(key)), false
+        for i, e := range res.Entity {
+                if e.Entity == nil {
+                        multiErr[i] = ErrNoSuchEntity
+                } else {
+                        elem := v.Index(i)
+                        if multiArgType == multiArgTypePropertyLoadSaver || multiArgType == multiArgTypeStruct {
+                                elem = elem.Addr()
+                        }
+                        if multiArgType == multiArgTypeStructPtr && elem.IsNil() {
+                                elem.Set(reflect.New(elem.Type().Elem()))
+                        }
+                        multiErr[i] = loadEntity(elem.Interface(), e.Entity)
+                }
+                if multiErr[i] != nil {
+                        any = true
+                }
+        }
+        if any {
+                return multiErr
+        }
+        return nil
+}
+
+// Put saves the entity src into the datastore with key k. src must be a struct
+// pointer or implement PropertyLoadSaver; if a struct pointer then any
+// unexported fields of that struct will be skipped. If k is an incomplete key,
+// the returned key will be a unique key generated by the datastore.
+func Put(c context.Context, key *Key, src interface{}) (*Key, error) {
+        k, err := PutMulti(c, []*Key{key}, []interface{}{src})
+        if err != nil {
+                if me, ok := err.(appengine.MultiError); ok {
+                        return nil, me[0]
+                }
+                return nil, err
+        }
+        return k[0], nil
+}
+
+// PutMulti is a batch version of Put.
+//
+// src must satisfy the same conditions as the dst argument to GetMulti.
+func PutMulti(c context.Context, key []*Key, src interface{}) ([]*Key, error) {
+        v := reflect.ValueOf(src)
+        multiArgType, _ := checkMultiArg(v)
+        if multiArgType == multiArgTypeInvalid {
+                return nil, errors.New("datastore: src has invalid type")
+        }
+        if len(key) != v.Len() {
+                return nil, errors.New("datastore: key and src slices have different length")
+        }
+        if len(key) == 0 {
+                return nil, nil
+        }
+        appID := internal.FullyQualifiedAppID(c)
+        if err := multiValid(key); err != nil {
+                return nil, err
+        }
+        req := &pb.PutRequest{}
+        for i := range key {
+                elem := v.Index(i)
+                if multiArgType == multiArgTypePropertyLoadSaver || multiArgType == multiArgTypeStruct {
+                        elem = elem.Addr()
+                }
+                sProto, err := saveEntity(appID, key[i], elem.Interface())
+                if err != nil {
+                        return nil, err
+                }
+                req.Entity = append(req.Entity, sProto)
+        }
+        res := &pb.PutResponse{}
+        if err := internal.Call(c, "datastore_v3", "Put", req, res); err != nil {
+                return nil, err
+        }
+        if len(key) != len(res.Key) {
+                return nil, errors.New("datastore: internal error: server returned the wrong number of keys")
+        }
+        ret := make([]*Key, len(key))
+        for i := range ret {
+                var err error
+                ret[i], err = protoToKey(res.Key[i])
+                if err != nil || ret[i].Incomplete() {
+                        return nil, errors.New("datastore: internal error: server returned an invalid key")
+                }
+        }
+        return ret, nil
+}
+
+// Delete deletes the entity for the given key.
+func Delete(c context.Context, key *Key) error {
+        err := DeleteMulti(c, []*Key{key})
+        if me, ok := err.(appengine.MultiError); ok {
+                return me[0]
+        }
+        return err
+}
+
+// DeleteMulti is a batch version of Delete.
+func DeleteMulti(c context.Context, key []*Key) error {
+        if len(key) == 0 {
+                return nil
+        }
+        if err := multiValid(key); err != nil {
+                return err
+        }
+        req := &pb.DeleteRequest{
+                Key: multiKeyToProto(internal.FullyQualifiedAppID(c), key),
+        }
+        res := &pb.DeleteResponse{}
+        return internal.Call(c, "datastore_v3", "Delete", req, res)
+}
+
+func namespaceMod(m proto.Message, namespace string) {
+        // pb.Query is the only type that has a name_space field.
+        // All other namespace support in datastore is in the keys.
+        switch m := m.(type) {
+        case *pb.Query:
+                if m.NameSpace == nil {
+                        m.NameSpace = &namespace
+                }
+        }
+}
+
+func init() {
+        internal.NamespaceMods["datastore_v3"] = namespaceMod
+        internal.RegisterErrorCodeMap("datastore_v3", pb.Error_ErrorCode_name)
+        internal.RegisterTimeoutErrorCode("datastore_v3", int32(pb.Error_TIMEOUT))
+}
diff --git a/vendor/google.golang.org/appengine/datastore/doc.go b/vendor/google.golang.org/appengine/datastore/doc.go
new file mode 100644
index 0000000..85616cf
--- /dev/null
+++ b/vendor/google.golang.org/appengine/datastore/doc.go
@@ -0,0 +1,361 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+/*
+Package datastore provides a client for App Engine's datastore service.
+
+
+Basic Operations
+
+Entities are the unit of storage and are associated with a key. A key
+consists of an optional parent key, a string application ID, a string kind
+(also known as an entity type), and either a StringID or an IntID. A
+StringID is also known as an entity name or key name.
+
+It is valid to create a key with a zero StringID and a zero IntID; this is
+called an incomplete key, and does not refer to any saved entity. Putting an
+entity into the datastore under an incomplete key will cause a unique key
+to be generated for that entity, with a non-zero IntID.
+
+An entity's contents are a mapping from case-sensitive field names to values.
+Valid value types are:
+  - signed integers (int, int8, int16, int32 and int64),
+  - bool,
+  - string,
+  - float32 and float64,
+  - []byte (up to 1 megabyte in length),
+  - any type whose underlying type is one of the above predeclared types,
+  - ByteString,
+  - *Key,
+  - time.Time (stored with microsecond precision),
+  - appengine.BlobKey,
+  - appengine.GeoPoint,
+  - structs whose fields are all valid value types,
+  - slices of any of the above.
+
+Slices of structs are valid, as are structs that contain slices. However, if
+one struct contains another, then at most one of those can be repeated. This
+disqualifies recursively defined struct types: any struct T that (directly or
+indirectly) contains a []T.
+
+The Get and Put functions load and save an entity's contents. An entity's
+contents are typically represented by a struct pointer.
+
+Example code:
+
+        type Entity struct {
+                Value string
+        }
+
+        func handle(w http.ResponseWriter, r *http.Request) {
+                ctx := appengine.NewContext(r)
+
+                k := datastore.NewKey(ctx, "Entity", "stringID", 0, nil)
+                e := new(Entity)
+                if err := datastore.Get(ctx, k, e); err != nil {
+                        http.Error(w, err.Error(), 500)
+                        return
+                }
+
+                old := e.Value
+                e.Value = r.URL.Path
+
+                if _, err := datastore.Put(ctx, k, e); err != nil {
+                        http.Error(w, err.Error(), 500)
+                        return
+                }
+
+                w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+                fmt.Fprintf(w, "old=%q\nnew=%q\n", old, e.Value)
+        }
+
+GetMulti, PutMulti and DeleteMulti are batch versions of the Get, Put and
+Delete functions. They take a []*Key instead of a *Key, and may return an
+appengine.MultiError when encountering partial failure.
+
+
+Properties
+
+An entity's contents can be represented by a variety of types. These are
+typically struct pointers, but can also be any type that implements the
+PropertyLoadSaver interface. If using a struct pointer, you do not have to
+explicitly implement the PropertyLoadSaver interface; the datastore will
+automatically convert via reflection. If a struct pointer does implement that
+interface then those methods will be used in preference to the default
+behavior for struct pointers. Struct pointers are more strongly typed and are
+easier to use; PropertyLoadSavers are more flexible.
+
+The actual types passed do not have to match between Get and Put calls or even
+across different calls to datastore. It is valid to put a *PropertyList and
+get that same entity as a *myStruct, or put a *myStruct0 and get a *myStruct1.
+Conceptually, any entity is saved as a sequence of properties, and is loaded
+into the destination value on a property-by-property basis. When loading into
+a struct pointer, an entity that cannot be completely represented (such as a
+missing field) will result in an ErrFieldMismatch error but it is up to the
+caller whether this error is fatal, recoverable or ignorable.
+
+By default, for struct pointers, all properties are potentially indexed, and
+the property name is the same as the field name (and hence must start with an
+upper case letter).
+
+Fields may have a `datastore:"name,options"` tag. The tag name is the
+property name, which must be one or more valid Go identifiers joined by ".",
+but may start with a lower case letter. An empty tag name means to just use the
+field name. A "-" tag name means that the datastore will ignore that field.
+
+The only valid options are "omitempty" and "noindex".
+
+If the options include "omitempty" and the value of the field is empty, then the field will be omitted on Save.
+The empty values are false, 0, any nil interface value, and any array, slice, map, or string of length zero.
+Struct field values will never be empty.
+
+If options include "noindex" then the field will not be indexed. All fields are indexed
+by default. Strings or byte slices longer than 1500 bytes cannot be indexed;
+fields used to store long strings and byte slices must be tagged with "noindex"
+or they will cause Put operations to fail.
+
+To use multiple options together, separate them by a comma.
+The order does not matter.
+
+If the options is "" then the comma may be omitted.
+
+Example code:
+
+        // A and B are renamed to a and b.
+        // A, C and J are not indexed.
+        // D's tag is equivalent to having no tag at all (E).
+        // I is ignored entirely by the datastore.
+        // J has tag information for both the datastore and json packages.
+        type TaggedStruct struct {
+                A int `datastore:"a,noindex"`
+                B int `datastore:"b"`
+                C int `datastore:",noindex"`
+                D int `datastore:""`
+                E int
+                I int `datastore:"-"`
+                J int `datastore:",noindex" json:"j"`
+        }
+
+
+Structured Properties
+
+If the struct pointed to contains other structs, then the nested or embedded
+structs are flattened. For example, given these definitions:
+
+        type Inner1 struct {
+                W int32
+                X string
+        }
+
+        type Inner2 struct {
+                Y float64
+        }
+
+        type Inner3 struct {
+                Z bool
+        }
+
+        type Outer struct {
+                A int16
+                I []Inner1
+                J Inner2
+                Inner3
+        }
+
+then an Outer's properties would be equivalent to those of:
+
+        type OuterEquivalent struct {
+                A     int16
+                IDotW []int32  `datastore:"I.W"`
+                IDotX []string `datastore:"I.X"`
+                JDotY float64  `datastore:"J.Y"`
+                Z     bool
+        }
+
+If Outer's embedded Inner3 field was tagged as `datastore:"Foo"` then the
+equivalent field would instead be: FooDotZ bool `datastore:"Foo.Z"`.
+
+If an outer struct is tagged "noindex" then all of its implicit flattened
+fields are effectively "noindex".
+
+
+The PropertyLoadSaver Interface
+
+An entity's contents can also be represented by any type that implements the
+PropertyLoadSaver interface. This type may be a struct pointer, but it does
+not have to be. The datastore package will call Load when getting the entity's
+contents, and Save when putting the entity's contents.
+Possible uses include deriving non-stored fields, verifying fields, or indexing
+a field only if its value is positive.
+
+Example code:
+
+        type CustomPropsExample struct {
+                I, J int
+                // Sum is not stored, but should always be equal to I + J.
+                Sum int `datastore:"-"`
+        }
+
+        func (x *CustomPropsExample) Load(ps []datastore.Property) error {
+                // Load I and J as usual.
+                if err := datastore.LoadStruct(x, ps); err != nil {
+                        return err
+                }
+                // Derive the Sum field.
+                x.Sum = x.I + x.J
+                return nil
+        }
+
+        func (x *CustomPropsExample) Save() ([]datastore.Property, error) {
+                // Validate the Sum field.
+                if x.Sum != x.I + x.J {
+                        return nil, errors.New("CustomPropsExample has inconsistent sum")
+                }
+                // Save I and J as usual. The code below is equivalent to calling
+                // "return datastore.SaveStruct(x)", but is done manually for
+                // demonstration purposes.
+                return []datastore.Property{
+                        {
+                                Name:  "I",
+                                Value: int64(x.I),
+                        },
+                        {
+                                Name:  "J",
+                                Value: int64(x.J),
+                        },
+                }, nil
+        }
+
+The *PropertyList type implements PropertyLoadSaver, and can therefore hold an
+arbitrary entity's contents.
+
+
+Queries
+
+Queries retrieve entities based on their properties or key's ancestry. Running
+a query yields an iterator of results: either keys or (key, entity) pairs.
+Queries are re-usable and it is safe to call Query.Run from concurrent
+goroutines. Iterators are not safe for concurrent use.
+
+Queries are immutable, and are either created by calling NewQuery, or derived
+from an existing query by calling a method like Filter or Order that returns a
+new query value. A query is typically constructed by calling NewQuery followed
+by a chain of zero or more such methods. These methods are:
+  - Ancestor and Filter constrain the entities returned by running a query.
+  - Order affects the order in which they are returned.
+  - Project constrains the fields returned.
+  - Distinct de-duplicates projected entities.
+  - KeysOnly makes the iterator return only keys, not (key, entity) pairs.
+  - Start, End, Offset and Limit define which sub-sequence of matching entities
+    to return. Start and End take cursors, Offset and Limit take integers. Start
+    and Offset affect the first result, End and Limit affect the last result.
+    If both Start and Offset are set, then the offset is relative to Start.
+    If both End and Limit are set, then the earliest constraint wins. Limit is
+    relative to Start+Offset, not relative to End. As a special case, a
+    negative limit means unlimited.
+
+Example code:
+
+        type Widget struct {
+                Description string
+                Price       int
+        }
+
+        func handle(w http.ResponseWriter, r *http.Request) {
+                ctx := appengine.NewContext(r)
+                q := datastore.NewQuery("Widget").
+                        Filter("Price <", 1000).
+                        Order("-Price")
+                b := new(bytes.Buffer)
+                for t := q.Run(ctx); ; {
+                        var x Widget
+                        key, err := t.Next(&x)
+                        if err == datastore.Done {
+                                break
+                        }
+                        if err != nil {
+                                serveError(ctx, w, err)
+                                return
+                        }
+                        fmt.Fprintf(b, "Key=%v\nWidget=%#v\n\n", key, x)
+                }
+                w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+                io.Copy(w, b)
+        }
+
+
+Transactions
+
+RunInTransaction runs a function in a transaction.
+
+Example code:
+
+        type Counter struct {
+                Count int
+        }
+
+        func inc(ctx context.Context, key *datastore.Key) (int, error) {
+                var x Counter
+                if err := datastore.Get(ctx, key, &x); err != nil && err != datastore.ErrNoSuchEntity {
+                        return 0, err
+                }
+                x.Count++
+                if _, err := datastore.Put(ctx, key, &x); err != nil {
+                        return 0, err
+                }
+                return x.Count, nil
+        }
+
+        func handle(w http.ResponseWriter, r *http.Request) {
+                ctx := appengine.NewContext(r)
+                var count int
+                err := datastore.RunInTransaction(ctx, func(ctx context.Context) error {
+                        var err1 error
+                        count, err1 = inc(ctx, datastore.NewKey(ctx, "Counter", "singleton", 0, nil))
+                        return err1
+                }, nil)
+                if err != nil {
+                        serveError(ctx, w, err)
+                        return
+                }
+                w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+                fmt.Fprintf(w, "Count=%d", count)
+        }
+
+
+Metadata
+
+The datastore package provides access to some of App Engine's datastore
+metadata. This metadata includes information about the entity groups,
+namespaces, entity kinds, and properties in the datastore, as well as the
+property representations for each property.
+
+Example code:
+
+        func handle(w http.ResponseWriter, r *http.Request) {
+                // Print all the kinds in the datastore, with all the indexed
+                // properties (and their representations) for each.
+                ctx := appengine.NewContext(r)
+
+                kinds, err := datastore.Kinds(ctx)
+                if err != nil {
+                        serveError(ctx, w, err)
+                        return
+                }
+
+                w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+                for _, kind := range kinds {
+                        fmt.Fprintf(w, "%s:\n", kind)
+                        props, err := datastore.KindProperties(ctx, kind)
+                        if err != nil {
+                                fmt.Fprintln(w, "\t(unable to retrieve properties)")
+                                continue
+                        }
+                        for p, rep := range props {
+                                fmt.Fprintf(w, "\t-%s (%s)\n", p, strings.Join(rep, ", "))
+                        }
+                }
+        }
+*/
+package datastore // import "google.golang.org/appengine/datastore"
diff --git a/vendor/google.golang.org/appengine/datastore/key.go b/vendor/google.golang.org/appengine/datastore/key.go
new file mode 100644
index 0000000..6ab83ea
--- /dev/null
+++ b/vendor/google.golang.org/appengine/datastore/key.go
@@ -0,0 +1,396 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package datastore
+
+import (
+        "bytes"
+        "encoding/base64"
+        "encoding/gob"
+        "errors"
+        "fmt"
+        "strconv"
+        "strings"
+
+        "github.com/golang/protobuf/proto"
+        "golang.org/x/net/context"
+
+        "google.golang.org/appengine/internal"
+        pb "google.golang.org/appengine/internal/datastore"
+)
+
+type KeyRangeCollisionError struct {
+        start int64
+        end   int64
+}
+
+func (e *KeyRangeCollisionError) Error() string {
+        return fmt.Sprintf("datastore: Collision when attempting to allocate range [%d, %d]",
+                e.start, e.end)
+}
+
+type KeyRangeContentionError struct {
+        start int64
+        end   int64
+}
+
+func (e *KeyRangeContentionError) Error() string {
+        return fmt.Sprintf("datastore: Contention when attempting to allocate range [%d, %d]",
+                e.start, e.end)
+}
+
+// Key represents the datastore key for a stored entity, and is immutable.
+type Key struct {
+        kind      string
+        stringID  string
+        intID     int64
+        parent    *Key
+        appID     string
+        namespace string
+}
+
+// Kind returns the key's kind (also known as entity type).
+func (k *Key) Kind() string {
+        return k.kind
+}
+
+// StringID returns the key's string ID (also known as an entity name or key
+// name), which may be "".
+func (k *Key) StringID() string {
+        return k.stringID
+}
+
+// IntID returns the key's integer ID, which may be 0.
+func (k *Key) IntID() int64 {
+        return k.intID
+}
+
+// Parent returns the key's parent key, which may be nil.
+func (k *Key) Parent() *Key {
+        return k.parent
+}
+
+// AppID returns the key's application ID.
+func (k *Key) AppID() string {
+        return k.appID
+}
+
+// Namespace returns the key's namespace.
+func (k *Key) Namespace() string {
+        return k.namespace
+}
+
+// Incomplete returns whether the key does not refer to a stored entity.
+// In particular, whether the key has a zero StringID and a zero IntID.
+func (k *Key) Incomplete() bool {
+        return k.stringID == "" && k.intID == 0
+}
+
+// valid returns whether the key is valid.
+func (k *Key) valid() bool {
+        if k == nil {
+                return false
+        }
+        for ; k != nil; k = k.parent {
+                if k.kind == "" || k.appID == "" {
+                        return false
+                }
+                if k.stringID != "" && k.intID != 0 {
+                        return false
+                }
+                if k.parent != nil {
+                        if k.parent.Incomplete() {
+                                return false
+                        }
+                        if k.parent.appID != k.appID || k.parent.namespace != k.namespace {
+                                return false
+                        }
+                }
+        }
+        return true
+}
+
+// Equal returns whether two keys are equal.
+func (k *Key) Equal(o *Key) bool {
+        for k != nil && o != nil {
+                if k.kind != o.kind || k.stringID != o.stringID || k.intID != o.intID || k.appID != o.appID || k.namespace != o.namespace {
+                        return false
+                }
+                k, o = k.parent, o.parent
+        }
+        return k == o
+}
+
+// root returns the furthest ancestor of a key, which may be itself.
+func (k *Key) root() *Key {
+        for k.parent != nil {
+                k = k.parent
+        }
+        return k
+}
+
+// marshal marshals the key's string representation to the buffer.
+func (k *Key) marshal(b *bytes.Buffer) {
+        if k.parent != nil {
+                k.parent.marshal(b)
+        }
+        b.WriteByte('/')
+        b.WriteString(k.kind)
+        b.WriteByte(',')
+        if k.stringID != "" {
+                b.WriteString(k.stringID)
+        } else {
+                b.WriteString(strconv.FormatInt(k.intID, 10))
+        }
+}
+
+// String returns a string representation of the key.
+func (k *Key) String() string {
+        if k == nil {
+                return ""
+        }
+        b := bytes.NewBuffer(make([]byte, 0, 512))
+        k.marshal(b)
+        return b.String()
+}
+
+type gobKey struct {
+        Kind      string
+        StringID  string
+        IntID     int64
+        Parent    *gobKey
+        AppID     string
+        Namespace string
+}
+
+func keyToGobKey(k *Key) *gobKey {
+        if k == nil {
+                return nil
+        }
+        return &gobKey{
+                Kind:      k.kind,
+                StringID:  k.stringID,
+                IntID:     k.intID,
+                Parent:    keyToGobKey(k.parent),
+                AppID:     k.appID,
+                Namespace: k.namespace,
+        }
+}
+
+func gobKeyToKey(gk *gobKey) *Key {
+        if gk == nil {
+                return nil
+        }
+        return &Key{
+                kind:      gk.Kind,
+                stringID:  gk.StringID,
+                intID:     gk.IntID,
+                parent:    gobKeyToKey(gk.Parent),
+                appID:     gk.AppID,
+                namespace: gk.Namespace,
+        }
+}
+
+func (k *Key) GobEncode() ([]byte, error) {
+        buf := new(bytes.Buffer)
+        if err := gob.NewEncoder(buf).Encode(keyToGobKey(k)); err != nil {
+                return nil, err
+        }
+        return buf.Bytes(), nil
+}
+
+func (k *Key) GobDecode(buf []byte) error {
+        gk := new(gobKey)
+        if err := gob.NewDecoder(bytes.NewBuffer(buf)).Decode(gk); err != nil {
+                return err
+        }
+        *k = *gobKeyToKey(gk)
+        return nil
+}
+
+func (k *Key) MarshalJSON() ([]byte, error) {
+        return []byte(`"` + k.Encode() + `"`), nil
+}
+
+func (k *Key) UnmarshalJSON(buf []byte) error {
+        if len(buf) < 2 || buf[0] != '"' || buf[len(buf)-1] != '"' {
+                return errors.New("datastore: bad JSON key")
+        }
+        k2, err := DecodeKey(string(buf[1 : len(buf)-1]))
+        if err != nil {
+                return err
+        }
+        *k = *k2
+        return nil
+}
+
+// Encode returns an opaque representation of the key
+// suitable for use in HTML and URLs.
+// This is compatible with the Python and Java runtimes.
+func (k *Key) Encode() string {
+        ref := keyToProto("", k)
+
+        b, err := proto.Marshal(ref)
+        if err != nil {
+                panic(err)
+        }
+
+        // Trailing padding is stripped.
+        return strings.TrimRight(base64.URLEncoding.EncodeToString(b), "=")
+}
+
+// DecodeKey decodes a key from the opaque representation returned by Encode.
+func DecodeKey(encoded string) (*Key, error) {
+        // Re-add padding.
+        if m := len(encoded) % 4; m != 0 {
+                encoded += strings.Repeat("=", 4-m)
+        }
+
+        b, err := base64.URLEncoding.DecodeString(encoded)
+        if err != nil {
+                return nil, err
+        }
+
+        ref := new(pb.Reference)
+        if err := proto.Unmarshal(b, ref); err != nil {
+                return nil, err
+        }
+
+        return protoToKey(ref)
+}
+
+// NewIncompleteKey creates a new incomplete key.
+// kind cannot be empty.
+func NewIncompleteKey(c context.Context, kind string, parent *Key) *Key {
+        return NewKey(c, kind, "", 0, parent)
+}
+
+// NewKey creates a new key.
+// kind cannot be empty.
+// Either one or both of stringID and intID must be zero. If both are zero,
+// the key returned is incomplete.
+// parent must either be a complete key or nil.
+func NewKey(c context.Context, kind, stringID string, intID int64, parent *Key) *Key {
+        // If there's a parent key, use its namespace.
+        // Otherwise, use any namespace attached to the context.
+        var namespace string
+        if parent != nil {
+                namespace = parent.namespace
+        } else {
+                namespace = internal.NamespaceFromContext(c)
+        }
+
+        return &Key{
+                kind:      kind,
+                stringID:  stringID,
+                intID:     intID,
+                parent:    parent,
+                appID:     internal.FullyQualifiedAppID(c),
+                namespace: namespace,
+        }
+}
+
+// AllocateIDs returns a range of n integer IDs with the given kind and parent
+// combination. kind cannot be empty; parent may be nil. The IDs in the range
+// returned will not be used by the datastore's automatic ID sequence generator
+// and may be used with NewKey without conflict.
+//
+// The range is inclusive at the low end and exclusive at the high end. In
+// other words, valid intIDs x satisfy low <= x && x < high.
+//
+// If no error is returned, low + n == high.
+func AllocateIDs(c context.Context, kind string, parent *Key, n int) (low, high int64, err error) {
+        if kind == "" {
+                return 0, 0, errors.New("datastore: AllocateIDs given an empty kind")
+        }
+        if n < 0 {
+                return 0, 0, fmt.Errorf("datastore: AllocateIDs given a negative count: %d", n)
+        }
+        if n == 0 {
+                return 0, 0, nil
+        }
+        req := &pb.AllocateIdsRequest{
+                ModelKey: keyToProto("", NewIncompleteKey(c, kind, parent)),
+                Size:     proto.Int64(int64(n)),
+        }
+        res := &pb.AllocateIdsResponse{}
+        if err := internal.Call(c, "datastore_v3", "AllocateIds", req, res); err != nil {
+                return 0, 0, err
+        }
+        // The protobuf is inclusive at both ends. Idiomatic Go (e.g. slices, for loops)
+        // is inclusive at the low end and exclusive at the high end, so we add 1.
+        low = res.GetStart()
+        high = res.GetEnd() + 1
+        if low+int64(n) != high {
+                return 0, 0, fmt.Errorf("datastore: internal error: could not allocate %d IDs", n)
+        }
+        return low, high, nil
+}
+
+// AllocateIDRange allocates a range of IDs with specific endpoints.
+// The range is inclusive at both the low and high end. Once these IDs have been
+// allocated, you can manually assign them to newly created entities.
+//
+// The Datastore's automatic ID allocator never assigns a key that has already
+// been allocated (either through automatic ID allocation or through an explicit
+// AllocateIDs call). As a result, entities written to the given key range will
+// never be overwritten. However, writing entities with manually assigned keys in
+// this range may overwrite existing entities (or new entities written by a separate
+// request), depending on the error returned.
+//
+// Use this only if you have an existing numeric ID range that you want to reserve
+// (for example, bulk loading entities that already have IDs). If you don't care
+// about which IDs you receive, use AllocateIDs instead.
+//
+// AllocateIDRange returns nil if the range is successfully allocated. If one or more
+// entities with an ID in the given range already exist, it returns a KeyRangeCollisionError.
+// If the Datastore has already cached IDs in this range (e.g. from a previous call to
+// AllocateIDRange), it returns a KeyRangeContentionError. Errors of other types indicate
+// problems with arguments or an error returned directly from the Datastore.
+func AllocateIDRange(c context.Context, kind string, parent *Key, start, end int64) (err error) {
+        if kind == "" {
+                return errors.New("datastore: AllocateIDRange given an empty kind")
+        }
+
+        if start < 1 || end < 1 {
+                return errors.New("datastore: AllocateIDRange start and end must both be greater than 0")
+        }
+
+        if start > end {
+                return errors.New("datastore: AllocateIDRange start must be before end")
+        }
+
+        req := &pb.AllocateIdsRequest{
+                ModelKey: keyToProto("", NewIncompleteKey(c, kind, parent)),
+                Max:      proto.Int64(end),
+        }
+        res := &pb.AllocateIdsResponse{}
+        if err := internal.Call(c, "datastore_v3", "AllocateIds", req, res); err != nil {
+                return err
+        }
+
+        // Check for collisions, i.e. existing entities with IDs in this range.
+        // We could do this before the allocation, but we'd still have to do it
+        // afterward as well to catch the race condition where an entity is inserted
+        // after that initial check but before the allocation. Skip the up-front check
+        // and just do it once.
+        q := NewQuery(kind).Filter("__key__ >=", NewKey(c, kind, "", start, parent)).
+                Filter("__key__ <=", NewKey(c, kind, "", end, parent)).KeysOnly().Limit(1)
+
+        keys, err := q.GetAll(c, nil)
+        if err != nil {
+                return err
+        }
+        if len(keys) != 0 {
+                return &KeyRangeCollisionError{start: start, end: end}
+        }
+
+        // Check for a race condition, i.e. cases where the datastore may have
+        // cached ID batches that contain IDs in this range.
+        if start < res.GetStart() {
+                return &KeyRangeContentionError{start: start, end: end}
+        }
+
+        return nil
+}
diff --git a/vendor/google.golang.org/appengine/datastore/load.go b/vendor/google.golang.org/appengine/datastore/load.go
new file mode 100644
index 0000000..38a6365
--- /dev/null
+++ b/vendor/google.golang.org/appengine/datastore/load.go
@@ -0,0 +1,429 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package datastore
+
+import (
+        "fmt"
+        "reflect"
+        "strings"
+        "time"
+
+        "github.com/golang/protobuf/proto"
+        "google.golang.org/appengine"
+        pb "google.golang.org/appengine/internal/datastore"
+)
+
+var (
+        typeOfBlobKey    = reflect.TypeOf(appengine.BlobKey(""))
+        typeOfByteSlice  = reflect.TypeOf([]byte(nil))
+        typeOfByteString = reflect.TypeOf(ByteString(nil))
+        typeOfGeoPoint   = reflect.TypeOf(appengine.GeoPoint{})
+        typeOfTime       = reflect.TypeOf(time.Time{})
+        typeOfKeyPtr     = reflect.TypeOf(&Key{})
+        typeOfEntityPtr  = reflect.TypeOf(&Entity{})
+)
+
+// typeMismatchReason returns a string explaining why the property p could not
+// be stored in an entity field of type v.Type().
+func typeMismatchReason(pValue interface{}, v reflect.Value) string {
+        entityType := "empty"
+        switch pValue.(type) {
+        case int64:
+                entityType = "int"
+        case bool:
+                entityType = "bool"
+        case string:
+                entityType = "string"
+        case float64:
+                entityType = "float"
+        case *Key:
+                entityType = "*datastore.Key"
+        case time.Time:
+                entityType = "time.Time"
+        case appengine.BlobKey:
+                entityType = "appengine.BlobKey"
+        case appengine.GeoPoint:
+                entityType = "appengine.GeoPoint"
+        case ByteString:
+                entityType = "datastore.ByteString"
+        case []byte:
+                entityType = "[]byte"
+        }
+        return fmt.Sprintf("type mismatch: %s versus %v", entityType, v.Type())
+}
+
+type propertyLoader struct {
+        // m holds the number of times a substruct field like "Foo.Bar.Baz" has
+        // been seen so far. The map is constructed lazily.
+        m map[string]int
+}
+
+func (l *propertyLoader) load(codec *structCodec, structValue reflect.Value, p Property, requireSlice bool) string {
+        var v reflect.Value
+        var sliceIndex int
+
+        name := p.Name
+
+        // If name ends with a '.', the last field is anonymous.
+        // In this case, strings.Split will give us "" as the
+        // last element of our fields slice, which will match the ""
+        // field name in the substruct codec.
+        fields := strings.Split(name, ".")
+
+        for len(fields) > 0 {
+                var decoder fieldCodec
+                var ok bool
+
+                // Cut off the last field (delimited by ".") and find its parent
+                // in the codec.
+                // eg. for name "A.B.C.D", split off "A.B.C" and try to
+                // find a field in the codec with this name.
+                // Loop again with "A.B", etc.
+                for i := len(fields); i > 0; i-- {
+                        parent := strings.Join(fields[:i], ".")
+                        decoder, ok = codec.fields[parent]
+                        if ok {
+                                fields = fields[i:]
+                                break
+                        }
+                }
+
+                // If we never found a matching field in the codec, return
+                // error message.
+                if !ok {
+                        return "no such struct field"
+                }
+
+                v = initField(structValue, decoder.path)
+                if !v.IsValid() {
+                        return "no such struct field"
+                }
+                if !v.CanSet() {
+                        return "cannot set struct field"
+                }
+
+                if decoder.structCodec != nil {
+                        codec = decoder.structCodec
+                        structValue = v
+                }
+
+                if v.Kind() == reflect.Slice && v.Type() != typeOfByteSlice {
+                        if l.m == nil {
+                                l.m = make(map[string]int)
+                        }
+                        sliceIndex = l.m[p.Name]
+                        l.m[p.Name] = sliceIndex + 1
+                        for v.Len() <= sliceIndex {
+                                v.Set(reflect.Append(v, reflect.New(v.Type().Elem()).Elem()))
+                        }
+                        structValue = v.Index(sliceIndex)
+                        requireSlice = false
+                }
+        }
+
+        var slice reflect.Value
+        if v.Kind() == reflect.Slice && v.Type().Elem().Kind() != reflect.Uint8 {
+                slice = v
+                v = reflect.New(v.Type().Elem()).Elem()
+        } else if requireSlice {
+                return "multiple-valued property requires a slice field type"
+        }
+
+        // Convert indexValues to a Go value with a meaning derived from the
+        // destination type.
+        pValue := p.Value
+        if iv, ok := pValue.(indexValue); ok {
+                meaning := pb.Property_NO_MEANING
+                switch v.Type() {
+                case typeOfBlobKey:
+                        meaning = pb.Property_BLOBKEY
+                case typeOfByteSlice:
+                        meaning = pb.Property_BLOB
+                case typeOfByteString:
+                        meaning = pb.Property_BYTESTRING
+                case typeOfGeoPoint:
+                        meaning = pb.Property_GEORSS_POINT
+                case typeOfTime:
+                        meaning = pb.Property_GD_WHEN
+                case typeOfEntityPtr:
+                        meaning = pb.Property_ENTITY_PROTO
+                }
+                var err error
+                pValue, err = propValue(iv.value, meaning)
+                if err != nil {
+                        return err.Error()
+                }
+        }
+
+        if errReason := setVal(v, pValue); errReason != "" {
+                // Set the slice back to its zero value.
+                if slice.IsValid() {
+                        slice.Set(reflect.Zero(slice.Type()))
+                }
+                return errReason
+        }
+
+        if slice.IsValid() {
+                slice.Index(sliceIndex).Set(v)
+        }
+
+        return ""
+}
+
+// setVal sets v to the value pValue.
+func setVal(v reflect.Value, pValue interface{}) string {
+        switch v.Kind() {
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                x, ok := pValue.(int64)
+                if !ok && pValue != nil {
+                        return typeMismatchReason(pValue, v)
+                }
+                if v.OverflowInt(x) {
+                        return fmt.Sprintf("value %v overflows struct field of type %v", x, v.Type())
+                }
+                v.SetInt(x)
+        case reflect.Bool:
+                x, ok := pValue.(bool)
+                if !ok && pValue != nil {
+                        return typeMismatchReason(pValue, v)
+                }
+                v.SetBool(x)
+        case reflect.String:
+                switch x := pValue.(type) {
+                case appengine.BlobKey:
+                        v.SetString(string(x))
+                case ByteString:
+                        v.SetString(string(x))
+                case string:
+                        v.SetString(x)
+                default:
+                        if pValue != nil {
+                                return typeMismatchReason(pValue, v)
+                        }
+                }
+        case reflect.Float32, reflect.Float64:
+                x, ok := pValue.(float64)
+                if !ok && pValue != nil {
+                        return typeMismatchReason(pValue, v)
+                }
+                if v.OverflowFloat(x) {
+                        return fmt.Sprintf("value %v overflows struct field of type %v", x, v.Type())
+                }
+                v.SetFloat(x)
+        case reflect.Ptr:
+                x, ok := pValue.(*Key)
+                if !ok && pValue != nil {
+                        return typeMismatchReason(pValue, v)
+                }
+                if _, ok := v.Interface().(*Key); !ok {
+                        return typeMismatchReason(pValue, v)
+                }
+                v.Set(reflect.ValueOf(x))
+        case reflect.Struct:
+                switch v.Type() {
+                case typeOfTime:
+                        x, ok := pValue.(time.Time)
+                        if !ok && pValue != nil {
+                                return typeMismatchReason(pValue, v)
+                        }
+                        v.Set(reflect.ValueOf(x))
+                case typeOfGeoPoint:
+                        x, ok := pValue.(appengine.GeoPoint)
+                        if !ok && pValue != nil {
+                                return typeMismatchReason(pValue, v)
+                        }
+                        v.Set(reflect.ValueOf(x))
+                default:
+                        ent, ok := pValue.(*Entity)
+                        if !ok {
+                                return typeMismatchReason(pValue, v)
+                        }
+
+                        // Recursively load nested struct
+                        pls, err := newStructPLS(v.Addr().Interface())
+                        if err != nil {
+                                return err.Error()
+                        }
+
+                        // if ent has a Key value and our struct has a Key field,
+                        // load the Entity's Key value into the Key field on the struct.
+                        if ent.Key != nil && pls.codec.keyField != -1 {
+
+                                pls.v.Field(pls.codec.keyField).Set(reflect.ValueOf(ent.Key))
+                        }
+
+                        err = pls.Load(ent.Properties)
+                        if err != nil {
+                                return err.Error()
+                        }
+                }
+        case reflect.Slice:
+                x, ok := pValue.([]byte)
+                if !ok {
+                        if y, yok := pValue.(ByteString); yok {
+                                x, ok = []byte(y), true
+                        }
+                }
+                if !ok && pValue != nil {
+                        return typeMismatchReason(pValue, v)
+                }
+                if v.Type().Elem().Kind() != reflect.Uint8 {
+                        return typeMismatchReason(pValue, v)
+                }
+                v.SetBytes(x)
+        default:
+                return typeMismatchReason(pValue, v)
+        }
+        return ""
+}
+
+// initField is similar to reflect's Value.FieldByIndex, in that it
+// returns the nested struct field corresponding to index, but it
+// initialises any nil pointers encountered when traversing the structure.
+func initField(val reflect.Value, index []int) reflect.Value {
+        for _, i := range index[:len(index)-1] {
+                val = val.Field(i)
+                if val.Kind() == reflect.Ptr {
+                        if val.IsNil() {
+                                val.Set(reflect.New(val.Type().Elem()))
+                        }
+                        val = val.Elem()
+                }
+        }
+        return val.Field(index[len(index)-1])
+}
+
+// loadEntity loads an EntityProto into PropertyLoadSaver or struct pointer.
+func loadEntity(dst interface{}, src *pb.EntityProto) (err error) {
+        ent, err := protoToEntity(src)
+        if err != nil {
+                return err
+        }
+        if e, ok := dst.(PropertyLoadSaver); ok {
+                return e.Load(ent.Properties)
+        }
+        return LoadStruct(dst, ent.Properties)
+}
+
+func (s structPLS) Load(props []Property) error {
+        var fieldName, reason string
+        var l propertyLoader
+        for _, p := range props {
+                if errStr := l.load(s.codec, s.v, p, p.Multiple); errStr != "" {
+                        // We don't return early, as we try to load as many properties as possible.
+                        // It is valid to load an entity into a struct that cannot fully represent it.
+                        // That case returns an error, but the caller is free to ignore it.
+                        fieldName, reason = p.Name, errStr
+                }
+        }
+        if reason != "" {
+                return &ErrFieldMismatch{
+                        StructType: s.v.Type(),
+                        FieldName:  fieldName,
+                        Reason:     reason,
+                }
+        }
+        return nil
+}
+
+func protoToEntity(src *pb.EntityProto) (*Entity, error) {
+        props, rawProps := src.Property, src.RawProperty
+        outProps := make([]Property, 0, len(props)+len(rawProps))
+        for {
+                var (
+                        x       *pb.Property
+                        noIndex bool
+                )
+                if len(props) > 0 {
+                        x, props = props[0], props[1:]
+                } else if len(rawProps) > 0 {
+                        x, rawProps = rawProps[0], rawProps[1:]
+                        noIndex = true
+                } else {
+                        break
+                }
+
+                var value interface{}
+                if x.Meaning != nil && *x.Meaning == pb.Property_INDEX_VALUE {
+                        value = indexValue{x.Value}
+                } else {
+                        var err error
+                        value, err = propValue(x.Value, x.GetMeaning())
+                        if err != nil {
+                                return nil, err
+                        }
+                }
+                outProps = append(outProps, Property{
+                        Name:     x.GetName(),
+                        Value:    value,
+                        NoIndex:  noIndex,
+                        Multiple: x.GetMultiple(),
+                })
+        }
+
+        var key *Key
+        if src.Key != nil {
+                // Ignore any error, since nested entity values
+                // are allowed to have an invalid key.
+                key, _ = protoToKey(src.Key)
+        }
+        return &Entity{key, outProps}, nil
+}
+
+// propValue returns a Go value that combines the raw PropertyValue with a
+// meaning. For example, an Int64Value with GD_WHEN becomes a time.Time.
+func propValue(v *pb.PropertyValue, m pb.Property_Meaning) (interface{}, error) {
+        switch {
+        case v.Int64Value != nil:
+                if m == pb.Property_GD_WHEN {
+                        return fromUnixMicro(*v.Int64Value), nil
+                } else {
+                        return *v.Int64Value, nil
+                }
+        case v.BooleanValue != nil:
+                return *v.BooleanValue, nil
+        case v.StringValue != nil:
+                if m == pb.Property_BLOB {
+                        return []byte(*v.StringValue), nil
+                } else if m == pb.Property_BLOBKEY {
+                        return appengine.BlobKey(*v.StringValue), nil
+                } else if m == pb.Property_BYTESTRING {
+                        return ByteString(*v.StringValue), nil
+                } else if m == pb.Property_ENTITY_PROTO {
+                        var ent pb.EntityProto
+                        err := proto.Unmarshal([]byte(*v.StringValue), &ent)
+                        if err != nil {
+                                return nil, err
+                        }
+                        return protoToEntity(&ent)
+                } else {
+                        return *v.StringValue, nil
+                }
+        case v.DoubleValue != nil:
+                return *v.DoubleValue, nil
+        case v.Referencevalue != nil:
+                key, err := referenceValueToKey(v.Referencevalue)
+                if err != nil {
+                        return nil, err
+                }
+                return key, nil
+        case v.Pointvalue != nil:
+                // NOTE: Strangely, latitude maps to X, longitude to Y.
+                return appengine.GeoPoint{Lat: v.Pointvalue.GetX(), Lng: v.Pointvalue.GetY()}, nil
+        }
+        return nil, nil
+}
+
+// indexValue is a Property value that is created when entities are loaded from
+// an index, such as from a projection query.
+//
+// Such Property values do not contain all of the metadata required to be
+// faithfully represented as a Go value, and are instead represented as an
+// opaque indexValue. Load the properties into a concrete struct type (e.g. by
+// passing a struct pointer to Iterator.Next) to reconstruct actual Go values
+// of type int, string, time.Time, etc.
+type indexValue struct {
+        value *pb.PropertyValue
+}
diff --git a/vendor/google.golang.org/appengine/datastore/metadata.go b/vendor/google.golang.org/appengine/datastore/metadata.go
new file mode 100644
index 0000000..6acacc3
--- /dev/null
+++ b/vendor/google.golang.org/appengine/datastore/metadata.go
@@ -0,0 +1,78 @@
+// Copyright 2016 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package datastore
+
+import "golang.org/x/net/context"
+
+// Datastore kinds for the metadata entities.
+const (
+        namespaceKind = "__namespace__"
+        kindKind      = "__kind__"
+        propertyKind  = "__property__"
+)
+
+// Namespaces returns all the datastore namespaces.
+func Namespaces(ctx context.Context) ([]string, error) {
+        // TODO(djd): Support range queries.
+        q := NewQuery(namespaceKind).KeysOnly()
+        keys, err := q.GetAll(ctx, nil)
+        if err != nil {
+                return nil, err
+        }
+        // The empty namespace key uses a numeric ID (==1), but luckily
+        // the string ID defaults to "" for numeric IDs anyway.
+        return keyNames(keys), nil
+}
+
+// Kinds returns the names of all the kinds in the current namespace.
+func Kinds(ctx context.Context) ([]string, error) {
+        // TODO(djd): Support range queries.
+        q := NewQuery(kindKind).KeysOnly()
+        keys, err := q.GetAll(ctx, nil)
+        if err != nil {
+                return nil, err
+        }
+        return keyNames(keys), nil
+}
+
+// keyNames returns a slice of the provided keys' names (string IDs).
+func keyNames(keys []*Key) []string {
+        n := make([]string, 0, len(keys))
+        for _, k := range keys {
+                n = append(n, k.StringID())
+        }
+        return n
+}
+
+// KindProperties returns all the indexed properties for the given kind.
+// The properties are returned as a map of property names to a slice of the
+// representation types. The representation types for the supported Go property
+// types are:
+//   "INT64":     signed integers and time.Time
+//   "DOUBLE":    float32 and float64
+//   "BOOLEAN":   bool
+//   "STRING":    string, []byte and ByteString
+//   "POINT":     appengine.GeoPoint
+//   "REFERENCE": *Key
+//   "USER":      (not used in the Go runtime)
+func KindProperties(ctx context.Context, kind string) (map[string][]string, error) {
+        // TODO(djd): Support range queries.
+        kindKey := NewKey(ctx, kindKind, kind, 0, nil)
+        q := NewQuery(propertyKind).Ancestor(kindKey)
+
+        propMap := map[string][]string{}
+        props := []struct {
+                Repr []string `datastore:"property_representation"`
+        }{}
+
+        keys, err := q.GetAll(ctx, &props)
+        if err != nil {
+                return nil, err
+        }
+        for i, p := range props {
+                propMap[keys[i].StringID()] = p.Repr
+        }
+        return propMap, nil
+}
diff --git a/vendor/google.golang.org/appengine/datastore/prop.go b/vendor/google.golang.org/appengine/datastore/prop.go
new file mode 100644
index 0000000..5cb2079
--- /dev/null
+++ b/vendor/google.golang.org/appengine/datastore/prop.go
@@ -0,0 +1,330 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package datastore
+
+import (
+        "fmt"
+        "reflect"
+        "strings"
+        "sync"
+        "unicode"
+)
+
+// Entities with more than this many indexed properties will not be saved.
+const maxIndexedProperties = 20000
+
+// []byte fields more than 1 megabyte long will not be loaded or saved.
+const maxBlobLen = 1 << 20
+
+// Property is a name/value pair plus some metadata. A datastore entity's
+// contents are loaded and saved as a sequence of Properties. An entity can
+// have multiple Properties with the same name, provided that p.Multiple is
+// true on all of that entity's Properties with that name.
+type Property struct {
+        // Name is the property name.
+        Name string
+        // Value is the property value. The valid types are:
+        //      - int64
+        //      - bool
+        //      - string
+        //      - float64
+        //      - ByteString
+        //      - *Key
+        //      - time.Time
+        //      - appengine.BlobKey
+        //      - appengine.GeoPoint
+        //      - []byte (up to 1 megabyte in length)
+        //      - *Entity (representing a nested struct)
+        // This set is smaller than the set of valid struct field types that the
+        // datastore can load and save. A Property Value cannot be a slice (apart
+        // from []byte); use multiple Properties instead. Also, a Value's type
+        // must be explicitly on the list above; it is not sufficient for the
+        // underlying type to be on that list. For example, a Value of "type
+        // myInt64 int64" is invalid. Smaller-width integers and floats are also
+        // invalid. Again, this is more restrictive than the set of valid struct
+        // field types.
+        //
+        // A Value will have an opaque type when loading entities from an index,
+        // such as via a projection query. Load entities into a struct instead
+        // of a PropertyLoadSaver when using a projection query.
+        //
+        // A Value may also be the nil interface value; this is equivalent to
+        // Python's None but not directly representable by a Go struct. Loading
+        // a nil-valued property into a struct will set that field to the zero
+        // value.
+        Value interface{}
+        // NoIndex is whether the datastore cannot index this property.
+        NoIndex bool
+        // Multiple is whether the entity can have multiple properties with
+        // the same name. Even if a particular instance only has one property with
+        // a certain name, Multiple should be true if a struct would best represent
+        // it as a field of type []T instead of type T.
+        Multiple bool
+}
+
+// An Entity is the value type for a nested struct.
+// This type is only used for a Property's Value.
+type Entity struct {
+        Key        *Key
+        Properties []Property
+}
+
+// ByteString is a short byte slice (up to 1500 bytes) that can be indexed.
+type ByteString []byte
+
+// PropertyLoadSaver can be converted from and to a slice of Properties.
+type PropertyLoadSaver interface {
+        Load([]Property) error
+        Save() ([]Property, error)
+}
+
+// PropertyList converts a []Property to implement PropertyLoadSaver.
+type PropertyList []Property
+
+var (
+        typeOfPropertyLoadSaver = reflect.TypeOf((*PropertyLoadSaver)(nil)).Elem()
+        typeOfPropertyList      = reflect.TypeOf(PropertyList(nil))
+)
+
+// Load loads all of the provided properties into l.
+// It does not first reset *l to an empty slice.
+func (l *PropertyList) Load(p []Property) error {
+        *l = append(*l, p...)
+        return nil
+}
+
+// Save saves all of l's properties as a slice or Properties.
+func (l *PropertyList) Save() ([]Property, error) {
+        return *l, nil
+}
+
+// validPropertyName returns whether name consists of one or more valid Go
+// identifiers joined by ".".
+func validPropertyName(name string) bool {
+        if name == "" {
+                return false
+        }
+        for _, s := range strings.Split(name, ".") {
+                if s == "" {
+                        return false
+                }
+                first := true
+                for _, c := range s {
+                        if first {
+                                first = false
+                                if c != '_' && !unicode.IsLetter(c) {
+                                        return false
+                                }
+                        } else {
+                                if c != '_' && !unicode.IsLetter(c) && !unicode.IsDigit(c) {
+                                        return false
+                                }
+                        }
+                }
+        }
+        return true
+}
+
+// structCodec describes how to convert a struct to and from a sequence of
+// properties.
+type structCodec struct {
+        // fields gives the field codec for the structTag with the given name.
+        fields map[string]fieldCodec
+        // hasSlice is whether a struct or any of its nested or embedded structs
+        // has a slice-typed field (other than []byte).
+        hasSlice bool
+        // keyField is the index of a *Key field with structTag __key__.
+        // This field is not relevant for the top level struct, only for
+        // nested structs.
+        keyField int
+        // complete is whether the structCodec is complete. An incomplete
+        // structCodec may be encountered when walking a recursive struct.
+        complete bool
+}
+
+// fieldCodec is a struct field's index and, if that struct field's type is
+// itself a struct, that substruct's structCodec.
+type fieldCodec struct {
+        // path is the index path to the field
+        path    []int
+        noIndex bool
+        // omitEmpty indicates that the field should be omitted on save
+        // if empty.
+        omitEmpty bool
+        // structCodec is the codec fot the struct field at index 'path',
+        // or nil if the field is not a struct.
+        structCodec *structCodec
+}
+
+// structCodecs collects the structCodecs that have already been calculated.
+var (
+        structCodecsMutex sync.Mutex
+        structCodecs      = make(map[reflect.Type]*structCodec)
+)
+
+// getStructCodec returns the structCodec for the given struct type.
+func getStructCodec(t reflect.Type) (*structCodec, error) {
+        structCodecsMutex.Lock()
+        defer structCodecsMutex.Unlock()
+        return getStructCodecLocked(t)
+}
+
+// getStructCodecLocked implements getStructCodec. The structCodecsMutex must
+// be held when calling this function.
+func getStructCodecLocked(t reflect.Type) (ret *structCodec, retErr error) {
+        c, ok := structCodecs[t]
+        if ok {
+                return c, nil
+        }
+        c = &structCodec{
+                fields: make(map[string]fieldCodec),
+                // We initialize keyField to -1 so that the zero-value is not
+                // misinterpreted as index 0.
+                keyField: -1,
+        }
+
+        // Add c to the structCodecs map before we are sure it is good. If t is
+        // a recursive type, it needs to find the incomplete entry for itself in
+        // the map.
+        structCodecs[t] = c
+        defer func() {
+                if retErr != nil {
+                        delete(structCodecs, t)
+                }
+        }()
+
+        for i := 0; i < t.NumField(); i++ {
+                f := t.Field(i)
+                // Skip unexported fields.
+                // Note that if f is an anonymous, unexported struct field,
+                // we will promote its fields.
+                if f.PkgPath != "" && !f.Anonymous {
+                        continue
+                }
+
+                tags := strings.Split(f.Tag.Get("datastore"), ",")
+                name := tags[0]
+                opts := make(map[string]bool)
+                for _, t := range tags[1:] {
+                        opts[t] = true
+                }
+                switch {
+                case name == "":
+                        if !f.Anonymous {
+                                name = f.Name
+                        }
+                case name == "-":
+                        continue
+                case name == "__key__":
+                        if f.Type != typeOfKeyPtr {
+                                return nil, fmt.Errorf("datastore: __key__ field on struct %v is not a *datastore.Key", t)
+                        }
+                        c.keyField = i
+                case !validPropertyName(name):
+                        return nil, fmt.Errorf("datastore: struct tag has invalid property name: %q", name)
+                }
+
+                substructType, fIsSlice := reflect.Type(nil), false
+                switch f.Type.Kind() {
+                case reflect.Struct:
+                        substructType = f.Type
+                case reflect.Slice:
+                        if f.Type.Elem().Kind() == reflect.Struct {
+                                substructType = f.Type.Elem()
+                        }
+                        fIsSlice = f.Type != typeOfByteSlice
+                        c.hasSlice = c.hasSlice || fIsSlice
+                }
+
+                var sub *structCodec
+                if substructType != nil && substructType != typeOfTime && substructType != typeOfGeoPoint {
+                        var err error
+                        sub, err = getStructCodecLocked(substructType)
+                        if err != nil {
+                                return nil, err
+                        }
+                        if !sub.complete {
+                                return nil, fmt.Errorf("datastore: recursive struct: field %q", f.Name)
+                        }
+                        if fIsSlice && sub.hasSlice {
+                                return nil, fmt.Errorf(
+                                        "datastore: flattening nested structs leads to a slice of slices: field %q", f.Name)
+                        }
+                        c.hasSlice = c.hasSlice || sub.hasSlice
+                        // If f is an anonymous struct field, we promote the substruct's fields up to this level
+                        // in the linked list of struct codecs.
+                        if f.Anonymous {
+                                for subname, subfield := range sub.fields {
+                                        if name != "" {
+                                                subname = name + "." + subname
+                                        }
+                                        if _, ok := c.fields[subname]; ok {
+                                                return nil, fmt.Errorf("datastore: struct tag has repeated property name: %q", subname)
+                                        }
+                                        c.fields[subname] = fieldCodec{
+                                                path:        append([]int{i}, subfield.path...),
+                                                noIndex:     subfield.noIndex || opts["noindex"],
+                                                omitEmpty:   subfield.omitEmpty,
+                                                structCodec: subfield.structCodec,
+                                        }
+                                }
+                                continue
+                        }
+                }
+
+                if _, ok := c.fields[name]; ok {
+                        return nil, fmt.Errorf("datastore: struct tag has repeated property name: %q", name)
+                }
+                c.fields[name] = fieldCodec{
+                        path:        []int{i},
+                        noIndex:     opts["noindex"],
+                        omitEmpty:   opts["omitempty"],
+                        structCodec: sub,
+                }
+        }
+        c.complete = true
+        return c, nil
+}
+
+// structPLS adapts a struct to be a PropertyLoadSaver.
+type structPLS struct {
+        v     reflect.Value
+        codec *structCodec
+}
+
+// newStructPLS returns a structPLS, which implements the
+// PropertyLoadSaver interface, for the struct pointer p.
+func newStructPLS(p interface{}) (*structPLS, error) {
+        v := reflect.ValueOf(p)
+        if v.Kind() != reflect.Ptr || v.Elem().Kind() != reflect.Struct {
+                return nil, ErrInvalidEntityType
+        }
+        v = v.Elem()
+        codec, err := getStructCodec(v.Type())
+        if err != nil {
+                return nil, err
+        }
+        return &structPLS{v, codec}, nil
+}
+
+// LoadStruct loads the properties from p to dst.
+// dst must be a struct pointer.
+func LoadStruct(dst interface{}, p []Property) error {
+        x, err := newStructPLS(dst)
+        if err != nil {
+                return err
+        }
+        return x.Load(p)
+}
+
+// SaveStruct returns the properties from src as a slice of Properties.
+// src must be a struct pointer.
+func SaveStruct(src interface{}) ([]Property, error) {
+        x, err := newStructPLS(src)
+        if err != nil {
+                return nil, err
+        }
+        return x.Save()
+}
diff --git a/vendor/google.golang.org/appengine/datastore/query.go b/vendor/google.golang.org/appengine/datastore/query.go
new file mode 100644
index 0000000..c1ea4ad
--- /dev/null
+++ b/vendor/google.golang.org/appengine/datastore/query.go
@@ -0,0 +1,757 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package datastore
+
+import (
+        "encoding/base64"
+        "errors"
+        "fmt"
+        "math"
+        "reflect"
+        "strings"
+
+        "github.com/golang/protobuf/proto"
+        "golang.org/x/net/context"
+
+        "google.golang.org/appengine/internal"
+        pb "google.golang.org/appengine/internal/datastore"
+)
+
+type operator int
+
+const (
+        lessThan operator = iota
+        lessEq
+        equal
+        greaterEq
+        greaterThan
+)
+
+var operatorToProto = map[operator]*pb.Query_Filter_Operator{
+        lessThan:    pb.Query_Filter_LESS_THAN.Enum(),
+        lessEq:      pb.Query_Filter_LESS_THAN_OR_EQUAL.Enum(),
+        equal:       pb.Query_Filter_EQUAL.Enum(),
+        greaterEq:   pb.Query_Filter_GREATER_THAN_OR_EQUAL.Enum(),
+        greaterThan: pb.Query_Filter_GREATER_THAN.Enum(),
+}
+
+// filter is a conditional filter on query results.
+type filter struct {
+        FieldName string
+        Op        operator
+        Value     interface{}
+}
+
+type sortDirection int
+
+const (
+        ascending sortDirection = iota
+        descending
+)
+
+var sortDirectionToProto = map[sortDirection]*pb.Query_Order_Direction{
+        ascending:  pb.Query_Order_ASCENDING.Enum(),
+        descending: pb.Query_Order_DESCENDING.Enum(),
+}
+
+// order is a sort order on query results.
+type order struct {
+        FieldName string
+        Direction sortDirection
+}
+
+// NewQuery creates a new Query for a specific entity kind.
+//
+// An empty kind means to return all entities, including entities created and
+// managed by other App Engine features, and is called a kindless query.
+// Kindless queries cannot include filters or sort orders on property values.
+func NewQuery(kind string) *Query {
+        return &Query{
+                kind:  kind,
+                limit: -1,
+        }
+}
+
+// Query represents a datastore query.
+type Query struct {
+        kind       string
+        ancestor   *Key
+        filter     []filter
+        order      []order
+        projection []string
+
+        distinct bool
+        keysOnly bool
+        eventual bool
+        limit    int32
+        offset   int32
+        count    int32
+        start    *pb.CompiledCursor
+        end      *pb.CompiledCursor
+
+        err error
+}
+
+func (q *Query) clone() *Query {
+        x := *q
+        // Copy the contents of the slice-typed fields to a new backing store.
+        if len(q.filter) > 0 {
+                x.filter = make([]filter, len(q.filter))
+                copy(x.filter, q.filter)
+        }
+        if len(q.order) > 0 {
+                x.order = make([]order, len(q.order))
+                copy(x.order, q.order)
+        }
+        return &x
+}
+
+// Ancestor returns a derivative query with an ancestor filter.
+// The ancestor should not be nil.
+func (q *Query) Ancestor(ancestor *Key) *Query {
+        q = q.clone()
+        if ancestor == nil {
+                q.err = errors.New("datastore: nil query ancestor")
+                return q
+        }
+        q.ancestor = ancestor
+        return q
+}
+
+// EventualConsistency returns a derivative query that returns eventually
+// consistent results.
+// It only has an effect on ancestor queries.
+func (q *Query) EventualConsistency() *Query {
+        q = q.clone()
+        q.eventual = true
+        return q
+}
+
+// Filter returns a derivative query with a field-based filter.
+// The filterStr argument must be a field name followed by optional space,
+// followed by an operator, one of ">", "<", ">=", "<=", or "=".
+// Fields are compared against the provided value using the operator.
+// Multiple filters are AND'ed together.
+func (q *Query) Filter(filterStr string, value interface{}) *Query {
+        q = q.clone()
+        filterStr = strings.TrimSpace(filterStr)
+        if len(filterStr) < 1 {
+                q.err = errors.New("datastore: invalid filter: " + filterStr)
+                return q
+        }
+        f := filter{
+                FieldName: strings.TrimRight(filterStr, " ><=!"),
+                Value:     value,
+        }
+        switch op := strings.TrimSpace(filterStr[len(f.FieldName):]); op {
+        case "<=":
+                f.Op = lessEq
+        case ">=":
+                f.Op = greaterEq
+        case "<":
+                f.Op = lessThan
+        case ">":
+                f.Op = greaterThan
+        case "=":
+                f.Op = equal
+        default:
+                q.err = fmt.Errorf("datastore: invalid operator %q in filter %q", op, filterStr)
+                return q
+        }
+        q.filter = append(q.filter, f)
+        return q
+}
+
+// Order returns a derivative query with a field-based sort order. Orders are
+// applied in the order they are added. The default order is ascending; to sort
+// in descending order prefix the fieldName with a minus sign (-).
+func (q *Query) Order(fieldName string) *Query {
+        q = q.clone()
+        fieldName = strings.TrimSpace(fieldName)
+        o := order{
+                Direction: ascending,
+                FieldName: fieldName,
+        }
+        if strings.HasPrefix(fieldName, "-") {
+                o.Direction = descending
+                o.FieldName = strings.TrimSpace(fieldName[1:])
+        } else if strings.HasPrefix(fieldName, "+") {
+                q.err = fmt.Errorf("datastore: invalid order: %q", fieldName)
+                return q
+        }
+        if len(o.FieldName) == 0 {
+                q.err = errors.New("datastore: empty order")
+                return q
+        }
+        q.order = append(q.order, o)
+        return q
+}
+
+// Project returns a derivative query that yields only the given fields. It
+// cannot be used with KeysOnly.
+func (q *Query) Project(fieldNames ...string) *Query {
+        q = q.clone()
+        q.projection = append([]string(nil), fieldNames...)
+        return q
+}
+
+// Distinct returns a derivative query that yields de-duplicated entities with
+// respect to the set of projected fields. It is only used for projection
+// queries.
+func (q *Query) Distinct() *Query {
+        q = q.clone()
+        q.distinct = true
+        return q
+}
+
+// KeysOnly returns a derivative query that yields only keys, not keys and
+// entities. It cannot be used with projection queries.
+func (q *Query) KeysOnly() *Query {
+        q = q.clone()
+        q.keysOnly = true
+        return q
+}
+
+// Limit returns a derivative query that has a limit on the number of results
+// returned. A negative value means unlimited.
+func (q *Query) Limit(limit int) *Query {
+        q = q.clone()
+        if limit < math.MinInt32 || limit > math.MaxInt32 {
+                q.err = errors.New("datastore: query limit overflow")
+                return q
+        }
+        q.limit = int32(limit)
+        return q
+}
+
+// Offset returns a derivative query that has an offset of how many keys to
+// skip over before returning results. A negative value is invalid.
+func (q *Query) Offset(offset int) *Query {
+        q = q.clone()
+        if offset < 0 {
+                q.err = errors.New("datastore: negative query offset")
+                return q
+        }
+        if offset > math.MaxInt32 {
+                q.err = errors.New("datastore: query offset overflow")
+                return q
+        }
+        q.offset = int32(offset)
+        return q
+}
+
+// BatchSize returns a derivative query to fetch the supplied number of results
+// at once. This value should be greater than zero, and equal to or less than
+// the Limit.
+func (q *Query) BatchSize(size int) *Query {
+        q = q.clone()
+        if size <= 0 || size > math.MaxInt32 {
+                q.err = errors.New("datastore: query batch size overflow")
+                return q
+        }
+        q.count = int32(size)
+        return q
+}
+
+// Start returns a derivative query with the given start point.
+func (q *Query) Start(c Cursor) *Query {
+        q = q.clone()
+        if c.cc == nil {
+                q.err = errors.New("datastore: invalid cursor")
+                return q
+        }
+        q.start = c.cc
+        return q
+}
+
+// End returns a derivative query with the given end point.
+func (q *Query) End(c Cursor) *Query {
+        q = q.clone()
+        if c.cc == nil {
+                q.err = errors.New("datastore: invalid cursor")
+                return q
+        }
+        q.end = c.cc
+        return q
+}
+
+// toProto converts the query to a protocol buffer.
+func (q *Query) toProto(dst *pb.Query, appID string) error {
+        if len(q.projection) != 0 && q.keysOnly {
+                return errors.New("datastore: query cannot both project and be keys-only")
+        }
+        dst.Reset()
+        dst.App = proto.String(appID)
+        if q.kind != "" {
+                dst.Kind = proto.String(q.kind)
+        }
+        if q.ancestor != nil {
+                dst.Ancestor = keyToProto(appID, q.ancestor)
+                if q.eventual {
+                        dst.Strong = proto.Bool(false)
+                }
+        }
+        if q.projection != nil {
+                dst.PropertyName = q.projection
+                if q.distinct {
+                        dst.GroupByPropertyName = q.projection
+                }
+        }
+        if q.keysOnly {
+                dst.KeysOnly = proto.Bool(true)
+                dst.RequirePerfectPlan = proto.Bool(true)
+        }
+        for _, qf := range q.filter {
+                if qf.FieldName == "" {
+                        return errors.New("datastore: empty query filter field name")
+                }
+                p, errStr := valueToProto(appID, qf.FieldName, reflect.ValueOf(qf.Value), false)
+                if errStr != "" {
+                        return errors.New("datastore: bad query filter value type: " + errStr)
+                }
+                xf := &pb.Query_Filter{
+                        Op:       operatorToProto[qf.Op],
+                        Property: []*pb.Property{p},
+                }
+                if xf.Op == nil {
+                        return errors.New("datastore: unknown query filter operator")
+                }
+                dst.Filter = append(dst.Filter, xf)
+        }
+        for _, qo := range q.order {
+                if qo.FieldName == "" {
+                        return errors.New("datastore: empty query order field name")
+                }
+                xo := &pb.Query_Order{
+                        Property:  proto.String(qo.FieldName),
+                        Direction: sortDirectionToProto[qo.Direction],
+                }
+                if xo.Direction == nil {
+                        return errors.New("datastore: unknown query order direction")
+                }
+                dst.Order = append(dst.Order, xo)
+        }
+        if q.limit >= 0 {
+                dst.Limit = proto.Int32(q.limit)
+        }
+        if q.offset != 0 {
+                dst.Offset = proto.Int32(q.offset)
+        }
+        if q.count != 0 {
+                dst.Count = proto.Int32(q.count)
+        }
+        dst.CompiledCursor = q.start
+        dst.EndCompiledCursor = q.end
+        dst.Compile = proto.Bool(true)
+        return nil
+}
+
+// Count returns the number of results for the query.
+//
+// The running time and number of API calls made by Count scale linearly with
+// the sum of the query's offset and limit. Unless the result count is
+// expected to be small, it is best to specify a limit; otherwise Count will
+// continue until it finishes counting or the provided context expires.
+func (q *Query) Count(c context.Context) (int, error) {
+        // Check that the query is well-formed.
+        if q.err != nil {
+                return 0, q.err
+        }
+
+        // Run a copy of the query, with keysOnly true (if we're not a projection,
+        // since the two are incompatible), and an adjusted offset. We also set the
+        // limit to zero, as we don't want any actual entity data, just the number
+        // of skipped results.
+        newQ := q.clone()
+        newQ.keysOnly = len(newQ.projection) == 0
+        newQ.limit = 0
+        if q.limit < 0 {
+                // If the original query was unlimited, set the new query's offset to maximum.
+                newQ.offset = math.MaxInt32
+        } else {
+                newQ.offset = q.offset + q.limit
+                if newQ.offset < 0 {
+                        // Do the best we can, in the presence of overflow.
+                        newQ.offset = math.MaxInt32
+                }
+        }
+        req := &pb.Query{}
+        if err := newQ.toProto(req, internal.FullyQualifiedAppID(c)); err != nil {
+                return 0, err
+        }
+        res := &pb.QueryResult{}
+        if err := internal.Call(c, "datastore_v3", "RunQuery", req, res); err != nil {
+                return 0, err
+        }
+
+        // n is the count we will return. For example, suppose that our original
+        // query had an offset of 4 and a limit of 2008: the count will be 2008,
+        // provided that there are at least 2012 matching entities. However, the
+        // RPCs will only skip 1000 results at a time. The RPC sequence is:
+        //   call RunQuery with (offset, limit) = (2012, 0)  // 2012 == newQ.offset
+        //   response has (skippedResults, moreResults) = (1000, true)
+        //   n += 1000  // n == 1000
+        //   call Next     with (offset, limit) = (1012, 0)  // 1012 == newQ.offset - n
+        //   response has (skippedResults, moreResults) = (1000, true)
+        //   n += 1000  // n == 2000
+        //   call Next     with (offset, limit) = (12, 0)    // 12 == newQ.offset - n
+        //   response has (skippedResults, moreResults) = (12, false)
+        //   n += 12    // n == 2012
+        //   // exit the loop
+        //   n -= 4     // n == 2008
+        var n int32
+        for {
+                // The QueryResult should have no actual entity data, just skipped results.
+                if len(res.Result) != 0 {
+                        return 0, errors.New("datastore: internal error: Count request returned too much data")
+                }
+                n += res.GetSkippedResults()
+                if !res.GetMoreResults() {
+                        break
+                }
+                if err := callNext(c, res, newQ.offset-n, q.count); err != nil {
+                        return 0, err
+                }
+        }
+        n -= q.offset
+        if n < 0 {
+                // If the offset was greater than the number of matching entities,
+                // return 0 instead of negative.
+                n = 0
+        }
+        return int(n), nil
+}
+
+// callNext issues a datastore_v3/Next RPC to advance a cursor, such as that
+// returned by a query with more results.
+func callNext(c context.Context, res *pb.QueryResult, offset, count int32) error {
+        if res.Cursor == nil {
+                return errors.New("datastore: internal error: server did not return a cursor")
+        }
+        req := &pb.NextRequest{
+                Cursor: res.Cursor,
+        }
+        if count >= 0 {
+                req.Count = proto.Int32(count)
+        }
+        if offset != 0 {
+                req.Offset = proto.Int32(offset)
+        }
+        if res.CompiledCursor != nil {
+                req.Compile = proto.Bool(true)
+        }
+        res.Reset()
+        return internal.Call(c, "datastore_v3", "Next", req, res)
+}
+
+// GetAll runs the query in the given context and returns all keys that match
+// that query, as well as appending the values to dst.
+//
+// dst must have type *[]S or *[]*S or *[]P, for some struct type S or some non-
+// interface, non-pointer type P such that P or *P implements PropertyLoadSaver.
+//
+// As a special case, *PropertyList is an invalid type for dst, even though a
+// PropertyList is a slice of structs. It is treated as invalid to avoid being
+// mistakenly passed when *[]PropertyList was intended.
+//
+// The keys returned by GetAll will be in a 1-1 correspondence with the entities
+// added to dst.
+//
+// If q is a ``keys-only'' query, GetAll ignores dst and only returns the keys.
+//
+// The running time and number of API calls made by GetAll scale linearly with
+// the sum of the query's offset and limit. Unless the result count is
+// expected to be small, it is best to specify a limit; otherwise GetAll will
+// continue until it finishes collecting results or the provided context
+// expires.
+func (q *Query) GetAll(c context.Context, dst interface{}) ([]*Key, error) {
+        var (
+                dv               reflect.Value
+                mat              multiArgType
+                elemType         reflect.Type
+                errFieldMismatch error
+        )
+        if !q.keysOnly {
+                dv = reflect.ValueOf(dst)
+                if dv.Kind() != reflect.Ptr || dv.IsNil() {
+                        return nil, ErrInvalidEntityType
+                }
+                dv = dv.Elem()
+                mat, elemType = checkMultiArg(dv)
+                if mat == multiArgTypeInvalid || mat == multiArgTypeInterface {
+                        return nil, ErrInvalidEntityType
+                }
+        }
+
+        var keys []*Key
+        for t := q.Run(c); ; {
+                k, e, err := t.next()
+                if err == Done {
+                        break
+                }
+                if err != nil {
+                        return keys, err
+                }
+                if !q.keysOnly {
+                        ev := reflect.New(elemType)
+                        if elemType.Kind() == reflect.Map {
+                                // This is a special case. The zero values of a map type are
+                                // not immediately useful; they have to be make'd.
+                                //
+                                // Funcs and channels are similar, in that a zero value is not useful,
+                                // but even a freshly make'd channel isn't useful: there's no fixed
+                                // channel buffer size that is always going to be large enough, and
+                                // there's no goroutine to drain the other end. Theoretically, these
+                                // types could be supported, for example by sniffing for a constructor
+                                // method or requiring prior registration, but for now it's not a
+                                // frequent enough concern to be worth it. Programmers can work around
+                                // it by explicitly using Iterator.Next instead of the Query.GetAll
+                                // convenience method.
+                                x := reflect.MakeMap(elemType)
+                                ev.Elem().Set(x)
+                        }
+                        if err = loadEntity(ev.Interface(), e); err != nil {
+                                if _, ok := err.(*ErrFieldMismatch); ok {
+                                        // We continue loading entities even in the face of field mismatch errors.
+                                        // If we encounter any other error, that other error is returned. Otherwise,
+                                        // an ErrFieldMismatch is returned.
+                                        errFieldMismatch = err
+                                } else {
+                                        return keys, err
+                                }
+                        }
+                        if mat != multiArgTypeStructPtr {
+                                ev = ev.Elem()
+                        }
+                        dv.Set(reflect.Append(dv, ev))
+                }
+                keys = append(keys, k)
+        }
+        return keys, errFieldMismatch
+}
+
+// Run runs the query in the given context.
+func (q *Query) Run(c context.Context) *Iterator {
+        if q.err != nil {
+                return &Iterator{err: q.err}
+        }
+        t := &Iterator{
+                c:      c,
+                limit:  q.limit,
+                count:  q.count,
+                q:      q,
+                prevCC: q.start,
+        }
+        var req pb.Query
+        if err := q.toProto(&req, internal.FullyQualifiedAppID(c)); err != nil {
+                t.err = err
+                return t
+        }
+        if err := internal.Call(c, "datastore_v3", "RunQuery", &req, &t.res); err != nil {
+                t.err = err
+                return t
+        }
+        offset := q.offset - t.res.GetSkippedResults()
+        var count int32
+        if t.count > 0 && (t.limit < 0 || t.count < t.limit) {
+                count = t.count
+        } else {
+                count = t.limit
+        }
+        for offset > 0 && t.res.GetMoreResults() {
+                t.prevCC = t.res.CompiledCursor
+                if err := callNext(t.c, &t.res, offset, count); err != nil {
+                        t.err = err
+                        break
+                }
+                skip := t.res.GetSkippedResults()
+                if skip < 0 {
+                        t.err = errors.New("datastore: internal error: negative number of skipped_results")
+                        break
+                }
+                offset -= skip
+        }
+        if offset < 0 {
+                t.err = errors.New("datastore: internal error: query offset was overshot")
+        }
+        return t
+}
+
+// Iterator is the result of running a query.
+type Iterator struct {
+        c   context.Context
+        err error
+        // res is the result of the most recent RunQuery or Next API call.
+        res pb.QueryResult
+        // i is how many elements of res.Result we have iterated over.
+        i int
+        // limit is the limit on the number of results this iterator should return.
+        // A negative value means unlimited.
+        limit int32
+        // count is the number of results this iterator should fetch at once. This
+        // should be equal to or greater than zero.
+        count int32
+        // q is the original query which yielded this iterator.
+        q *Query
+        // prevCC is the compiled cursor that marks the end of the previous batch
+        // of results.
+        prevCC *pb.CompiledCursor
+}
+
+// Done is returned when a query iteration has completed.
+var Done = errors.New("datastore: query has no more results")
+
+// Next returns the key of the next result. When there are no more results,
+// Done is returned as the error.
+//
+// If the query is not keys only and dst is non-nil, it also loads the entity
+// stored for that key into the struct pointer or PropertyLoadSaver dst, with
+// the same semantics and possible errors as for the Get function.
+func (t *Iterator) Next(dst interface{}) (*Key, error) {
+        k, e, err := t.next()
+        if err != nil {
+                return nil, err
+        }
+        if dst != nil && !t.q.keysOnly {
+                err = loadEntity(dst, e)
+        }
+        return k, err
+}
+
+func (t *Iterator) next() (*Key, *pb.EntityProto, error) {
+        if t.err != nil {
+                return nil, nil, t.err
+        }
+
+        // Issue datastore_v3/Next RPCs as necessary.
+        for t.i == len(t.res.Result) {
+                if !t.res.GetMoreResults() {
+                        t.err = Done
+                        return nil, nil, t.err
+                }
+                t.prevCC = t.res.CompiledCursor
+                var count int32
+                if t.count > 0 && (t.limit < 0 || t.count < t.limit) {
+                        count = t.count
+                } else {
+                        count = t.limit
+                }
+                if err := callNext(t.c, &t.res, 0, count); err != nil {
+                        t.err = err
+                        return nil, nil, t.err
+                }
+                if t.res.GetSkippedResults() != 0 {
+                        t.err = errors.New("datastore: internal error: iterator has skipped results")
+                        return nil, nil, t.err
+                }
+                t.i = 0
+                if t.limit >= 0 {
+                        t.limit -= int32(len(t.res.Result))
+                        if t.limit < 0 {
+                                t.err = errors.New("datastore: internal error: query returned more results than the limit")
+                                return nil, nil, t.err
+                        }
+                }
+        }
+
+        // Extract the key from the t.i'th element of t.res.Result.
+        e := t.res.Result[t.i]
+        t.i++
+        if e.Key == nil {
+                return nil, nil, errors.New("datastore: internal error: server did not return a key")
+        }
+        k, err := protoToKey(e.Key)
+        if err != nil || k.Incomplete() {
+                return nil, nil, errors.New("datastore: internal error: server returned an invalid key")
+        }
+        return k, e, nil
+}
+
+// Cursor returns a cursor for the iterator's current location.
+func (t *Iterator) Cursor() (Cursor, error) {
+        if t.err != nil && t.err != Done {
+                return Cursor{}, t.err
+        }
+        // If we are at either end of the current batch of results,
+        // return the compiled cursor at that end.
+        skipped := t.res.GetSkippedResults()
+        if t.i == 0 && skipped == 0 {
+                if t.prevCC == nil {
+                        // A nil pointer (of type *pb.CompiledCursor) means no constraint:
+                        // passing it as the end cursor of a new query means unlimited results
+                        // (glossing over the integer limit parameter for now).
+                        // A non-nil pointer to an empty pb.CompiledCursor means the start:
+                        // passing it as the end cursor of a new query means 0 results.
+                        // If prevCC was nil, then the original query had no start cursor, but
+                        // Iterator.Cursor should return "the start" instead of unlimited.
+                        return Cursor{&zeroCC}, nil
+                }
+                return Cursor{t.prevCC}, nil
+        }
+        if t.i == len(t.res.Result) {
+                return Cursor{t.res.CompiledCursor}, nil
+        }
+        // Otherwise, re-run the query offset to this iterator's position, starting from
+        // the most recent compiled cursor. This is done on a best-effort basis, as it
+        // is racy; if a concurrent process has added or removed entities, then the
+        // cursor returned may be inconsistent.
+        q := t.q.clone()
+        q.start = t.prevCC
+        q.offset = skipped + int32(t.i)
+        q.limit = 0
+        q.keysOnly = len(q.projection) == 0
+        t1 := q.Run(t.c)
+        _, _, err := t1.next()
+        if err != Done {
+                if err == nil {
+                        err = fmt.Errorf("datastore: internal error: zero-limit query did not have zero results")
+                }
+                return Cursor{}, err
+        }
+        return Cursor{t1.res.CompiledCursor}, nil
+}
+
+var zeroCC pb.CompiledCursor
+
+// Cursor is an iterator's position. It can be converted to and from an opaque
+// string. A cursor can be used from different HTTP requests, but only with a
+// query with the same kind, ancestor, filter and order constraints.
+type Cursor struct {
+        cc *pb.CompiledCursor
+}
+
+// String returns a base-64 string representation of a cursor.
+func (c Cursor) String() string {
+        if c.cc == nil {
+                return ""
+        }
+        b, err := proto.Marshal(c.cc)
+        if err != nil {
+                // The only way to construct a Cursor with a non-nil cc field is to
+                // unmarshal from the byte representation. We panic if the unmarshal
+                // succeeds but the marshaling of the unchanged protobuf value fails.
+                panic(fmt.Sprintf("datastore: internal error: malformed cursor: %v", err))
+        }
+        return strings.TrimRight(base64.URLEncoding.EncodeToString(b), "=")
+}
+
+// Decode decodes a cursor from its base-64 string representation.
+func DecodeCursor(s string) (Cursor, error) {
+        if s == "" {
+                return Cursor{&zeroCC}, nil
+        }
+        if n := len(s) % 4; n != 0 {
+                s += strings.Repeat("=", 4-n)
+        }
+        b, err := base64.URLEncoding.DecodeString(s)
+        if err != nil {
+                return Cursor{}, err
+        }
+        cc := &pb.CompiledCursor{}
+        if err := proto.Unmarshal(b, cc); err != nil {
+                return Cursor{}, err
+        }
+        return Cursor{cc}, nil
+}
diff --git a/vendor/google.golang.org/appengine/datastore/save.go b/vendor/google.golang.org/appengine/datastore/save.go
new file mode 100644
index 0000000..7b045a5
--- /dev/null
+++ b/vendor/google.golang.org/appengine/datastore/save.go
@@ -0,0 +1,333 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package datastore
+
+import (
+        "errors"
+        "fmt"
+        "math"
+        "reflect"
+        "time"
+
+        "github.com/golang/protobuf/proto"
+
+        "google.golang.org/appengine"
+        pb "google.golang.org/appengine/internal/datastore"
+)
+
+func toUnixMicro(t time.Time) int64 {
+        // We cannot use t.UnixNano() / 1e3 because we want to handle times more than
+        // 2^63 nanoseconds (which is about 292 years) away from 1970, and those cannot
+        // be represented in the numerator of a single int64 divide.
+        return t.Unix()*1e6 + int64(t.Nanosecond()/1e3)
+}
+
+func fromUnixMicro(t int64) time.Time {
+        return time.Unix(t/1e6, (t%1e6)*1e3).UTC()
+}
+
+var (
+        minTime = time.Unix(int64(math.MinInt64)/1e6, (int64(math.MinInt64)%1e6)*1e3)
+        maxTime = time.Unix(int64(math.MaxInt64)/1e6, (int64(math.MaxInt64)%1e6)*1e3)
+)
+
+// valueToProto converts a named value to a newly allocated Property.
+// The returned error string is empty on success.
+func valueToProto(defaultAppID, name string, v reflect.Value, multiple bool) (p *pb.Property, errStr string) {
+        var (
+                pv          pb.PropertyValue
+                unsupported bool
+        )
+        switch v.Kind() {
+        case reflect.Invalid:
+                // No-op.
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                pv.Int64Value = proto.Int64(v.Int())
+        case reflect.Bool:
+                pv.BooleanValue = proto.Bool(v.Bool())
+        case reflect.String:
+                pv.StringValue = proto.String(v.String())
+        case reflect.Float32, reflect.Float64:
+                pv.DoubleValue = proto.Float64(v.Float())
+        case reflect.Ptr:
+                if k, ok := v.Interface().(*Key); ok {
+                        if k != nil {
+                                pv.Referencevalue = keyToReferenceValue(defaultAppID, k)
+                        }
+                } else {
+                        unsupported = true
+                }
+        case reflect.Struct:
+                switch t := v.Interface().(type) {
+                case time.Time:
+                        if t.Before(minTime) || t.After(maxTime) {
+                                return nil, "time value out of range"
+                        }
+                        pv.Int64Value = proto.Int64(toUnixMicro(t))
+                case appengine.GeoPoint:
+                        if !t.Valid() {
+                                return nil, "invalid GeoPoint value"
+                        }
+                        // NOTE: Strangely, latitude maps to X, longitude to Y.
+                        pv.Pointvalue = &pb.PropertyValue_PointValue{X: &t.Lat, Y: &t.Lng}
+                default:
+                        unsupported = true
+                }
+        case reflect.Slice:
+                if b, ok := v.Interface().([]byte); ok {
+                        pv.StringValue = proto.String(string(b))
+                } else {
+                        // nvToProto should already catch slice values.
+                        // If we get here, we have a slice of slice values.
+                        unsupported = true
+                }
+        default:
+                unsupported = true
+        }
+        if unsupported {
+                return nil, "unsupported datastore value type: " + v.Type().String()
+        }
+        p = &pb.Property{
+                Name:     proto.String(name),
+                Value:    &pv,
+                Multiple: proto.Bool(multiple),
+        }
+        if v.IsValid() {
+                switch v.Interface().(type) {
+                case []byte:
+                        p.Meaning = pb.Property_BLOB.Enum()
+                case ByteString:
+                        p.Meaning = pb.Property_BYTESTRING.Enum()
+                case appengine.BlobKey:
+                        p.Meaning = pb.Property_BLOBKEY.Enum()
+                case time.Time:
+                        p.Meaning = pb.Property_GD_WHEN.Enum()
+                case appengine.GeoPoint:
+                        p.Meaning = pb.Property_GEORSS_POINT.Enum()
+                }
+        }
+        return p, ""
+}
+
+type saveOpts struct {
+        noIndex   bool
+        multiple  bool
+        omitEmpty bool
+}
+
+// saveEntity saves an EntityProto into a PropertyLoadSaver or struct pointer.
+func saveEntity(defaultAppID string, key *Key, src interface{}) (*pb.EntityProto, error) {
+        var err error
+        var props []Property
+        if e, ok := src.(PropertyLoadSaver); ok {
+                props, err = e.Save()
+        } else {
+                props, err = SaveStruct(src)
+        }
+        if err != nil {
+                return nil, err
+        }
+        return propertiesToProto(defaultAppID, key, props)
+}
+
+func saveStructProperty(props *[]Property, name string, opts saveOpts, v reflect.Value) error {
+        if opts.omitEmpty && isEmptyValue(v) {
+                return nil
+        }
+        p := Property{
+                Name:     name,
+                NoIndex:  opts.noIndex,
+                Multiple: opts.multiple,
+        }
+        switch x := v.Interface().(type) {
+        case *Key:
+                p.Value = x
+        case time.Time:
+                p.Value = x
+        case appengine.BlobKey:
+                p.Value = x
+        case appengine.GeoPoint:
+                p.Value = x
+        case ByteString:
+                p.Value = x
+        default:
+                switch v.Kind() {
+                case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                        p.Value = v.Int()
+                case reflect.Bool:
+                        p.Value = v.Bool()
+                case reflect.String:
+                        p.Value = v.String()
+                case reflect.Float32, reflect.Float64:
+                        p.Value = v.Float()
+                case reflect.Slice:
+                        if v.Type().Elem().Kind() == reflect.Uint8 {
+                                p.NoIndex = true
+                                p.Value = v.Bytes()
+                        }
+                case reflect.Struct:
+                        if !v.CanAddr() {
+                                return fmt.Errorf("datastore: unsupported struct field: value is unaddressable")
+                        }
+                        sub, err := newStructPLS(v.Addr().Interface())
+                        if err != nil {
+                                return fmt.Errorf("datastore: unsupported struct field: %v", err)
+                        }
+                        return sub.save(props, name+".", opts)
+                }
+        }
+        if p.Value == nil {
+                return fmt.Errorf("datastore: unsupported struct field type: %v", v.Type())
+        }
+        *props = append(*props, p)
+        return nil
+}
+
+func (s structPLS) Save() ([]Property, error) {
+        var props []Property
+        if err := s.save(&props, "", saveOpts{}); err != nil {
+                return nil, err
+        }
+        return props, nil
+}
+
+func (s structPLS) save(props *[]Property, prefix string, opts saveOpts) error {
+        for name, f := range s.codec.fields {
+                name = prefix + name
+                v := s.v.FieldByIndex(f.path)
+                if !v.IsValid() || !v.CanSet() {
+                        continue
+                }
+                var opts1 saveOpts
+                opts1.noIndex = opts.noIndex || f.noIndex
+                opts1.multiple = opts.multiple
+                opts1.omitEmpty = f.omitEmpty // don't propagate
+                // For slice fields that aren't []byte, save each element.
+                if v.Kind() == reflect.Slice && v.Type().Elem().Kind() != reflect.Uint8 {
+                        opts1.multiple = true
+                        for j := 0; j < v.Len(); j++ {
+                                if err := saveStructProperty(props, name, opts1, v.Index(j)); err != nil {
+                                        return err
+                                }
+                        }
+                        continue
+                }
+                // Otherwise, save the field itself.
+                if err := saveStructProperty(props, name, opts1, v); err != nil {
+                        return err
+                }
+        }
+        return nil
+}
+
+func propertiesToProto(defaultAppID string, key *Key, props []Property) (*pb.EntityProto, error) {
+        e := &pb.EntityProto{
+                Key: keyToProto(defaultAppID, key),
+        }
+        if key.parent == nil {
+                e.EntityGroup = &pb.Path{}
+        } else {
+                e.EntityGroup = keyToProto(defaultAppID, key.root()).Path
+        }
+        prevMultiple := make(map[string]bool)
+
+        for _, p := range props {
+                if pm, ok := prevMultiple[p.Name]; ok {
+                        if !pm || !p.Multiple {
+                                return nil, fmt.Errorf("datastore: multiple Properties with Name %q, but Multiple is false", p.Name)
+                        }
+                } else {
+                        prevMultiple[p.Name] = p.Multiple
+                }
+
+                x := &pb.Property{
+                        Name:     proto.String(p.Name),
+                        Value:    new(pb.PropertyValue),
+                        Multiple: proto.Bool(p.Multiple),
+                }
+                switch v := p.Value.(type) {
+                case int64:
+                        x.Value.Int64Value = proto.Int64(v)
+                case bool:
+                        x.Value.BooleanValue = proto.Bool(v)
+                case string:
+                        x.Value.StringValue = proto.String(v)
+                        if p.NoIndex {
+                                x.Meaning = pb.Property_TEXT.Enum()
+                        }
+                case float64:
+                        x.Value.DoubleValue = proto.Float64(v)
+                case *Key:
+                        if v != nil {
+                                x.Value.Referencevalue = keyToReferenceValue(defaultAppID, v)
+                        }
+                case time.Time:
+                        if v.Before(minTime) || v.After(maxTime) {
+                                return nil, fmt.Errorf("datastore: time value out of range")
+                        }
+                        x.Value.Int64Value = proto.Int64(toUnixMicro(v))
+                        x.Meaning = pb.Property_GD_WHEN.Enum()
+                case appengine.BlobKey:
+                        x.Value.StringValue = proto.String(string(v))
+                        x.Meaning = pb.Property_BLOBKEY.Enum()
+                case appengine.GeoPoint:
+                        if !v.Valid() {
+                                return nil, fmt.Errorf("datastore: invalid GeoPoint value")
+                        }
+                        // NOTE: Strangely, latitude maps to X, longitude to Y.
+                        x.Value.Pointvalue = &pb.PropertyValue_PointValue{X: &v.Lat, Y: &v.Lng}
+                        x.Meaning = pb.Property_GEORSS_POINT.Enum()
+                case []byte:
+                        x.Value.StringValue = proto.String(string(v))
+                        x.Meaning = pb.Property_BLOB.Enum()
+                        if !p.NoIndex {
+                                return nil, fmt.Errorf("datastore: cannot index a []byte valued Property with Name %q", p.Name)
+                        }
+                case ByteString:
+                        x.Value.StringValue = proto.String(string(v))
+                        x.Meaning = pb.Property_BYTESTRING.Enum()
+                default:
+                        if p.Value != nil {
+                                return nil, fmt.Errorf("datastore: invalid Value type for a Property with Name %q", p.Name)
+                        }
+                }
+
+                if p.NoIndex {
+                        e.RawProperty = append(e.RawProperty, x)
+                } else {
+                        e.Property = append(e.Property, x)
+                        if len(e.Property) > maxIndexedProperties {
+                                return nil, errors.New("datastore: too many indexed properties")
+                        }
+                }
+        }
+        return e, nil
+}
+
+// isEmptyValue is taken from the encoding/json package in the standard library.
+func isEmptyValue(v reflect.Value) bool {
+        switch v.Kind() {
+        case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
+                // TODO(perfomance): Only reflect.String needed, other property types are not supported (copy/paste from json package)
+                return v.Len() == 0
+        case reflect.Bool:
+                return !v.Bool()
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                return v.Int() == 0
+        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+                // TODO(perfomance): Uint* are unsupported property types - should be removed (copy/paste from json package)
+                return v.Uint() == 0
+        case reflect.Float32, reflect.Float64:
+                return v.Float() == 0
+        case reflect.Interface, reflect.Ptr:
+                return v.IsNil()
+        case reflect.Struct:
+                switch x := v.Interface().(type) {
+                case time.Time:
+                        return x.IsZero()
+                }
+        }
+        return false
+}
diff --git a/vendor/google.golang.org/appengine/datastore/transaction.go b/vendor/google.golang.org/appengine/datastore/transaction.go
new file mode 100644
index 0000000..2ae8428
--- /dev/null
+++ b/vendor/google.golang.org/appengine/datastore/transaction.go
@@ -0,0 +1,96 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package datastore
+
+import (
+        "errors"
+
+        "golang.org/x/net/context"
+
+        "google.golang.org/appengine/internal"
+        pb "google.golang.org/appengine/internal/datastore"
+)
+
+func init() {
+        internal.RegisterTransactionSetter(func(x *pb.Query, t *pb.Transaction) {
+                x.Transaction = t
+        })
+        internal.RegisterTransactionSetter(func(x *pb.GetRequest, t *pb.Transaction) {
+                x.Transaction = t
+        })
+        internal.RegisterTransactionSetter(func(x *pb.PutRequest, t *pb.Transaction) {
+                x.Transaction = t
+        })
+        internal.RegisterTransactionSetter(func(x *pb.DeleteRequest, t *pb.Transaction) {
+                x.Transaction = t
+        })
+}
+
+// ErrConcurrentTransaction is returned when a transaction is rolled back due
+// to a conflict with a concurrent transaction.
+var ErrConcurrentTransaction = errors.New("datastore: concurrent transaction")
+
+// RunInTransaction runs f in a transaction. It calls f with a transaction
+// context tc that f should use for all App Engine operations.
+//
+// If f returns nil, RunInTransaction attempts to commit the transaction,
+// returning nil if it succeeds. If the commit fails due to a conflicting
+// transaction, RunInTransaction retries f, each time with a new transaction
+// context. It gives up and returns ErrConcurrentTransaction after three
+// failed attempts. The number of attempts can be configured by specifying
+// TransactionOptions.Attempts.
+//
+// If f returns non-nil, then any datastore changes will not be applied and
+// RunInTransaction returns that same error. The function f is not retried.
+//
+// Note that when f returns, the transaction is not yet committed. Calling code
+// must be careful not to assume that any of f's changes have been committed
+// until RunInTransaction returns nil.
+//
+// Since f may be called multiple times, f should usually be idempotent.
+// datastore.Get is not idempotent when unmarshaling slice fields.
+//
+// Nested transactions are not supported; c may not be a transaction context.
+func RunInTransaction(c context.Context, f func(tc context.Context) error, opts *TransactionOptions) error {
+        xg := false
+        if opts != nil {
+                xg = opts.XG
+        }
+        readOnly := false
+        if opts != nil {
+                readOnly = opts.ReadOnly
+        }
+        attempts := 3
+        if opts != nil && opts.Attempts > 0 {
+                attempts = opts.Attempts
+        }
+        var t *pb.Transaction
+        var err error
+        for i := 0; i < attempts; i++ {
+                if t, err = internal.RunTransactionOnce(c, f, xg, readOnly, t); err != internal.ErrConcurrentTransaction {
+                        return err
+                }
+        }
+        return ErrConcurrentTransaction
+}
+
+// TransactionOptions are the options for running a transaction.
+type TransactionOptions struct {
+        // XG is whether the transaction can cross multiple entity groups. In
+        // comparison, a single group transaction is one where all datastore keys
+        // used have the same root key. Note that cross group transactions do not
+        // have the same behavior as single group transactions. In particular, it
+        // is much more likely to see partially applied transactions in different
+        // entity groups, in global queries.
+        // It is valid to set XG to true even if the transaction is within a
+        // single entity group.
+        XG bool
+        // Attempts controls the number of retries to perform when commits fail
+        // due to a conflicting transaction. If omitted, it defaults to 3.
+        Attempts int
+        // ReadOnly controls whether the transaction is a read only transaction.
+        // Read only transactions are potentially more efficient.
+        ReadOnly bool
+}
diff --git a/vendor/google.golang.org/appengine/errors.go b/vendor/google.golang.org/appengine/errors.go
new file mode 100644
index 0000000..16d0772
--- /dev/null
+++ b/vendor/google.golang.org/appengine/errors.go
@@ -0,0 +1,46 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// This file provides error functions for common API failure modes.
+
+package appengine
+
+import (
+        "fmt"
+
+        "google.golang.org/appengine/internal"
+)
+
+// IsOverQuota reports whether err represents an API call failure
+// due to insufficient available quota.
+func IsOverQuota(err error) bool {
+        callErr, ok := err.(*internal.CallError)
+        return ok && callErr.Code == 4
+}
+
+// MultiError is returned by batch operations when there are errors with
+// particular elements. Errors will be in a one-to-one correspondence with
+// the input elements; successful elements will have a nil entry.
+type MultiError []error
+
+func (m MultiError) Error() string {
+        s, n := "", 0
+        for _, e := range m {
+                if e != nil {
+                        if n == 0 {
+                                s = e.Error()
+                        }
+                        n++
+                }
+        }
+        switch n {
+        case 0:
+                return "(0 errors)"
+        case 1:
+                return s
+        case 2:
+                return s + " (and 1 other error)"
+        }
+        return fmt.Sprintf("%s (and %d other errors)", s, n-1)
+}
diff --git a/vendor/google.golang.org/appengine/go.mod b/vendor/google.golang.org/appengine/go.mod
new file mode 100644
index 0000000..f449359
--- /dev/null
+++ b/vendor/google.golang.org/appengine/go.mod
@@ -0,0 +1,7 @@
+module google.golang.org/appengine
+
+require (
+        github.com/golang/protobuf v1.2.0
+        golang.org/x/net v0.0.0-20180724234803-3673e40ba225
+        golang.org/x/text v0.3.0
+)
diff --git a/vendor/google.golang.org/appengine/go.sum b/vendor/google.golang.org/appengine/go.sum
new file mode 100644
index 0000000..1a221c0
--- /dev/null
+++ b/vendor/google.golang.org/appengine/go.sum
@@ -0,0 +1,6 @@
+github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225 h1:kNX+jCowfMYzvlSvJu5pQWEmyWFrBXJ3PBy10xKMXK8=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
diff --git a/vendor/google.golang.org/appengine/identity.go b/vendor/google.golang.org/appengine/identity.go
new file mode 100644
index 0000000..b8dcf8f
--- /dev/null
+++ b/vendor/google.golang.org/appengine/identity.go
@@ -0,0 +1,142 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package appengine
+
+import (
+        "time"
+
+        "golang.org/x/net/context"
+
+        "google.golang.org/appengine/internal"
+        pb "google.golang.org/appengine/internal/app_identity"
+        modpb "google.golang.org/appengine/internal/modules"
+)
+
+// AppID returns the application ID for the current application.
+// The string will be a plain application ID (e.g. "appid"), with a
+// domain prefix for custom domain deployments (e.g. "example.com:appid").
+func AppID(c context.Context) string { return internal.AppID(c) }
+
+// DefaultVersionHostname returns the standard hostname of the default version
+// of the current application (e.g. "my-app.appspot.com"). This is suitable for
+// use in constructing URLs.
+func DefaultVersionHostname(c context.Context) string {
+        return internal.DefaultVersionHostname(c)
+}
+
+// ModuleName returns the module name of the current instance.
+func ModuleName(c context.Context) string {
+        return internal.ModuleName(c)
+}
+
+// ModuleHostname returns a hostname of a module instance.
+// If module is the empty string, it refers to the module of the current instance.
+// If version is empty, it refers to the version of the current instance if valid,
+// or the default version of the module of the current instance.
+// If instance is empty, ModuleHostname returns the load-balancing hostname.
+func ModuleHostname(c context.Context, module, version, instance string) (string, error) {
+        req := &modpb.GetHostnameRequest{}
+        if module != "" {
+                req.Module = &module
+        }
+        if version != "" {
+                req.Version = &version
+        }
+        if instance != "" {
+                req.Instance = &instance
+        }
+        res := &modpb.GetHostnameResponse{}
+        if err := internal.Call(c, "modules", "GetHostname", req, res); err != nil {
+                return "", err
+        }
+        return *res.Hostname, nil
+}
+
+// VersionID returns the version ID for the current application.
+// It will be of the form "X.Y", where X is specified in app.yaml,
+// and Y is a number generated when each version of the app is uploaded.
+// It does not include a module name.
+func VersionID(c context.Context) string { return internal.VersionID(c) }
+
+// InstanceID returns a mostly-unique identifier for this instance.
+func InstanceID() string { return internal.InstanceID() }
+
+// Datacenter returns an identifier for the datacenter that the instance is running in.
+func Datacenter(c context.Context) string { return internal.Datacenter(c) }
+
+// ServerSoftware returns the App Engine release version.
+// In production, it looks like "Google App Engine/X.Y.Z".
+// In the development appserver, it looks like "Development/X.Y".
+func ServerSoftware() string { return internal.ServerSoftware() }
+
+// RequestID returns a string that uniquely identifies the request.
+func RequestID(c context.Context) string { return internal.RequestID(c) }
+
+// AccessToken generates an OAuth2 access token for the specified scopes on
+// behalf of service account of this application. This token will expire after
+// the returned time.
+func AccessToken(c context.Context, scopes ...string) (token string, expiry time.Time, err error) {
+        req := &pb.GetAccessTokenRequest{Scope: scopes}
+        res := &pb.GetAccessTokenResponse{}
+
+        err = internal.Call(c, "app_identity_service", "GetAccessToken", req, res)
+        if err != nil {
+                return "", time.Time{}, err
+        }
+        return res.GetAccessToken(), time.Unix(res.GetExpirationTime(), 0), nil
+}
+
+// Certificate represents a public certificate for the app.
+type Certificate struct {
+        KeyName string
+        Data    []byte // PEM-encoded X.509 certificate
+}
+
+// PublicCertificates retrieves the public certificates for the app.
+// They can be used to verify a signature returned by SignBytes.
+func PublicCertificates(c context.Context) ([]Certificate, error) {
+        req := &pb.GetPublicCertificateForAppRequest{}
+        res := &pb.GetPublicCertificateForAppResponse{}
+        if err := internal.Call(c, "app_identity_service", "GetPublicCertificatesForApp", req, res); err != nil {
+                return nil, err
+        }
+        var cs []Certificate
+        for _, pc := range res.PublicCertificateList {
+                cs = append(cs, Certificate{
+                        KeyName: pc.GetKeyName(),
+                        Data:    []byte(pc.GetX509CertificatePem()),
+                })
+        }
+        return cs, nil
+}
+
+// ServiceAccount returns a string representing the service account name, in
+// the form of an email address (typically app_id@appspot.gserviceaccount.com).
+func ServiceAccount(c context.Context) (string, error) {
+        req := &pb.GetServiceAccountNameRequest{}
+        res := &pb.GetServiceAccountNameResponse{}
+
+        err := internal.Call(c, "app_identity_service", "GetServiceAccountName", req, res)
+        if err != nil {
+                return "", err
+        }
+        return res.GetServiceAccountName(), err
+}
+
+// SignBytes signs bytes using a private key unique to your application.
+func SignBytes(c context.Context, bytes []byte) (keyName string, signature []byte, err error) {
+        req := &pb.SignForAppRequest{BytesToSign: bytes}
+        res := &pb.SignForAppResponse{}
+
+        if err := internal.Call(c, "app_identity_service", "SignForApp", req, res); err != nil {
+                return "", nil, err
+        }
+        return res.GetKeyName(), res.GetSignatureBytes(), nil
+}
+
+func init() {
+        internal.RegisterErrorCodeMap("app_identity_service", pb.AppIdentityServiceError_ErrorCode_name)
+        internal.RegisterErrorCodeMap("modules", modpb.ModulesServiceError_ErrorCode_name)
+}
diff --git a/vendor/google.golang.org/appengine/internal/api.go b/vendor/google.golang.org/appengine/internal/api.go
new file mode 100644
index 0000000..bbc1cb9
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/api.go
@@ -0,0 +1,671 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build !appengine
+
+package internal
+
+import (
+        "bytes"
+        "errors"
+        "fmt"
+        "io/ioutil"
+        "log"
+        "net"
+        "net/http"
+        "net/url"
+        "os"
+        "runtime"
+        "strconv"
+        "strings"
+        "sync"
+        "sync/atomic"
+        "time"
+
+        "github.com/golang/protobuf/proto"
+        netcontext "golang.org/x/net/context"
+
+        basepb "google.golang.org/appengine/internal/base"
+        logpb "google.golang.org/appengine/internal/log"
+        remotepb "google.golang.org/appengine/internal/remote_api"
+)
+
+const (
+        apiPath             = "/rpc_http"
+        defaultTicketSuffix = "/default.20150612t184001.0"
+)
+
+var (
+        // Incoming headers.
+        ticketHeader       = http.CanonicalHeaderKey("X-AppEngine-API-Ticket")
+        dapperHeader       = http.CanonicalHeaderKey("X-Google-DapperTraceInfo")
+        traceHeader        = http.CanonicalHeaderKey("X-Cloud-Trace-Context")
+        curNamespaceHeader = http.CanonicalHeaderKey("X-AppEngine-Current-Namespace")
+        userIPHeader       = http.CanonicalHeaderKey("X-AppEngine-User-IP")
+        remoteAddrHeader   = http.CanonicalHeaderKey("X-AppEngine-Remote-Addr")
+
+        // Outgoing headers.
+        apiEndpointHeader      = http.CanonicalHeaderKey("X-Google-RPC-Service-Endpoint")
+        apiEndpointHeaderValue = []string{"app-engine-apis"}
+        apiMethodHeader        = http.CanonicalHeaderKey("X-Google-RPC-Service-Method")
+        apiMethodHeaderValue   = []string{"/VMRemoteAPI.CallRemoteAPI"}
+        apiDeadlineHeader      = http.CanonicalHeaderKey("X-Google-RPC-Service-Deadline")
+        apiContentType         = http.CanonicalHeaderKey("Content-Type")
+        apiContentTypeValue    = []string{"application/octet-stream"}
+        logFlushHeader         = http.CanonicalHeaderKey("X-AppEngine-Log-Flush-Count")
+
+        apiHTTPClient = &http.Client{
+                Transport: &http.Transport{
+                        Proxy: http.ProxyFromEnvironment,
+                        Dial:  limitDial,
+                },
+        }
+
+        defaultTicketOnce     sync.Once
+        defaultTicket         string
+        backgroundContextOnce sync.Once
+        backgroundContext     netcontext.Context
+)
+
+func apiURL() *url.URL {
+        host, port := "appengine.googleapis.internal", "10001"
+        if h := os.Getenv("API_HOST"); h != "" {
+                host = h
+        }
+        if p := os.Getenv("API_PORT"); p != "" {
+                port = p
+        }
+        return &url.URL{
+                Scheme: "http",
+                Host:   host + ":" + port,
+                Path:   apiPath,
+        }
+}
+
+func handleHTTP(w http.ResponseWriter, r *http.Request) {
+        c := &context{
+                req:       r,
+                outHeader: w.Header(),
+                apiURL:    apiURL(),
+        }
+        r = r.WithContext(withContext(r.Context(), c))
+        c.req = r
+
+        stopFlushing := make(chan int)
+
+        // Patch up RemoteAddr so it looks reasonable.
+        if addr := r.Header.Get(userIPHeader); addr != "" {
+                r.RemoteAddr = addr
+        } else if addr = r.Header.Get(remoteAddrHeader); addr != "" {
+                r.RemoteAddr = addr
+        } else {
+                // Should not normally reach here, but pick a sensible default anyway.
+                r.RemoteAddr = "127.0.0.1"
+        }
+        // The address in the headers will most likely be of these forms:
+        //      123.123.123.123
+        //      2001:db8::1
+        // net/http.Request.RemoteAddr is specified to be in "IP:port" form.
+        if _, _, err := net.SplitHostPort(r.RemoteAddr); err != nil {
+                // Assume the remote address is only a host; add a default port.
+                r.RemoteAddr = net.JoinHostPort(r.RemoteAddr, "80")
+        }
+
+        // Start goroutine responsible for flushing app logs.
+        // This is done after adding c to ctx.m (and stopped before removing it)
+        // because flushing logs requires making an API call.
+        go c.logFlusher(stopFlushing)
+
+        executeRequestSafely(c, r)
+        c.outHeader = nil // make sure header changes aren't respected any more
+
+        stopFlushing <- 1 // any logging beyond this point will be dropped
+
+        // Flush any pending logs asynchronously.
+        c.pendingLogs.Lock()
+        flushes := c.pendingLogs.flushes
+        if len(c.pendingLogs.lines) > 0 {
+                flushes++
+        }
+        c.pendingLogs.Unlock()
+        flushed := make(chan struct{})
+        go func() {
+                defer close(flushed)
+                // Force a log flush, because with very short requests we
+                // may not ever flush logs.
+                c.flushLog(true)
+        }()
+        w.Header().Set(logFlushHeader, strconv.Itoa(flushes))
+
+        // Avoid nil Write call if c.Write is never called.
+        if c.outCode != 0 {
+                w.WriteHeader(c.outCode)
+        }
+        if c.outBody != nil {
+                w.Write(c.outBody)
+        }
+        // Wait for the last flush to complete before returning,
+        // otherwise the security ticket will not be valid.
+        <-flushed
+}
+
+func executeRequestSafely(c *context, r *http.Request) {
+        defer func() {
+                if x := recover(); x != nil {
+                        logf(c, 4, "%s", renderPanic(x)) // 4 == critical
+                        c.outCode = 500
+                }
+        }()
+
+        http.DefaultServeMux.ServeHTTP(c, r)
+}
+
+func renderPanic(x interface{}) string {
+        buf := make([]byte, 16<<10) // 16 KB should be plenty
+        buf = buf[:runtime.Stack(buf, false)]
+
+        // Remove the first few stack frames:
+        //   this func
+        //   the recover closure in the caller
+        // That will root the stack trace at the site of the panic.
+        const (
+                skipStart  = "internal.renderPanic"
+                skipFrames = 2
+        )
+        start := bytes.Index(buf, []byte(skipStart))
+        p := start
+        for i := 0; i < skipFrames*2 && p+1 < len(buf); i++ {
+                p = bytes.IndexByte(buf[p+1:], '\n') + p + 1
+                if p < 0 {
+                        break
+                }
+        }
+        if p >= 0 {
+                // buf[start:p+1] is the block to remove.
+                // Copy buf[p+1:] over buf[start:] and shrink buf.
+                copy(buf[start:], buf[p+1:])
+                buf = buf[:len(buf)-(p+1-start)]
+        }
+
+        // Add panic heading.
+        head := fmt.Sprintf("panic: %v\n\n", x)
+        if len(head) > len(buf) {
+                // Extremely unlikely to happen.
+                return head
+        }
+        copy(buf[len(head):], buf)
+        copy(buf, head)
+
+        return string(buf)
+}
+
+// context represents the context of an in-flight HTTP request.
+// It implements the appengine.Context and http.ResponseWriter interfaces.
+type context struct {
+        req *http.Request
+
+        outCode   int
+        outHeader http.Header
+        outBody   []byte
+
+        pendingLogs struct {
+                sync.Mutex
+                lines   []*logpb.UserAppLogLine
+                flushes int
+        }
+
+        apiURL *url.URL
+}
+
+var contextKey = "holds a *context"
+
+// jointContext joins two contexts in a superficial way.
+// It takes values and timeouts from a base context, and only values from another context.
+type jointContext struct {
+        base       netcontext.Context
+        valuesOnly netcontext.Context
+}
+
+func (c jointContext) Deadline() (time.Time, bool) {
+        return c.base.Deadline()
+}
+
+func (c jointContext) Done() <-chan struct{} {
+        return c.base.Done()
+}
+
+func (c jointContext) Err() error {
+        return c.base.Err()
+}
+
+func (c jointContext) Value(key interface{}) interface{} {
+        if val := c.base.Value(key); val != nil {
+                return val
+        }
+        return c.valuesOnly.Value(key)
+}
+
+// fromContext returns the App Engine context or nil if ctx is not
+// derived from an App Engine context.
+func fromContext(ctx netcontext.Context) *context {
+        c, _ := ctx.Value(&contextKey).(*context)
+        return c
+}
+
+func withContext(parent netcontext.Context, c *context) netcontext.Context {
+        ctx := netcontext.WithValue(parent, &contextKey, c)
+        if ns := c.req.Header.Get(curNamespaceHeader); ns != "" {
+                ctx = withNamespace(ctx, ns)
+        }
+        return ctx
+}
+
+func toContext(c *context) netcontext.Context {
+        return withContext(netcontext.Background(), c)
+}
+
+func IncomingHeaders(ctx netcontext.Context) http.Header {
+        if c := fromContext(ctx); c != nil {
+                return c.req.Header
+        }
+        return nil
+}
+
+func ReqContext(req *http.Request) netcontext.Context {
+        return req.Context()
+}
+
+func WithContext(parent netcontext.Context, req *http.Request) netcontext.Context {
+        return jointContext{
+                base:       parent,
+                valuesOnly: req.Context(),
+        }
+}
+
+// DefaultTicket returns a ticket used for background context or dev_appserver.
+func DefaultTicket() string {
+        defaultTicketOnce.Do(func() {
+                if IsDevAppServer() {
+                        defaultTicket = "testapp" + defaultTicketSuffix
+                        return
+                }
+                appID := partitionlessAppID()
+                escAppID := strings.Replace(strings.Replace(appID, ":", "_", -1), ".", "_", -1)
+                majVersion := VersionID(nil)
+                if i := strings.Index(majVersion, "."); i > 0 {
+                        majVersion = majVersion[:i]
+                }
+                defaultTicket = fmt.Sprintf("%s/%s.%s.%s", escAppID, ModuleName(nil), majVersion, InstanceID())
+        })
+        return defaultTicket
+}
+
+func BackgroundContext() netcontext.Context {
+        backgroundContextOnce.Do(func() {
+                // Compute background security ticket.
+                ticket := DefaultTicket()
+
+                c := &context{
+                        req: &http.Request{
+                                Header: http.Header{
+                                        ticketHeader: []string{ticket},
+                                },
+                        },
+                        apiURL: apiURL(),
+                }
+                backgroundContext = toContext(c)
+
+                // TODO(dsymonds): Wire up the shutdown handler to do a final flush.
+                go c.logFlusher(make(chan int))
+        })
+
+        return backgroundContext
+}
+
+// RegisterTestRequest registers the HTTP request req for testing, such that
+// any API calls are sent to the provided URL. It returns a closure to delete
+// the registration.
+// It should only be used by aetest package.
+func RegisterTestRequest(req *http.Request, apiURL *url.URL, decorate func(netcontext.Context) netcontext.Context) (*http.Request, func()) {
+        c := &context{
+                req:    req,
+                apiURL: apiURL,
+        }
+        ctx := withContext(decorate(req.Context()), c)
+        req = req.WithContext(ctx)
+        c.req = req
+        return req, func() {}
+}
+
+var errTimeout = &CallError{
+        Detail:  "Deadline exceeded",
+        Code:    int32(remotepb.RpcError_CANCELLED),
+        Timeout: true,
+}
+
+func (c *context) Header() http.Header { return c.outHeader }
+
+// Copied from $GOROOT/src/pkg/net/http/transfer.go. Some response status
+// codes do not permit a response body (nor response entity headers such as
+// Content-Length, Content-Type, etc).
+func bodyAllowedForStatus(status int) bool {
+        switch {
+        case status >= 100 && status <= 199:
+                return false
+        case status == 204:
+                return false
+        case status == 304:
+                return false
+        }
+        return true
+}
+
+func (c *context) Write(b []byte) (int, error) {
+        if c.outCode == 0 {
+                c.WriteHeader(http.StatusOK)
+        }
+        if len(b) > 0 && !bodyAllowedForStatus(c.outCode) {
+                return 0, http.ErrBodyNotAllowed
+        }
+        c.outBody = append(c.outBody, b...)
+        return len(b), nil
+}
+
+func (c *context) WriteHeader(code int) {
+        if c.outCode != 0 {
+                logf(c, 3, "WriteHeader called multiple times on request.") // error level
+                return
+        }
+        c.outCode = code
+}
+
+func (c *context) post(body []byte, timeout time.Duration) (b []byte, err error) {
+        hreq := &http.Request{
+                Method: "POST",
+                URL:    c.apiURL,
+                Header: http.Header{
+                        apiEndpointHeader: apiEndpointHeaderValue,
+                        apiMethodHeader:   apiMethodHeaderValue,
+                        apiContentType:    apiContentTypeValue,
+                        apiDeadlineHeader: []string{strconv.FormatFloat(timeout.Seconds(), 'f', -1, 64)},
+                },
+                Body:          ioutil.NopCloser(bytes.NewReader(body)),
+                ContentLength: int64(len(body)),
+                Host:          c.apiURL.Host,
+        }
+        if info := c.req.Header.Get(dapperHeader); info != "" {
+                hreq.Header.Set(dapperHeader, info)
+        }
+        if info := c.req.Header.Get(traceHeader); info != "" {
+                hreq.Header.Set(traceHeader, info)
+        }
+
+        tr := apiHTTPClient.Transport.(*http.Transport)
+
+        var timedOut int32 // atomic; set to 1 if timed out
+        t := time.AfterFunc(timeout, func() {
+                atomic.StoreInt32(&timedOut, 1)
+                tr.CancelRequest(hreq)
+        })
+        defer t.Stop()
+        defer func() {
+                // Check if timeout was exceeded.
+                if atomic.LoadInt32(&timedOut) != 0 {
+                        err = errTimeout
+                }
+        }()
+
+        hresp, err := apiHTTPClient.Do(hreq)
+        if err != nil {
+                return nil, &CallError{
+                        Detail: fmt.Sprintf("service bridge HTTP failed: %v", err),
+                        Code:   int32(remotepb.RpcError_UNKNOWN),
+                }
+        }
+        defer hresp.Body.Close()
+        hrespBody, err := ioutil.ReadAll(hresp.Body)
+        if hresp.StatusCode != 200 {
+                return nil, &CallError{
+                        Detail: fmt.Sprintf("service bridge returned HTTP %d (%q)", hresp.StatusCode, hrespBody),
+                        Code:   int32(remotepb.RpcError_UNKNOWN),
+                }
+        }
+        if err != nil {
+                return nil, &CallError{
+                        Detail: fmt.Sprintf("service bridge response bad: %v", err),
+                        Code:   int32(remotepb.RpcError_UNKNOWN),
+                }
+        }
+        return hrespBody, nil
+}
+
+func Call(ctx netcontext.Context, service, method string, in, out proto.Message) error {
+        if ns := NamespaceFromContext(ctx); ns != "" {
+                if fn, ok := NamespaceMods[service]; ok {
+                        fn(in, ns)
+                }
+        }
+
+        if f, ctx, ok := callOverrideFromContext(ctx); ok {
+                return f(ctx, service, method, in, out)
+        }
+
+        // Handle already-done contexts quickly.
+        select {
+        case <-ctx.Done():
+                return ctx.Err()
+        default:
+        }
+
+        c := fromContext(ctx)
+        if c == nil {
+                // Give a good error message rather than a panic lower down.
+                return errNotAppEngineContext
+        }
+
+        // Apply transaction modifications if we're in a transaction.
+        if t := transactionFromContext(ctx); t != nil {
+                if t.finished {
+                        return errors.New("transaction context has expired")
+                }
+                applyTransaction(in, &t.transaction)
+        }
+
+        // Default RPC timeout is 60s.
+        timeout := 60 * time.Second
+        if deadline, ok := ctx.Deadline(); ok {
+                timeout = deadline.Sub(time.Now())
+        }
+
+        data, err := proto.Marshal(in)
+        if err != nil {
+                return err
+        }
+
+        ticket := c.req.Header.Get(ticketHeader)
+        // Use a test ticket under test environment.
+        if ticket == "" {
+                if appid := ctx.Value(&appIDOverrideKey); appid != nil {
+                        ticket = appid.(string) + defaultTicketSuffix
+                }
+        }
+        // Fall back to use background ticket when the request ticket is not available in Flex or dev_appserver.
+        if ticket == "" {
+                ticket = DefaultTicket()
+        }
+        req := &remotepb.Request{
+                ServiceName: &service,
+                Method:      &method,
+                Request:     data,
+                RequestId:   &ticket,
+        }
+        hreqBody, err := proto.Marshal(req)
+        if err != nil {
+                return err
+        }
+
+        hrespBody, err := c.post(hreqBody, timeout)
+        if err != nil {
+                return err
+        }
+
+        res := &remotepb.Response{}
+        if err := proto.Unmarshal(hrespBody, res); err != nil {
+                return err
+        }
+        if res.RpcError != nil {
+                ce := &CallError{
+                        Detail: res.RpcError.GetDetail(),
+                        Code:   *res.RpcError.Code,
+                }
+                switch remotepb.RpcError_ErrorCode(ce.Code) {
+                case remotepb.RpcError_CANCELLED, remotepb.RpcError_DEADLINE_EXCEEDED:
+                        ce.Timeout = true
+                }
+                return ce
+        }
+        if res.ApplicationError != nil {
+                return &APIError{
+                        Service: *req.ServiceName,
+                        Detail:  res.ApplicationError.GetDetail(),
+                        Code:    *res.ApplicationError.Code,
+                }
+        }
+        if res.Exception != nil || res.JavaException != nil {
+                // This shouldn't happen, but let's be defensive.
+                return &CallError{
+                        Detail: "service bridge returned exception",
+                        Code:   int32(remotepb.RpcError_UNKNOWN),
+                }
+        }
+        return proto.Unmarshal(res.Response, out)
+}
+
+func (c *context) Request() *http.Request {
+        return c.req
+}
+
+func (c *context) addLogLine(ll *logpb.UserAppLogLine) {
+        // Truncate long log lines.
+        // TODO(dsymonds): Check if this is still necessary.
+        const lim = 8 << 10
+        if len(*ll.Message) > lim {
+                suffix := fmt.Sprintf("...(length %d)", len(*ll.Message))
+                ll.Message = proto.String((*ll.Message)[:lim-len(suffix)] + suffix)
+        }
+
+        c.pendingLogs.Lock()
+        c.pendingLogs.lines = append(c.pendingLogs.lines, ll)
+        c.pendingLogs.Unlock()
+}
+
+var logLevelName = map[int64]string{
+        0: "DEBUG",
+        1: "INFO",
+        2: "WARNING",
+        3: "ERROR",
+        4: "CRITICAL",
+}
+
+func logf(c *context, level int64, format string, args ...interface{}) {
+        if c == nil {
+                panic("not an App Engine context")
+        }
+        s := fmt.Sprintf(format, args...)
+        s = strings.TrimRight(s, "\n") // Remove any trailing newline characters.
+        c.addLogLine(&logpb.UserAppLogLine{
+                TimestampUsec: proto.Int64(time.Now().UnixNano() / 1e3),
+                Level:         &level,
+                Message:       &s,
+        })
+        // Only duplicate log to stderr if not running on App Engine second generation
+        if !IsSecondGen() {
+                log.Print(logLevelName[level] + ": " + s)
+        }
+}
+
+// flushLog attempts to flush any pending logs to the appserver.
+// It should not be called concurrently.
+func (c *context) flushLog(force bool) (flushed bool) {
+        c.pendingLogs.Lock()
+        // Grab up to 30 MB. We can get away with up to 32 MB, but let's be cautious.
+        n, rem := 0, 30<<20
+        for ; n < len(c.pendingLogs.lines); n++ {
+                ll := c.pendingLogs.lines[n]
+                // Each log line will require about 3 bytes of overhead.
+                nb := proto.Size(ll) + 3
+                if nb > rem {
+                        break
+                }
+                rem -= nb
+        }
+        lines := c.pendingLogs.lines[:n]
+        c.pendingLogs.lines = c.pendingLogs.lines[n:]
+        c.pendingLogs.Unlock()
+
+        if len(lines) == 0 && !force {
+                // Nothing to flush.
+                return false
+        }
+
+        rescueLogs := false
+        defer func() {
+                if rescueLogs {
+                        c.pendingLogs.Lock()
+                        c.pendingLogs.lines = append(lines, c.pendingLogs.lines...)
+                        c.pendingLogs.Unlock()
+                }
+        }()
+
+        buf, err := proto.Marshal(&logpb.UserAppLogGroup{
+                LogLine: lines,
+        })
+        if err != nil {
+                log.Printf("internal.flushLog: marshaling UserAppLogGroup: %v", err)
+                rescueLogs = true
+                return false
+        }
+
+        req := &logpb.FlushRequest{
+                Logs: buf,
+        }
+        res := &basepb.VoidProto{}
+        c.pendingLogs.Lock()
+        c.pendingLogs.flushes++
+        c.pendingLogs.Unlock()
+        if err := Call(toContext(c), "logservice", "Flush", req, res); err != nil {
+                log.Printf("internal.flushLog: Flush RPC: %v", err)
+                rescueLogs = true
+                return false
+        }
+        return true
+}
+
+const (
+        // Log flushing parameters.
+        flushInterval      = 1 * time.Second
+        forceFlushInterval = 60 * time.Second
+)
+
+func (c *context) logFlusher(stop <-chan int) {
+        lastFlush := time.Now()
+        tick := time.NewTicker(flushInterval)
+        for {
+                select {
+                case <-stop:
+                        // Request finished.
+                        tick.Stop()
+                        return
+                case <-tick.C:
+                        force := time.Now().Sub(lastFlush) > forceFlushInterval
+                        if c.flushLog(force) {
+                                lastFlush = time.Now()
+                        }
+                }
+        }
+}
+
+func ContextForTesting(req *http.Request) netcontext.Context {
+        return toContext(&context{req: req})
+}
diff --git a/vendor/google.golang.org/appengine/internal/api_classic.go b/vendor/google.golang.org/appengine/internal/api_classic.go
new file mode 100644
index 0000000..f0f40b2
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/api_classic.go
@@ -0,0 +1,169 @@
+// Copyright 2015 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build appengine
+
+package internal
+
+import (
+        "errors"
+        "fmt"
+        "net/http"
+        "time"
+
+        "appengine"
+        "appengine_internal"
+        basepb "appengine_internal/base"
+
+        "github.com/golang/protobuf/proto"
+        netcontext "golang.org/x/net/context"
+)
+
+var contextKey = "holds an appengine.Context"
+
+// fromContext returns the App Engine context or nil if ctx is not
+// derived from an App Engine context.
+func fromContext(ctx netcontext.Context) appengine.Context {
+        c, _ := ctx.Value(&contextKey).(appengine.Context)
+        return c
+}
+
+// This is only for classic App Engine adapters.
+func ClassicContextFromContext(ctx netcontext.Context) (appengine.Context, error) {
+        c := fromContext(ctx)
+        if c == nil {
+                return nil, errNotAppEngineContext
+        }
+        return c, nil
+}
+
+func withContext(parent netcontext.Context, c appengine.Context) netcontext.Context {
+        ctx := netcontext.WithValue(parent, &contextKey, c)
+
+        s := &basepb.StringProto{}
+        c.Call("__go__", "GetNamespace", &basepb.VoidProto{}, s, nil)
+        if ns := s.GetValue(); ns != "" {
+                ctx = NamespacedContext(ctx, ns)
+        }
+
+        return ctx
+}
+
+func IncomingHeaders(ctx netcontext.Context) http.Header {
+        if c := fromContext(ctx); c != nil {
+                if req, ok := c.Request().(*http.Request); ok {
+                        return req.Header
+                }
+        }
+        return nil
+}
+
+func ReqContext(req *http.Request) netcontext.Context {
+        return WithContext(netcontext.Background(), req)
+}
+
+func WithContext(parent netcontext.Context, req *http.Request) netcontext.Context {
+        c := appengine.NewContext(req)
+        return withContext(parent, c)
+}
+
+type testingContext struct {
+        appengine.Context
+
+        req *http.Request
+}
+
+func (t *testingContext) FullyQualifiedAppID() string { return "dev~testcontext" }
+func (t *testingContext) Call(service, method string, _, _ appengine_internal.ProtoMessage, _ *appengine_internal.CallOptions) error {
+        if service == "__go__" && method == "GetNamespace" {
+                return nil
+        }
+        return fmt.Errorf("testingContext: unsupported Call")
+}
+func (t *testingContext) Request() interface{} { return t.req }
+
+func ContextForTesting(req *http.Request) netcontext.Context {
+        return withContext(netcontext.Background(), &testingContext{req: req})
+}
+
+func Call(ctx netcontext.Context, service, method string, in, out proto.Message) error {
+        if ns := NamespaceFromContext(ctx); ns != "" {
+                if fn, ok := NamespaceMods[service]; ok {
+                        fn(in, ns)
+                }
+        }
+
+        if f, ctx, ok := callOverrideFromContext(ctx); ok {
+                return f(ctx, service, method, in, out)
+        }
+
+        // Handle already-done contexts quickly.
+        select {
+        case <-ctx.Done():
+                return ctx.Err()
+        default:
+        }
+
+        c := fromContext(ctx)
+        if c == nil {
+                // Give a good error message rather than a panic lower down.
+                return errNotAppEngineContext
+        }
+
+        // Apply transaction modifications if we're in a transaction.
+        if t := transactionFromContext(ctx); t != nil {
+                if t.finished {
+                        return errors.New("transaction context has expired")
+                }
+                applyTransaction(in, &t.transaction)
+        }
+
+        var opts *appengine_internal.CallOptions
+        if d, ok := ctx.Deadline(); ok {
+                opts = &appengine_internal.CallOptions{
+                        Timeout: d.Sub(time.Now()),
+                }
+        }
+
+        err := c.Call(service, method, in, out, opts)
+        switch v := err.(type) {
+        case *appengine_internal.APIError:
+                return &APIError{
+                        Service: v.Service,
+                        Detail:  v.Detail,
+                        Code:    v.Code,
+                }
+        case *appengine_internal.CallError:
+                return &CallError{
+                        Detail:  v.Detail,
+                        Code:    v.Code,
+                        Timeout: v.Timeout,
+                }
+        }
+        return err
+}
+
+func handleHTTP(w http.ResponseWriter, r *http.Request) {
+        panic("handleHTTP called; this should be impossible")
+}
+
+func logf(c appengine.Context, level int64, format string, args ...interface{}) {
+        var fn func(format string, args ...interface{})
+        switch level {
+        case 0:
+                fn = c.Debugf
+        case 1:
+                fn = c.Infof
+        case 2:
+                fn = c.Warningf
+        case 3:
+                fn = c.Errorf
+        case 4:
+                fn = c.Criticalf
+        default:
+                // This shouldn't happen.
+                fn = c.Criticalf
+        }
+        fn(format, args...)
+}
diff --git a/vendor/google.golang.org/appengine/internal/api_common.go b/vendor/google.golang.org/appengine/internal/api_common.go
new file mode 100644
index 0000000..e0c0b21
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/api_common.go
@@ -0,0 +1,123 @@
+// Copyright 2015 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package internal
+
+import (
+        "errors"
+        "os"
+
+        "github.com/golang/protobuf/proto"
+        netcontext "golang.org/x/net/context"
+)
+
+var errNotAppEngineContext = errors.New("not an App Engine context")
+
+type CallOverrideFunc func(ctx netcontext.Context, service, method string, in, out proto.Message) error
+
+var callOverrideKey = "holds []CallOverrideFunc"
+
+func WithCallOverride(ctx netcontext.Context, f CallOverrideFunc) netcontext.Context {
+        // We avoid appending to any existing call override
+        // so we don't risk overwriting a popped stack below.
+        var cofs []CallOverrideFunc
+        if uf, ok := ctx.Value(&callOverrideKey).([]CallOverrideFunc); ok {
+                cofs = append(cofs, uf...)
+        }
+        cofs = append(cofs, f)
+        return netcontext.WithValue(ctx, &callOverrideKey, cofs)
+}
+
+func callOverrideFromContext(ctx netcontext.Context) (CallOverrideFunc, netcontext.Context, bool) {
+        cofs, _ := ctx.Value(&callOverrideKey).([]CallOverrideFunc)
+        if len(cofs) == 0 {
+                return nil, nil, false
+        }
+        // We found a list of overrides; grab the last, and reconstitute a
+        // context that will hide it.
+        f := cofs[len(cofs)-1]
+        ctx = netcontext.WithValue(ctx, &callOverrideKey, cofs[:len(cofs)-1])
+        return f, ctx, true
+}
+
+type logOverrideFunc func(level int64, format string, args ...interface{})
+
+var logOverrideKey = "holds a logOverrideFunc"
+
+func WithLogOverride(ctx netcontext.Context, f logOverrideFunc) netcontext.Context {
+        return netcontext.WithValue(ctx, &logOverrideKey, f)
+}
+
+var appIDOverrideKey = "holds a string, being the full app ID"
+
+func WithAppIDOverride(ctx netcontext.Context, appID string) netcontext.Context {
+        return netcontext.WithValue(ctx, &appIDOverrideKey, appID)
+}
+
+var namespaceKey = "holds the namespace string"
+
+func withNamespace(ctx netcontext.Context, ns string) netcontext.Context {
+        return netcontext.WithValue(ctx, &namespaceKey, ns)
+}
+
+func NamespaceFromContext(ctx netcontext.Context) string {
+        // If there's no namespace, return the empty string.
+        ns, _ := ctx.Value(&namespaceKey).(string)
+        return ns
+}
+
+// FullyQualifiedAppID returns the fully-qualified application ID.
+// This may contain a partition prefix (e.g. "s~" for High Replication apps),
+// or a domain prefix (e.g. "example.com:").
+func FullyQualifiedAppID(ctx netcontext.Context) string {
+        if id, ok := ctx.Value(&appIDOverrideKey).(string); ok {
+                return id
+        }
+        return fullyQualifiedAppID(ctx)
+}
+
+func Logf(ctx netcontext.Context, level int64, format string, args ...interface{}) {
+        if f, ok := ctx.Value(&logOverrideKey).(logOverrideFunc); ok {
+                f(level, format, args...)
+                return
+        }
+        c := fromContext(ctx)
+        if c == nil {
+                panic(errNotAppEngineContext)
+        }
+        logf(c, level, format, args...)
+}
+
+// NamespacedContext wraps a Context to support namespaces.
+func NamespacedContext(ctx netcontext.Context, namespace string) netcontext.Context {
+        return withNamespace(ctx, namespace)
+}
+
+// SetTestEnv sets the env variables for testing background ticket in Flex.
+func SetTestEnv() func() {
+        var environ = []struct {
+                key, value string
+        }{
+                {"GAE_LONG_APP_ID", "my-app-id"},
+                {"GAE_MINOR_VERSION", "067924799508853122"},
+                {"GAE_MODULE_INSTANCE", "0"},
+                {"GAE_MODULE_NAME", "default"},
+                {"GAE_MODULE_VERSION", "20150612t184001"},
+        }
+
+        for _, v := range environ {
+                old := os.Getenv(v.key)
+                os.Setenv(v.key, v.value)
+                v.value = old
+        }
+        return func() { // Restore old environment after the test completes.
+                for _, v := range environ {
+                        if v.value == "" {
+                                os.Unsetenv(v.key)
+                                continue
+                        }
+                        os.Setenv(v.key, v.value)
+                }
+        }
+}
diff --git a/vendor/google.golang.org/appengine/internal/app_id.go b/vendor/google.golang.org/appengine/internal/app_id.go
new file mode 100644
index 0000000..11df8c0
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/app_id.go
@@ -0,0 +1,28 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package internal
+
+import (
+        "strings"
+)
+
+func parseFullAppID(appid string) (partition, domain, displayID string) {
+        if i := strings.Index(appid, "~"); i != -1 {
+                partition, appid = appid[:i], appid[i+1:]
+        }
+        if i := strings.Index(appid, ":"); i != -1 {
+                domain, appid = appid[:i], appid[i+1:]
+        }
+        return partition, domain, appid
+}
+
+// appID returns "appid" or "domain.com:appid".
+func appID(fullAppID string) string {
+        _, dom, dis := parseFullAppID(fullAppID)
+        if dom != "" {
+                return dom + ":" + dis
+        }
+        return dis
+}
diff --git a/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.pb.go b/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.pb.go
new file mode 100644
index 0000000..9a2ff77
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.pb.go
@@ -0,0 +1,611 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google.golang.org/appengine/internal/app_identity/app_identity_service.proto
+
+package app_identity
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// 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
+
+type AppIdentityServiceError_ErrorCode int32
+
+const (
+        AppIdentityServiceError_SUCCESS           AppIdentityServiceError_ErrorCode = 0
+        AppIdentityServiceError_UNKNOWN_SCOPE     AppIdentityServiceError_ErrorCode = 9
+        AppIdentityServiceError_BLOB_TOO_LARGE    AppIdentityServiceError_ErrorCode = 1000
+        AppIdentityServiceError_DEADLINE_EXCEEDED AppIdentityServiceError_ErrorCode = 1001
+        AppIdentityServiceError_NOT_A_VALID_APP   AppIdentityServiceError_ErrorCode = 1002
+        AppIdentityServiceError_UNKNOWN_ERROR     AppIdentityServiceError_ErrorCode = 1003
+        AppIdentityServiceError_NOT_ALLOWED       AppIdentityServiceError_ErrorCode = 1005
+        AppIdentityServiceError_NOT_IMPLEMENTED   AppIdentityServiceError_ErrorCode = 1006
+)
+
+var AppIdentityServiceError_ErrorCode_name = map[int32]string{
+        0:    "SUCCESS",
+        9:    "UNKNOWN_SCOPE",
+        1000: "BLOB_TOO_LARGE",
+        1001: "DEADLINE_EXCEEDED",
+        1002: "NOT_A_VALID_APP",
+        1003: "UNKNOWN_ERROR",
+        1005: "NOT_ALLOWED",
+        1006: "NOT_IMPLEMENTED",
+}
+var AppIdentityServiceError_ErrorCode_value = map[string]int32{
+        "SUCCESS":           0,
+        "UNKNOWN_SCOPE":     9,
+        "BLOB_TOO_LARGE":    1000,
+        "DEADLINE_EXCEEDED": 1001,
+        "NOT_A_VALID_APP":   1002,
+        "UNKNOWN_ERROR":     1003,
+        "NOT_ALLOWED":       1005,
+        "NOT_IMPLEMENTED":   1006,
+}
+
+func (x AppIdentityServiceError_ErrorCode) Enum() *AppIdentityServiceError_ErrorCode {
+        p := new(AppIdentityServiceError_ErrorCode)
+        *p = x
+        return p
+}
+func (x AppIdentityServiceError_ErrorCode) String() string {
+        return proto.EnumName(AppIdentityServiceError_ErrorCode_name, int32(x))
+}
+func (x *AppIdentityServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(AppIdentityServiceError_ErrorCode_value, data, "AppIdentityServiceError_ErrorCode")
+        if err != nil {
+                return err
+        }
+        *x = AppIdentityServiceError_ErrorCode(value)
+        return nil
+}
+func (AppIdentityServiceError_ErrorCode) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{0, 0}
+}
+
+type AppIdentityServiceError struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *AppIdentityServiceError) Reset()         { *m = AppIdentityServiceError{} }
+func (m *AppIdentityServiceError) String() string { return proto.CompactTextString(m) }
+func (*AppIdentityServiceError) ProtoMessage()    {}
+func (*AppIdentityServiceError) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{0}
+}
+func (m *AppIdentityServiceError) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_AppIdentityServiceError.Unmarshal(m, b)
+}
+func (m *AppIdentityServiceError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_AppIdentityServiceError.Marshal(b, m, deterministic)
+}
+func (dst *AppIdentityServiceError) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_AppIdentityServiceError.Merge(dst, src)
+}
+func (m *AppIdentityServiceError) XXX_Size() int {
+        return xxx_messageInfo_AppIdentityServiceError.Size(m)
+}
+func (m *AppIdentityServiceError) XXX_DiscardUnknown() {
+        xxx_messageInfo_AppIdentityServiceError.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AppIdentityServiceError proto.InternalMessageInfo
+
+type SignForAppRequest struct {
+        BytesToSign          []byte   `protobuf:"bytes,1,opt,name=bytes_to_sign,json=bytesToSign" json:"bytes_to_sign,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SignForAppRequest) Reset()         { *m = SignForAppRequest{} }
+func (m *SignForAppRequest) String() string { return proto.CompactTextString(m) }
+func (*SignForAppRequest) ProtoMessage()    {}
+func (*SignForAppRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{1}
+}
+func (m *SignForAppRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_SignForAppRequest.Unmarshal(m, b)
+}
+func (m *SignForAppRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_SignForAppRequest.Marshal(b, m, deterministic)
+}
+func (dst *SignForAppRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_SignForAppRequest.Merge(dst, src)
+}
+func (m *SignForAppRequest) XXX_Size() int {
+        return xxx_messageInfo_SignForAppRequest.Size(m)
+}
+func (m *SignForAppRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_SignForAppRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SignForAppRequest proto.InternalMessageInfo
+
+func (m *SignForAppRequest) GetBytesToSign() []byte {
+        if m != nil {
+                return m.BytesToSign
+        }
+        return nil
+}
+
+type SignForAppResponse struct {
+        KeyName              *string  `protobuf:"bytes,1,opt,name=key_name,json=keyName" json:"key_name,omitempty"`
+        SignatureBytes       []byte   `protobuf:"bytes,2,opt,name=signature_bytes,json=signatureBytes" json:"signature_bytes,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SignForAppResponse) Reset()         { *m = SignForAppResponse{} }
+func (m *SignForAppResponse) String() string { return proto.CompactTextString(m) }
+func (*SignForAppResponse) ProtoMessage()    {}
+func (*SignForAppResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{2}
+}
+func (m *SignForAppResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_SignForAppResponse.Unmarshal(m, b)
+}
+func (m *SignForAppResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_SignForAppResponse.Marshal(b, m, deterministic)
+}
+func (dst *SignForAppResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_SignForAppResponse.Merge(dst, src)
+}
+func (m *SignForAppResponse) XXX_Size() int {
+        return xxx_messageInfo_SignForAppResponse.Size(m)
+}
+func (m *SignForAppResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_SignForAppResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SignForAppResponse proto.InternalMessageInfo
+
+func (m *SignForAppResponse) GetKeyName() string {
+        if m != nil && m.KeyName != nil {
+                return *m.KeyName
+        }
+        return ""
+}
+
+func (m *SignForAppResponse) GetSignatureBytes() []byte {
+        if m != nil {
+                return m.SignatureBytes
+        }
+        return nil
+}
+
+type GetPublicCertificateForAppRequest struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetPublicCertificateForAppRequest) Reset()         { *m = GetPublicCertificateForAppRequest{} }
+func (m *GetPublicCertificateForAppRequest) String() string { return proto.CompactTextString(m) }
+func (*GetPublicCertificateForAppRequest) ProtoMessage()    {}
+func (*GetPublicCertificateForAppRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{3}
+}
+func (m *GetPublicCertificateForAppRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetPublicCertificateForAppRequest.Unmarshal(m, b)
+}
+func (m *GetPublicCertificateForAppRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetPublicCertificateForAppRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetPublicCertificateForAppRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetPublicCertificateForAppRequest.Merge(dst, src)
+}
+func (m *GetPublicCertificateForAppRequest) XXX_Size() int {
+        return xxx_messageInfo_GetPublicCertificateForAppRequest.Size(m)
+}
+func (m *GetPublicCertificateForAppRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetPublicCertificateForAppRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetPublicCertificateForAppRequest proto.InternalMessageInfo
+
+type PublicCertificate struct {
+        KeyName              *string  `protobuf:"bytes,1,opt,name=key_name,json=keyName" json:"key_name,omitempty"`
+        X509CertificatePem   *string  `protobuf:"bytes,2,opt,name=x509_certificate_pem,json=x509CertificatePem" json:"x509_certificate_pem,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PublicCertificate) Reset()         { *m = PublicCertificate{} }
+func (m *PublicCertificate) String() string { return proto.CompactTextString(m) }
+func (*PublicCertificate) ProtoMessage()    {}
+func (*PublicCertificate) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{4}
+}
+func (m *PublicCertificate) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_PublicCertificate.Unmarshal(m, b)
+}
+func (m *PublicCertificate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_PublicCertificate.Marshal(b, m, deterministic)
+}
+func (dst *PublicCertificate) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_PublicCertificate.Merge(dst, src)
+}
+func (m *PublicCertificate) XXX_Size() int {
+        return xxx_messageInfo_PublicCertificate.Size(m)
+}
+func (m *PublicCertificate) XXX_DiscardUnknown() {
+        xxx_messageInfo_PublicCertificate.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PublicCertificate proto.InternalMessageInfo
+
+func (m *PublicCertificate) GetKeyName() string {
+        if m != nil && m.KeyName != nil {
+                return *m.KeyName
+        }
+        return ""
+}
+
+func (m *PublicCertificate) GetX509CertificatePem() string {
+        if m != nil && m.X509CertificatePem != nil {
+                return *m.X509CertificatePem
+        }
+        return ""
+}
+
+type GetPublicCertificateForAppResponse struct {
+        PublicCertificateList      []*PublicCertificate `protobuf:"bytes,1,rep,name=public_certificate_list,json=publicCertificateList" json:"public_certificate_list,omitempty"`
+        MaxClientCacheTimeInSecond *int64               `protobuf:"varint,2,opt,name=max_client_cache_time_in_second,json=maxClientCacheTimeInSecond" json:"max_client_cache_time_in_second,omitempty"`
+        XXX_NoUnkeyedLiteral       struct{}             `json:"-"`
+        XXX_unrecognized           []byte               `json:"-"`
+        XXX_sizecache              int32                `json:"-"`
+}
+
+func (m *GetPublicCertificateForAppResponse) Reset()         { *m = GetPublicCertificateForAppResponse{} }
+func (m *GetPublicCertificateForAppResponse) String() string { return proto.CompactTextString(m) }
+func (*GetPublicCertificateForAppResponse) ProtoMessage()    {}
+func (*GetPublicCertificateForAppResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{5}
+}
+func (m *GetPublicCertificateForAppResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetPublicCertificateForAppResponse.Unmarshal(m, b)
+}
+func (m *GetPublicCertificateForAppResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetPublicCertificateForAppResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetPublicCertificateForAppResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetPublicCertificateForAppResponse.Merge(dst, src)
+}
+func (m *GetPublicCertificateForAppResponse) XXX_Size() int {
+        return xxx_messageInfo_GetPublicCertificateForAppResponse.Size(m)
+}
+func (m *GetPublicCertificateForAppResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetPublicCertificateForAppResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetPublicCertificateForAppResponse proto.InternalMessageInfo
+
+func (m *GetPublicCertificateForAppResponse) GetPublicCertificateList() []*PublicCertificate {
+        if m != nil {
+                return m.PublicCertificateList
+        }
+        return nil
+}
+
+func (m *GetPublicCertificateForAppResponse) GetMaxClientCacheTimeInSecond() int64 {
+        if m != nil && m.MaxClientCacheTimeInSecond != nil {
+                return *m.MaxClientCacheTimeInSecond
+        }
+        return 0
+}
+
+type GetServiceAccountNameRequest struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetServiceAccountNameRequest) Reset()         { *m = GetServiceAccountNameRequest{} }
+func (m *GetServiceAccountNameRequest) String() string { return proto.CompactTextString(m) }
+func (*GetServiceAccountNameRequest) ProtoMessage()    {}
+func (*GetServiceAccountNameRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{6}
+}
+func (m *GetServiceAccountNameRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetServiceAccountNameRequest.Unmarshal(m, b)
+}
+func (m *GetServiceAccountNameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetServiceAccountNameRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetServiceAccountNameRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetServiceAccountNameRequest.Merge(dst, src)
+}
+func (m *GetServiceAccountNameRequest) XXX_Size() int {
+        return xxx_messageInfo_GetServiceAccountNameRequest.Size(m)
+}
+func (m *GetServiceAccountNameRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetServiceAccountNameRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetServiceAccountNameRequest proto.InternalMessageInfo
+
+type GetServiceAccountNameResponse struct {
+        ServiceAccountName   *string  `protobuf:"bytes,1,opt,name=service_account_name,json=serviceAccountName" json:"service_account_name,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetServiceAccountNameResponse) Reset()         { *m = GetServiceAccountNameResponse{} }
+func (m *GetServiceAccountNameResponse) String() string { return proto.CompactTextString(m) }
+func (*GetServiceAccountNameResponse) ProtoMessage()    {}
+func (*GetServiceAccountNameResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{7}
+}
+func (m *GetServiceAccountNameResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetServiceAccountNameResponse.Unmarshal(m, b)
+}
+func (m *GetServiceAccountNameResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetServiceAccountNameResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetServiceAccountNameResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetServiceAccountNameResponse.Merge(dst, src)
+}
+func (m *GetServiceAccountNameResponse) XXX_Size() int {
+        return xxx_messageInfo_GetServiceAccountNameResponse.Size(m)
+}
+func (m *GetServiceAccountNameResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetServiceAccountNameResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetServiceAccountNameResponse proto.InternalMessageInfo
+
+func (m *GetServiceAccountNameResponse) GetServiceAccountName() string {
+        if m != nil && m.ServiceAccountName != nil {
+                return *m.ServiceAccountName
+        }
+        return ""
+}
+
+type GetAccessTokenRequest struct {
+        Scope                []string `protobuf:"bytes,1,rep,name=scope" json:"scope,omitempty"`
+        ServiceAccountId     *int64   `protobuf:"varint,2,opt,name=service_account_id,json=serviceAccountId" json:"service_account_id,omitempty"`
+        ServiceAccountName   *string  `protobuf:"bytes,3,opt,name=service_account_name,json=serviceAccountName" json:"service_account_name,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetAccessTokenRequest) Reset()         { *m = GetAccessTokenRequest{} }
+func (m *GetAccessTokenRequest) String() string { return proto.CompactTextString(m) }
+func (*GetAccessTokenRequest) ProtoMessage()    {}
+func (*GetAccessTokenRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{8}
+}
+func (m *GetAccessTokenRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetAccessTokenRequest.Unmarshal(m, b)
+}
+func (m *GetAccessTokenRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetAccessTokenRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetAccessTokenRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetAccessTokenRequest.Merge(dst, src)
+}
+func (m *GetAccessTokenRequest) XXX_Size() int {
+        return xxx_messageInfo_GetAccessTokenRequest.Size(m)
+}
+func (m *GetAccessTokenRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetAccessTokenRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetAccessTokenRequest proto.InternalMessageInfo
+
+func (m *GetAccessTokenRequest) GetScope() []string {
+        if m != nil {
+                return m.Scope
+        }
+        return nil
+}
+
+func (m *GetAccessTokenRequest) GetServiceAccountId() int64 {
+        if m != nil && m.ServiceAccountId != nil {
+                return *m.ServiceAccountId
+        }
+        return 0
+}
+
+func (m *GetAccessTokenRequest) GetServiceAccountName() string {
+        if m != nil && m.ServiceAccountName != nil {
+                return *m.ServiceAccountName
+        }
+        return ""
+}
+
+type GetAccessTokenResponse struct {
+        AccessToken          *string  `protobuf:"bytes,1,opt,name=access_token,json=accessToken" json:"access_token,omitempty"`
+        ExpirationTime       *int64   `protobuf:"varint,2,opt,name=expiration_time,json=expirationTime" json:"expiration_time,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetAccessTokenResponse) Reset()         { *m = GetAccessTokenResponse{} }
+func (m *GetAccessTokenResponse) String() string { return proto.CompactTextString(m) }
+func (*GetAccessTokenResponse) ProtoMessage()    {}
+func (*GetAccessTokenResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{9}
+}
+func (m *GetAccessTokenResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetAccessTokenResponse.Unmarshal(m, b)
+}
+func (m *GetAccessTokenResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetAccessTokenResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetAccessTokenResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetAccessTokenResponse.Merge(dst, src)
+}
+func (m *GetAccessTokenResponse) XXX_Size() int {
+        return xxx_messageInfo_GetAccessTokenResponse.Size(m)
+}
+func (m *GetAccessTokenResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetAccessTokenResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetAccessTokenResponse proto.InternalMessageInfo
+
+func (m *GetAccessTokenResponse) GetAccessToken() string {
+        if m != nil && m.AccessToken != nil {
+                return *m.AccessToken
+        }
+        return ""
+}
+
+func (m *GetAccessTokenResponse) GetExpirationTime() int64 {
+        if m != nil && m.ExpirationTime != nil {
+                return *m.ExpirationTime
+        }
+        return 0
+}
+
+type GetDefaultGcsBucketNameRequest struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetDefaultGcsBucketNameRequest) Reset()         { *m = GetDefaultGcsBucketNameRequest{} }
+func (m *GetDefaultGcsBucketNameRequest) String() string { return proto.CompactTextString(m) }
+func (*GetDefaultGcsBucketNameRequest) ProtoMessage()    {}
+func (*GetDefaultGcsBucketNameRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{10}
+}
+func (m *GetDefaultGcsBucketNameRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetDefaultGcsBucketNameRequest.Unmarshal(m, b)
+}
+func (m *GetDefaultGcsBucketNameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetDefaultGcsBucketNameRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetDefaultGcsBucketNameRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetDefaultGcsBucketNameRequest.Merge(dst, src)
+}
+func (m *GetDefaultGcsBucketNameRequest) XXX_Size() int {
+        return xxx_messageInfo_GetDefaultGcsBucketNameRequest.Size(m)
+}
+func (m *GetDefaultGcsBucketNameRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetDefaultGcsBucketNameRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetDefaultGcsBucketNameRequest proto.InternalMessageInfo
+
+type GetDefaultGcsBucketNameResponse struct {
+        DefaultGcsBucketName *string  `protobuf:"bytes,1,opt,name=default_gcs_bucket_name,json=defaultGcsBucketName" json:"default_gcs_bucket_name,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetDefaultGcsBucketNameResponse) Reset()         { *m = GetDefaultGcsBucketNameResponse{} }
+func (m *GetDefaultGcsBucketNameResponse) String() string { return proto.CompactTextString(m) }
+func (*GetDefaultGcsBucketNameResponse) ProtoMessage()    {}
+func (*GetDefaultGcsBucketNameResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{11}
+}
+func (m *GetDefaultGcsBucketNameResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetDefaultGcsBucketNameResponse.Unmarshal(m, b)
+}
+func (m *GetDefaultGcsBucketNameResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetDefaultGcsBucketNameResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetDefaultGcsBucketNameResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetDefaultGcsBucketNameResponse.Merge(dst, src)
+}
+func (m *GetDefaultGcsBucketNameResponse) XXX_Size() int {
+        return xxx_messageInfo_GetDefaultGcsBucketNameResponse.Size(m)
+}
+func (m *GetDefaultGcsBucketNameResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetDefaultGcsBucketNameResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetDefaultGcsBucketNameResponse proto.InternalMessageInfo
+
+func (m *GetDefaultGcsBucketNameResponse) GetDefaultGcsBucketName() string {
+        if m != nil && m.DefaultGcsBucketName != nil {
+                return *m.DefaultGcsBucketName
+        }
+        return ""
+}
+
+func init() {
+        proto.RegisterType((*AppIdentityServiceError)(nil), "appengine.AppIdentityServiceError")
+        proto.RegisterType((*SignForAppRequest)(nil), "appengine.SignForAppRequest")
+        proto.RegisterType((*SignForAppResponse)(nil), "appengine.SignForAppResponse")
+        proto.RegisterType((*GetPublicCertificateForAppRequest)(nil), "appengine.GetPublicCertificateForAppRequest")
+        proto.RegisterType((*PublicCertificate)(nil), "appengine.PublicCertificate")
+        proto.RegisterType((*GetPublicCertificateForAppResponse)(nil), "appengine.GetPublicCertificateForAppResponse")
+        proto.RegisterType((*GetServiceAccountNameRequest)(nil), "appengine.GetServiceAccountNameRequest")
+        proto.RegisterType((*GetServiceAccountNameResponse)(nil), "appengine.GetServiceAccountNameResponse")
+        proto.RegisterType((*GetAccessTokenRequest)(nil), "appengine.GetAccessTokenRequest")
+        proto.RegisterType((*GetAccessTokenResponse)(nil), "appengine.GetAccessTokenResponse")
+        proto.RegisterType((*GetDefaultGcsBucketNameRequest)(nil), "appengine.GetDefaultGcsBucketNameRequest")
+        proto.RegisterType((*GetDefaultGcsBucketNameResponse)(nil), "appengine.GetDefaultGcsBucketNameResponse")
+}
+
+func init() {
+        proto.RegisterFile("google.golang.org/appengine/internal/app_identity/app_identity_service.proto", fileDescriptor_app_identity_service_08a6e3f74b04cfa4)
+}
+
+var fileDescriptor_app_identity_service_08a6e3f74b04cfa4 = []byte{
+        // 676 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x54, 0xdb, 0x6e, 0xda, 0x58,
+        0x14, 0x1d, 0x26, 0x1a, 0x31, 0x6c, 0x12, 0x62, 0xce, 0x90, 0xcb, 0x8c, 0x32, 0xb9, 0x78, 0x1e,
+        0x26, 0x0f, 0x15, 0x89, 0x2a, 0x45, 0x55, 0x1f, 0x8d, 0xed, 0x22, 0x54, 0x07, 0x53, 0x43, 0x9a,
+        0xa8, 0x2f, 0xa7, 0xce, 0x61, 0xc7, 0x3d, 0x02, 0x9f, 0xe3, 0xda, 0x87, 0x0a, 0x3e, 0xa2, 0x3f,
+        0xd2, 0x9f, 0xe8, 0x5b, 0xbf, 0xa5, 0x17, 0xb5, 0xdf, 0x50, 0xd9, 0x38, 0x5c, 0x92, 0x92, 0x37,
+        0xbc, 0xf6, 0x5a, 0xcb, 0x6b, 0x2f, 0x6d, 0x0c, 0x4e, 0x20, 0x65, 0x30, 0xc4, 0x7a, 0x20, 0x87,
+        0xbe, 0x08, 0xea, 0x32, 0x0e, 0x4e, 0xfc, 0x28, 0x42, 0x11, 0x70, 0x81, 0x27, 0x5c, 0x28, 0x8c,
+        0x85, 0x3f, 0x4c, 0x21, 0xca, 0xfb, 0x28, 0x14, 0x57, 0x93, 0xa5, 0x07, 0x9a, 0x60, 0xfc, 0x8e,
+        0x33, 0xac, 0x47, 0xb1, 0x54, 0x92, 0x94, 0x66, 0x5a, 0xfd, 0x53, 0x01, 0x76, 0x8c, 0x28, 0x6a,
+        0xe5, 0xc4, 0xee, 0x94, 0x67, 0xc7, 0xb1, 0x8c, 0xf5, 0x0f, 0x05, 0x28, 0x65, 0xbf, 0x4c, 0xd9,
+        0x47, 0x52, 0x86, 0x62, 0xf7, 0xc2, 0x34, 0xed, 0x6e, 0x57, 0xfb, 0x8d, 0x54, 0x61, 0xe3, 0xa2,
+        0xfd, 0xbc, 0xed, 0x5e, 0xb6, 0x69, 0xd7, 0x74, 0x3b, 0xb6, 0x56, 0x22, 0x7f, 0x41, 0xa5, 0xe1,
+        0xb8, 0x0d, 0xda, 0x73, 0x5d, 0xea, 0x18, 0x5e, 0xd3, 0xd6, 0x3e, 0x17, 0xc9, 0x36, 0x54, 0x2d,
+        0xdb, 0xb0, 0x9c, 0x56, 0xdb, 0xa6, 0xf6, 0x95, 0x69, 0xdb, 0x96, 0x6d, 0x69, 0x5f, 0x8a, 0xa4,
+        0x06, 0x9b, 0x6d, 0xb7, 0x47, 0x0d, 0xfa, 0xd2, 0x70, 0x5a, 0x16, 0x35, 0x3a, 0x1d, 0xed, 0x6b,
+        0x91, 0x90, 0xb9, 0xab, 0xed, 0x79, 0xae, 0xa7, 0x7d, 0x2b, 0x12, 0x0d, 0xca, 0x19, 0xd3, 0x71,
+        0xdc, 0x4b, 0xdb, 0xd2, 0xbe, 0xcf, 0xb4, 0xad, 0xf3, 0x8e, 0x63, 0x9f, 0xdb, 0xed, 0x9e, 0x6d,
+        0x69, 0x3f, 0x8a, 0xfa, 0x13, 0xa8, 0x76, 0x79, 0x20, 0x9e, 0xc9, 0xd8, 0x88, 0x22, 0x0f, 0xdf,
+        0x8e, 0x30, 0x51, 0x44, 0x87, 0x8d, 0xeb, 0x89, 0xc2, 0x84, 0x2a, 0x49, 0x13, 0x1e, 0x88, 0xdd,
+        0xc2, 0x61, 0xe1, 0x78, 0xdd, 0x2b, 0x67, 0x60, 0x4f, 0xa6, 0x02, 0xfd, 0x0a, 0xc8, 0xa2, 0x30,
+        0x89, 0xa4, 0x48, 0x90, 0xfc, 0x0d, 0x7f, 0x0e, 0x70, 0x42, 0x85, 0x1f, 0x62, 0x26, 0x2a, 0x79,
+        0xc5, 0x01, 0x4e, 0xda, 0x7e, 0x88, 0xe4, 0x7f, 0xd8, 0x4c, 0xbd, 0x7c, 0x35, 0x8a, 0x91, 0x66,
+        0x4e, 0xbb, 0xbf, 0x67, 0xb6, 0x95, 0x19, 0xdc, 0x48, 0x51, 0xfd, 0x3f, 0x38, 0x6a, 0xa2, 0xea,
+        0x8c, 0xae, 0x87, 0x9c, 0x99, 0x18, 0x2b, 0x7e, 0xc3, 0x99, 0xaf, 0x70, 0x29, 0xa2, 0xfe, 0x1a,
+        0xaa, 0xf7, 0x18, 0x0f, 0xbd, 0xfd, 0x14, 0x6a, 0xe3, 0xb3, 0xd3, 0xa7, 0x94, 0xcd, 0xe9, 0x34,
+        0xc2, 0x30, 0x8b, 0x50, 0xf2, 0x48, 0x3a, 0x5b, 0x70, 0xea, 0x60, 0xa8, 0x7f, 0x2c, 0x80, 0xfe,
+        0x50, 0x8e, 0x7c, 0xe3, 0x1e, 0xec, 0x44, 0x19, 0x65, 0xc9, 0x7a, 0xc8, 0x13, 0xb5, 0x5b, 0x38,
+        0x5c, 0x3b, 0x2e, 0x3f, 0xde, 0xab, 0xcf, 0xce, 0xa6, 0x7e, 0xcf, 0xcc, 0xdb, 0x8a, 0xee, 0x42,
+        0x0e, 0x4f, 0x14, 0x31, 0xe1, 0x20, 0xf4, 0xc7, 0x94, 0x0d, 0x39, 0x0a, 0x45, 0x99, 0xcf, 0xde,
+        0x20, 0x55, 0x3c, 0x44, 0xca, 0x05, 0x4d, 0x90, 0x49, 0xd1, 0xcf, 0x92, 0xaf, 0x79, 0xff, 0x84,
+        0xfe, 0xd8, 0xcc, 0x58, 0x66, 0x4a, 0xea, 0xf1, 0x10, 0x5b, 0xa2, 0x9b, 0x31, 0xf4, 0x7d, 0xd8,
+        0x6b, 0xa2, 0xca, 0x6f, 0xd3, 0x60, 0x4c, 0x8e, 0x84, 0x4a, 0xcb, 0xb8, 0xed, 0xf0, 0x05, 0xfc,
+        0xbb, 0x62, 0x9e, 0xef, 0x76, 0x0a, 0xb5, 0xfc, 0x1f, 0x40, 0xfd, 0xe9, 0x78, 0xb1, 0x5b, 0x92,
+        0xdc, 0x53, 0xea, 0xef, 0x0b, 0xb0, 0xd5, 0x44, 0x65, 0x30, 0x86, 0x49, 0xd2, 0x93, 0x03, 0x14,
+        0xb7, 0x37, 0x55, 0x83, 0x3f, 0x12, 0x26, 0x23, 0xcc, 0x5a, 0x29, 0x79, 0xd3, 0x07, 0xf2, 0x08,
+        0xc8, 0xdd, 0x37, 0xf0, 0xdb, 0xd5, 0xb4, 0x65, 0xff, 0x56, 0x7f, 0x65, 0x9e, 0xb5, 0x95, 0x79,
+        0xfa, 0xb0, 0x7d, 0x37, 0x4e, 0xbe, 0xdb, 0x11, 0xac, 0xfb, 0x19, 0x4c, 0x55, 0x8a, 0xe7, 0x3b,
+        0x95, 0xfd, 0x39, 0x35, 0xbd, 0x58, 0x1c, 0x47, 0x3c, 0xf6, 0x15, 0x97, 0x22, 0xab, 0x3f, 0x4f,
+        0x56, 0x99, 0xc3, 0x69, 0xe1, 0xfa, 0x21, 0xec, 0x37, 0x51, 0x59, 0x78, 0xe3, 0x8f, 0x86, 0xaa,
+        0xc9, 0x92, 0xc6, 0x88, 0x0d, 0x70, 0xa9, 0xea, 0x2b, 0x38, 0x58, 0xc9, 0xc8, 0x03, 0x9d, 0xc1,
+        0x4e, 0x7f, 0x3a, 0xa7, 0x01, 0x4b, 0xe8, 0x75, 0xc6, 0x58, 0xec, 0xbb, 0xd6, 0xff, 0x85, 0xbc,
+        0x51, 0x79, 0xb5, 0xbe, 0xf8, 0xc9, 0xfa, 0x19, 0x00, 0x00, 0xff, 0xff, 0x37, 0x4c, 0x56, 0x38,
+        0xf3, 0x04, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.proto b/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.proto
new file mode 100644
index 0000000..19610ca
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.proto
@@ -0,0 +1,64 @@
+syntax = "proto2";
+option go_package = "app_identity";
+
+package appengine;
+
+message AppIdentityServiceError {
+  enum ErrorCode {
+    SUCCESS = 0;
+    UNKNOWN_SCOPE = 9;
+    BLOB_TOO_LARGE = 1000;
+    DEADLINE_EXCEEDED = 1001;
+    NOT_A_VALID_APP = 1002;
+    UNKNOWN_ERROR = 1003;
+    NOT_ALLOWED = 1005;
+    NOT_IMPLEMENTED = 1006;
+  }
+}
+
+message SignForAppRequest {
+  optional bytes bytes_to_sign = 1;
+}
+
+message SignForAppResponse {
+  optional string key_name = 1;
+  optional bytes signature_bytes = 2;
+}
+
+message GetPublicCertificateForAppRequest {
+}
+
+message PublicCertificate {
+  optional string key_name = 1;
+  optional string x509_certificate_pem = 2;
+}
+
+message GetPublicCertificateForAppResponse {
+  repeated PublicCertificate public_certificate_list = 1;
+  optional int64 max_client_cache_time_in_second = 2;
+}
+
+message GetServiceAccountNameRequest {
+}
+
+message GetServiceAccountNameResponse {
+  optional string service_account_name = 1;
+}
+
+message GetAccessTokenRequest {
+  repeated string scope = 1;
+  optional int64 service_account_id = 2;
+  optional string service_account_name = 3;
+}
+
+message GetAccessTokenResponse {
+  optional string access_token = 1;
+  optional int64 expiration_time = 2;
+}
+
+message GetDefaultGcsBucketNameRequest {
+}
+
+message GetDefaultGcsBucketNameResponse {
+  optional string default_gcs_bucket_name = 1;
+}
diff --git a/vendor/google.golang.org/appengine/internal/base/api_base.pb.go b/vendor/google.golang.org/appengine/internal/base/api_base.pb.go
new file mode 100644
index 0000000..db4777e
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/base/api_base.pb.go
@@ -0,0 +1,308 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google.golang.org/appengine/internal/base/api_base.proto
+
+package base
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// 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
+
+type StringProto struct {
+        Value                *string  `protobuf:"bytes,1,req,name=value" json:"value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *StringProto) Reset()         { *m = StringProto{} }
+func (m *StringProto) String() string { return proto.CompactTextString(m) }
+func (*StringProto) ProtoMessage()    {}
+func (*StringProto) Descriptor() ([]byte, []int) {
+        return fileDescriptor_api_base_9d49f8792e0c1140, []int{0}
+}
+func (m *StringProto) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_StringProto.Unmarshal(m, b)
+}
+func (m *StringProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_StringProto.Marshal(b, m, deterministic)
+}
+func (dst *StringProto) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_StringProto.Merge(dst, src)
+}
+func (m *StringProto) XXX_Size() int {
+        return xxx_messageInfo_StringProto.Size(m)
+}
+func (m *StringProto) XXX_DiscardUnknown() {
+        xxx_messageInfo_StringProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StringProto proto.InternalMessageInfo
+
+func (m *StringProto) GetValue() string {
+        if m != nil && m.Value != nil {
+                return *m.Value
+        }
+        return ""
+}
+
+type Integer32Proto struct {
+        Value                *int32   `protobuf:"varint,1,req,name=value" json:"value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Integer32Proto) Reset()         { *m = Integer32Proto{} }
+func (m *Integer32Proto) String() string { return proto.CompactTextString(m) }
+func (*Integer32Proto) ProtoMessage()    {}
+func (*Integer32Proto) Descriptor() ([]byte, []int) {
+        return fileDescriptor_api_base_9d49f8792e0c1140, []int{1}
+}
+func (m *Integer32Proto) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Integer32Proto.Unmarshal(m, b)
+}
+func (m *Integer32Proto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Integer32Proto.Marshal(b, m, deterministic)
+}
+func (dst *Integer32Proto) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Integer32Proto.Merge(dst, src)
+}
+func (m *Integer32Proto) XXX_Size() int {
+        return xxx_messageInfo_Integer32Proto.Size(m)
+}
+func (m *Integer32Proto) XXX_DiscardUnknown() {
+        xxx_messageInfo_Integer32Proto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Integer32Proto proto.InternalMessageInfo
+
+func (m *Integer32Proto) GetValue() int32 {
+        if m != nil && m.Value != nil {
+                return *m.Value
+        }
+        return 0
+}
+
+type Integer64Proto struct {
+        Value                *int64   `protobuf:"varint,1,req,name=value" json:"value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Integer64Proto) Reset()         { *m = Integer64Proto{} }
+func (m *Integer64Proto) String() string { return proto.CompactTextString(m) }
+func (*Integer64Proto) ProtoMessage()    {}
+func (*Integer64Proto) Descriptor() ([]byte, []int) {
+        return fileDescriptor_api_base_9d49f8792e0c1140, []int{2}
+}
+func (m *Integer64Proto) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Integer64Proto.Unmarshal(m, b)
+}
+func (m *Integer64Proto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Integer64Proto.Marshal(b, m, deterministic)
+}
+func (dst *Integer64Proto) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Integer64Proto.Merge(dst, src)
+}
+func (m *Integer64Proto) XXX_Size() int {
+        return xxx_messageInfo_Integer64Proto.Size(m)
+}
+func (m *Integer64Proto) XXX_DiscardUnknown() {
+        xxx_messageInfo_Integer64Proto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Integer64Proto proto.InternalMessageInfo
+
+func (m *Integer64Proto) GetValue() int64 {
+        if m != nil && m.Value != nil {
+                return *m.Value
+        }
+        return 0
+}
+
+type BoolProto struct {
+        Value                *bool    `protobuf:"varint,1,req,name=value" json:"value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *BoolProto) Reset()         { *m = BoolProto{} }
+func (m *BoolProto) String() string { return proto.CompactTextString(m) }
+func (*BoolProto) ProtoMessage()    {}
+func (*BoolProto) Descriptor() ([]byte, []int) {
+        return fileDescriptor_api_base_9d49f8792e0c1140, []int{3}
+}
+func (m *BoolProto) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_BoolProto.Unmarshal(m, b)
+}
+func (m *BoolProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_BoolProto.Marshal(b, m, deterministic)
+}
+func (dst *BoolProto) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_BoolProto.Merge(dst, src)
+}
+func (m *BoolProto) XXX_Size() int {
+        return xxx_messageInfo_BoolProto.Size(m)
+}
+func (m *BoolProto) XXX_DiscardUnknown() {
+        xxx_messageInfo_BoolProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BoolProto proto.InternalMessageInfo
+
+func (m *BoolProto) GetValue() bool {
+        if m != nil && m.Value != nil {
+                return *m.Value
+        }
+        return false
+}
+
+type DoubleProto struct {
+        Value                *float64 `protobuf:"fixed64,1,req,name=value" json:"value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *DoubleProto) Reset()         { *m = DoubleProto{} }
+func (m *DoubleProto) String() string { return proto.CompactTextString(m) }
+func (*DoubleProto) ProtoMessage()    {}
+func (*DoubleProto) Descriptor() ([]byte, []int) {
+        return fileDescriptor_api_base_9d49f8792e0c1140, []int{4}
+}
+func (m *DoubleProto) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_DoubleProto.Unmarshal(m, b)
+}
+func (m *DoubleProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_DoubleProto.Marshal(b, m, deterministic)
+}
+func (dst *DoubleProto) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_DoubleProto.Merge(dst, src)
+}
+func (m *DoubleProto) XXX_Size() int {
+        return xxx_messageInfo_DoubleProto.Size(m)
+}
+func (m *DoubleProto) XXX_DiscardUnknown() {
+        xxx_messageInfo_DoubleProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DoubleProto proto.InternalMessageInfo
+
+func (m *DoubleProto) GetValue() float64 {
+        if m != nil && m.Value != nil {
+                return *m.Value
+        }
+        return 0
+}
+
+type BytesProto struct {
+        Value                []byte   `protobuf:"bytes,1,req,name=value" json:"value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *BytesProto) Reset()         { *m = BytesProto{} }
+func (m *BytesProto) String() string { return proto.CompactTextString(m) }
+func (*BytesProto) ProtoMessage()    {}
+func (*BytesProto) Descriptor() ([]byte, []int) {
+        return fileDescriptor_api_base_9d49f8792e0c1140, []int{5}
+}
+func (m *BytesProto) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_BytesProto.Unmarshal(m, b)
+}
+func (m *BytesProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_BytesProto.Marshal(b, m, deterministic)
+}
+func (dst *BytesProto) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_BytesProto.Merge(dst, src)
+}
+func (m *BytesProto) XXX_Size() int {
+        return xxx_messageInfo_BytesProto.Size(m)
+}
+func (m *BytesProto) XXX_DiscardUnknown() {
+        xxx_messageInfo_BytesProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BytesProto proto.InternalMessageInfo
+
+func (m *BytesProto) GetValue() []byte {
+        if m != nil {
+                return m.Value
+        }
+        return nil
+}
+
+type VoidProto struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *VoidProto) Reset()         { *m = VoidProto{} }
+func (m *VoidProto) String() string { return proto.CompactTextString(m) }
+func (*VoidProto) ProtoMessage()    {}
+func (*VoidProto) Descriptor() ([]byte, []int) {
+        return fileDescriptor_api_base_9d49f8792e0c1140, []int{6}
+}
+func (m *VoidProto) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_VoidProto.Unmarshal(m, b)
+}
+func (m *VoidProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_VoidProto.Marshal(b, m, deterministic)
+}
+func (dst *VoidProto) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_VoidProto.Merge(dst, src)
+}
+func (m *VoidProto) XXX_Size() int {
+        return xxx_messageInfo_VoidProto.Size(m)
+}
+func (m *VoidProto) XXX_DiscardUnknown() {
+        xxx_messageInfo_VoidProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_VoidProto proto.InternalMessageInfo
+
+func init() {
+        proto.RegisterType((*StringProto)(nil), "appengine.base.StringProto")
+        proto.RegisterType((*Integer32Proto)(nil), "appengine.base.Integer32Proto")
+        proto.RegisterType((*Integer64Proto)(nil), "appengine.base.Integer64Proto")
+        proto.RegisterType((*BoolProto)(nil), "appengine.base.BoolProto")
+        proto.RegisterType((*DoubleProto)(nil), "appengine.base.DoubleProto")
+        proto.RegisterType((*BytesProto)(nil), "appengine.base.BytesProto")
+        proto.RegisterType((*VoidProto)(nil), "appengine.base.VoidProto")
+}
+
+func init() {
+        proto.RegisterFile("google.golang.org/appengine/internal/base/api_base.proto", fileDescriptor_api_base_9d49f8792e0c1140)
+}
+
+var fileDescriptor_api_base_9d49f8792e0c1140 = []byte{
+        // 199 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0xcf, 0x3f, 0x4b, 0xc6, 0x30,
+        0x10, 0x06, 0x70, 0x5a, 0xad, 0xb4, 0x57, 0xe9, 0x20, 0x0e, 0x1d, 0xb5, 0x05, 0x71, 0x4a, 0x40,
+        0x45, 0x9c, 0x83, 0x8b, 0x9b, 0x28, 0x38, 0xb8, 0x48, 0x8a, 0xc7, 0x11, 0x08, 0xb9, 0x90, 0xa6,
+        0x82, 0xdf, 0x5e, 0xda, 0xd2, 0xfa, 0xc2, 0x9b, 0xed, 0xfe, 0xfc, 0xe0, 0xe1, 0x81, 0x27, 0x62,
+        0x26, 0x8b, 0x82, 0xd8, 0x6a, 0x47, 0x82, 0x03, 0x49, 0xed, 0x3d, 0x3a, 0x32, 0x0e, 0xa5, 0x71,
+        0x11, 0x83, 0xd3, 0x56, 0x0e, 0x7a, 0x44, 0xa9, 0xbd, 0xf9, 0x9a, 0x07, 0xe1, 0x03, 0x47, 0xbe,
+        0x68, 0x76, 0x27, 0xe6, 0x6b, 0xd7, 0x43, 0xfd, 0x1e, 0x83, 0x71, 0xf4, 0xba, 0xbc, 0x2f, 0xa1,
+        0xf8, 0xd1, 0x76, 0xc2, 0x36, 0xbb, 0xca, 0x6f, 0xab, 0xb7, 0x75, 0xe9, 0x6e, 0xa0, 0x79, 0x71,
+        0x11, 0x09, 0xc3, 0xfd, 0x5d, 0xc2, 0x15, 0xc7, 0xee, 0xf1, 0x21, 0xe1, 0x4e, 0x36, 0x77, 0x0d,
+        0x95, 0x62, 0xb6, 0x09, 0x52, 0x6e, 0xa4, 0x87, 0xfa, 0x99, 0xa7, 0xc1, 0x62, 0x02, 0x65, 0xff,
+        0x79, 0xa0, 0x7e, 0x23, 0x8e, 0xab, 0x69, 0x0f, 0xcd, 0xb9, 0xca, 0xcb, 0xdd, 0xd5, 0x50, 0x7d,
+        0xb0, 0xf9, 0x5e, 0x98, 0x3a, 0xfb, 0x3c, 0x9d, 0x9b, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0xba,
+        0x37, 0x25, 0xea, 0x44, 0x01, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/appengine/internal/base/api_base.proto b/vendor/google.golang.org/appengine/internal/base/api_base.proto
new file mode 100644
index 0000000..56cd7a3
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/base/api_base.proto
@@ -0,0 +1,33 @@
+// Built-in base types for API calls. Primarily useful as return types.
+
+syntax = "proto2";
+option go_package = "base";
+
+package appengine.base;
+
+message StringProto {
+  required string value = 1;
+}
+
+message Integer32Proto {
+  required int32 value = 1;
+}
+
+message Integer64Proto {
+  required int64 value = 1;
+}
+
+message BoolProto {
+  required bool value = 1;
+}
+
+message DoubleProto {
+  required double value = 1;
+}
+
+message BytesProto {
+  required bytes value = 1 [ctype=CORD];
+}
+
+message VoidProto {
+}
diff --git a/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.pb.go b/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.pb.go
new file mode 100644
index 0000000..2fb7482
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.pb.go
@@ -0,0 +1,4367 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google.golang.org/appengine/internal/datastore/datastore_v3.proto
+
+package datastore
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// 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
+
+type Property_Meaning int32
+
+const (
+        Property_NO_MEANING       Property_Meaning = 0
+        Property_BLOB             Property_Meaning = 14
+        Property_TEXT             Property_Meaning = 15
+        Property_BYTESTRING       Property_Meaning = 16
+        Property_ATOM_CATEGORY    Property_Meaning = 1
+        Property_ATOM_LINK        Property_Meaning = 2
+        Property_ATOM_TITLE       Property_Meaning = 3
+        Property_ATOM_CONTENT     Property_Meaning = 4
+        Property_ATOM_SUMMARY     Property_Meaning = 5
+        Property_ATOM_AUTHOR      Property_Meaning = 6
+        Property_GD_WHEN          Property_Meaning = 7
+        Property_GD_EMAIL         Property_Meaning = 8
+        Property_GEORSS_POINT     Property_Meaning = 9
+        Property_GD_IM            Property_Meaning = 10
+        Property_GD_PHONENUMBER   Property_Meaning = 11
+        Property_GD_POSTALADDRESS Property_Meaning = 12
+        Property_GD_RATING        Property_Meaning = 13
+        Property_BLOBKEY          Property_Meaning = 17
+        Property_ENTITY_PROTO     Property_Meaning = 19
+        Property_INDEX_VALUE      Property_Meaning = 18
+)
+
+var Property_Meaning_name = map[int32]string{
+        0:  "NO_MEANING",
+        14: "BLOB",
+        15: "TEXT",
+        16: "BYTESTRING",
+        1:  "ATOM_CATEGORY",
+        2:  "ATOM_LINK",
+        3:  "ATOM_TITLE",
+        4:  "ATOM_CONTENT",
+        5:  "ATOM_SUMMARY",
+        6:  "ATOM_AUTHOR",
+        7:  "GD_WHEN",
+        8:  "GD_EMAIL",
+        9:  "GEORSS_POINT",
+        10: "GD_IM",
+        11: "GD_PHONENUMBER",
+        12: "GD_POSTALADDRESS",
+        13: "GD_RATING",
+        17: "BLOBKEY",
+        19: "ENTITY_PROTO",
+        18: "INDEX_VALUE",
+}
+var Property_Meaning_value = map[string]int32{
+        "NO_MEANING":       0,
+        "BLOB":             14,
+        "TEXT":             15,
+        "BYTESTRING":       16,
+        "ATOM_CATEGORY":    1,
+        "ATOM_LINK":        2,
+        "ATOM_TITLE":       3,
+        "ATOM_CONTENT":     4,
+        "ATOM_SUMMARY":     5,
+        "ATOM_AUTHOR":      6,
+        "GD_WHEN":          7,
+        "GD_EMAIL":         8,
+        "GEORSS_POINT":     9,
+        "GD_IM":            10,
+        "GD_PHONENUMBER":   11,
+        "GD_POSTALADDRESS": 12,
+        "GD_RATING":        13,
+        "BLOBKEY":          17,
+        "ENTITY_PROTO":     19,
+        "INDEX_VALUE":      18,
+}
+
+func (x Property_Meaning) Enum() *Property_Meaning {
+        p := new(Property_Meaning)
+        *p = x
+        return p
+}
+func (x Property_Meaning) String() string {
+        return proto.EnumName(Property_Meaning_name, int32(x))
+}
+func (x *Property_Meaning) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(Property_Meaning_value, data, "Property_Meaning")
+        if err != nil {
+                return err
+        }
+        *x = Property_Meaning(value)
+        return nil
+}
+func (Property_Meaning) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{2, 0}
+}
+
+type Property_FtsTokenizationOption int32
+
+const (
+        Property_HTML Property_FtsTokenizationOption = 1
+        Property_ATOM Property_FtsTokenizationOption = 2
+)
+
+var Property_FtsTokenizationOption_name = map[int32]string{
+        1: "HTML",
+        2: "ATOM",
+}
+var Property_FtsTokenizationOption_value = map[string]int32{
+        "HTML": 1,
+        "ATOM": 2,
+}
+
+func (x Property_FtsTokenizationOption) Enum() *Property_FtsTokenizationOption {
+        p := new(Property_FtsTokenizationOption)
+        *p = x
+        return p
+}
+func (x Property_FtsTokenizationOption) String() string {
+        return proto.EnumName(Property_FtsTokenizationOption_name, int32(x))
+}
+func (x *Property_FtsTokenizationOption) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(Property_FtsTokenizationOption_value, data, "Property_FtsTokenizationOption")
+        if err != nil {
+                return err
+        }
+        *x = Property_FtsTokenizationOption(value)
+        return nil
+}
+func (Property_FtsTokenizationOption) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{2, 1}
+}
+
+type EntityProto_Kind int32
+
+const (
+        EntityProto_GD_CONTACT EntityProto_Kind = 1
+        EntityProto_GD_EVENT   EntityProto_Kind = 2
+        EntityProto_GD_MESSAGE EntityProto_Kind = 3
+)
+
+var EntityProto_Kind_name = map[int32]string{
+        1: "GD_CONTACT",
+        2: "GD_EVENT",
+        3: "GD_MESSAGE",
+}
+var EntityProto_Kind_value = map[string]int32{
+        "GD_CONTACT": 1,
+        "GD_EVENT":   2,
+        "GD_MESSAGE": 3,
+}
+
+func (x EntityProto_Kind) Enum() *EntityProto_Kind {
+        p := new(EntityProto_Kind)
+        *p = x
+        return p
+}
+func (x EntityProto_Kind) String() string {
+        return proto.EnumName(EntityProto_Kind_name, int32(x))
+}
+func (x *EntityProto_Kind) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(EntityProto_Kind_value, data, "EntityProto_Kind")
+        if err != nil {
+                return err
+        }
+        *x = EntityProto_Kind(value)
+        return nil
+}
+func (EntityProto_Kind) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{6, 0}
+}
+
+type Index_Property_Direction int32
+
+const (
+        Index_Property_ASCENDING  Index_Property_Direction = 1
+        Index_Property_DESCENDING Index_Property_Direction = 2
+)
+
+var Index_Property_Direction_name = map[int32]string{
+        1: "ASCENDING",
+        2: "DESCENDING",
+}
+var Index_Property_Direction_value = map[string]int32{
+        "ASCENDING":  1,
+        "DESCENDING": 2,
+}
+
+func (x Index_Property_Direction) Enum() *Index_Property_Direction {
+        p := new(Index_Property_Direction)
+        *p = x
+        return p
+}
+func (x Index_Property_Direction) String() string {
+        return proto.EnumName(Index_Property_Direction_name, int32(x))
+}
+func (x *Index_Property_Direction) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(Index_Property_Direction_value, data, "Index_Property_Direction")
+        if err != nil {
+                return err
+        }
+        *x = Index_Property_Direction(value)
+        return nil
+}
+func (Index_Property_Direction) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{8, 0, 0}
+}
+
+type CompositeIndex_State int32
+
+const (
+        CompositeIndex_WRITE_ONLY CompositeIndex_State = 1
+        CompositeIndex_READ_WRITE CompositeIndex_State = 2
+        CompositeIndex_DELETED    CompositeIndex_State = 3
+        CompositeIndex_ERROR      CompositeIndex_State = 4
+)
+
+var CompositeIndex_State_name = map[int32]string{
+        1: "WRITE_ONLY",
+        2: "READ_WRITE",
+        3: "DELETED",
+        4: "ERROR",
+}
+var CompositeIndex_State_value = map[string]int32{
+        "WRITE_ONLY": 1,
+        "READ_WRITE": 2,
+        "DELETED":    3,
+        "ERROR":      4,
+}
+
+func (x CompositeIndex_State) Enum() *CompositeIndex_State {
+        p := new(CompositeIndex_State)
+        *p = x
+        return p
+}
+func (x CompositeIndex_State) String() string {
+        return proto.EnumName(CompositeIndex_State_name, int32(x))
+}
+func (x *CompositeIndex_State) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(CompositeIndex_State_value, data, "CompositeIndex_State")
+        if err != nil {
+                return err
+        }
+        *x = CompositeIndex_State(value)
+        return nil
+}
+func (CompositeIndex_State) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{9, 0}
+}
+
+type Snapshot_Status int32
+
+const (
+        Snapshot_INACTIVE Snapshot_Status = 0
+        Snapshot_ACTIVE   Snapshot_Status = 1
+)
+
+var Snapshot_Status_name = map[int32]string{
+        0: "INACTIVE",
+        1: "ACTIVE",
+}
+var Snapshot_Status_value = map[string]int32{
+        "INACTIVE": 0,
+        "ACTIVE":   1,
+}
+
+func (x Snapshot_Status) Enum() *Snapshot_Status {
+        p := new(Snapshot_Status)
+        *p = x
+        return p
+}
+func (x Snapshot_Status) String() string {
+        return proto.EnumName(Snapshot_Status_name, int32(x))
+}
+func (x *Snapshot_Status) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(Snapshot_Status_value, data, "Snapshot_Status")
+        if err != nil {
+                return err
+        }
+        *x = Snapshot_Status(value)
+        return nil
+}
+func (Snapshot_Status) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{12, 0}
+}
+
+type Query_Hint int32
+
+const (
+        Query_ORDER_FIRST    Query_Hint = 1
+        Query_ANCESTOR_FIRST Query_Hint = 2
+        Query_FILTER_FIRST   Query_Hint = 3
+)
+
+var Query_Hint_name = map[int32]string{
+        1: "ORDER_FIRST",
+        2: "ANCESTOR_FIRST",
+        3: "FILTER_FIRST",
+}
+var Query_Hint_value = map[string]int32{
+        "ORDER_FIRST":    1,
+        "ANCESTOR_FIRST": 2,
+        "FILTER_FIRST":   3,
+}
+
+func (x Query_Hint) Enum() *Query_Hint {
+        p := new(Query_Hint)
+        *p = x
+        return p
+}
+func (x Query_Hint) String() string {
+        return proto.EnumName(Query_Hint_name, int32(x))
+}
+func (x *Query_Hint) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(Query_Hint_value, data, "Query_Hint")
+        if err != nil {
+                return err
+        }
+        *x = Query_Hint(value)
+        return nil
+}
+func (Query_Hint) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 0}
+}
+
+type Query_Filter_Operator int32
+
+const (
+        Query_Filter_LESS_THAN             Query_Filter_Operator = 1
+        Query_Filter_LESS_THAN_OR_EQUAL    Query_Filter_Operator = 2
+        Query_Filter_GREATER_THAN          Query_Filter_Operator = 3
+        Query_Filter_GREATER_THAN_OR_EQUAL Query_Filter_Operator = 4
+        Query_Filter_EQUAL                 Query_Filter_Operator = 5
+        Query_Filter_IN                    Query_Filter_Operator = 6
+        Query_Filter_EXISTS                Query_Filter_Operator = 7
+)
+
+var Query_Filter_Operator_name = map[int32]string{
+        1: "LESS_THAN",
+        2: "LESS_THAN_OR_EQUAL",
+        3: "GREATER_THAN",
+        4: "GREATER_THAN_OR_EQUAL",
+        5: "EQUAL",
+        6: "IN",
+        7: "EXISTS",
+}
+var Query_Filter_Operator_value = map[string]int32{
+        "LESS_THAN":             1,
+        "LESS_THAN_OR_EQUAL":    2,
+        "GREATER_THAN":          3,
+        "GREATER_THAN_OR_EQUAL": 4,
+        "EQUAL":                 5,
+        "IN":                    6,
+        "EXISTS":                7,
+}
+
+func (x Query_Filter_Operator) Enum() *Query_Filter_Operator {
+        p := new(Query_Filter_Operator)
+        *p = x
+        return p
+}
+func (x Query_Filter_Operator) String() string {
+        return proto.EnumName(Query_Filter_Operator_name, int32(x))
+}
+func (x *Query_Filter_Operator) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(Query_Filter_Operator_value, data, "Query_Filter_Operator")
+        if err != nil {
+                return err
+        }
+        *x = Query_Filter_Operator(value)
+        return nil
+}
+func (Query_Filter_Operator) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 0, 0}
+}
+
+type Query_Order_Direction int32
+
+const (
+        Query_Order_ASCENDING  Query_Order_Direction = 1
+        Query_Order_DESCENDING Query_Order_Direction = 2
+)
+
+var Query_Order_Direction_name = map[int32]string{
+        1: "ASCENDING",
+        2: "DESCENDING",
+}
+var Query_Order_Direction_value = map[string]int32{
+        "ASCENDING":  1,
+        "DESCENDING": 2,
+}
+
+func (x Query_Order_Direction) Enum() *Query_Order_Direction {
+        p := new(Query_Order_Direction)
+        *p = x
+        return p
+}
+func (x Query_Order_Direction) String() string {
+        return proto.EnumName(Query_Order_Direction_name, int32(x))
+}
+func (x *Query_Order_Direction) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(Query_Order_Direction_value, data, "Query_Order_Direction")
+        if err != nil {
+                return err
+        }
+        *x = Query_Order_Direction(value)
+        return nil
+}
+func (Query_Order_Direction) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 1, 0}
+}
+
+type Error_ErrorCode int32
+
+const (
+        Error_BAD_REQUEST                  Error_ErrorCode = 1
+        Error_CONCURRENT_TRANSACTION       Error_ErrorCode = 2
+        Error_INTERNAL_ERROR               Error_ErrorCode = 3
+        Error_NEED_INDEX                   Error_ErrorCode = 4
+        Error_TIMEOUT                      Error_ErrorCode = 5
+        Error_PERMISSION_DENIED            Error_ErrorCode = 6
+        Error_BIGTABLE_ERROR               Error_ErrorCode = 7
+        Error_COMMITTED_BUT_STILL_APPLYING Error_ErrorCode = 8
+        Error_CAPABILITY_DISABLED          Error_ErrorCode = 9
+        Error_TRY_ALTERNATE_BACKEND        Error_ErrorCode = 10
+        Error_SAFE_TIME_TOO_OLD            Error_ErrorCode = 11
+)
+
+var Error_ErrorCode_name = map[int32]string{
+        1:  "BAD_REQUEST",
+        2:  "CONCURRENT_TRANSACTION",
+        3:  "INTERNAL_ERROR",
+        4:  "NEED_INDEX",
+        5:  "TIMEOUT",
+        6:  "PERMISSION_DENIED",
+        7:  "BIGTABLE_ERROR",
+        8:  "COMMITTED_BUT_STILL_APPLYING",
+        9:  "CAPABILITY_DISABLED",
+        10: "TRY_ALTERNATE_BACKEND",
+        11: "SAFE_TIME_TOO_OLD",
+}
+var Error_ErrorCode_value = map[string]int32{
+        "BAD_REQUEST":                  1,
+        "CONCURRENT_TRANSACTION":       2,
+        "INTERNAL_ERROR":               3,
+        "NEED_INDEX":                   4,
+        "TIMEOUT":                      5,
+        "PERMISSION_DENIED":            6,
+        "BIGTABLE_ERROR":               7,
+        "COMMITTED_BUT_STILL_APPLYING": 8,
+        "CAPABILITY_DISABLED":          9,
+        "TRY_ALTERNATE_BACKEND":        10,
+        "SAFE_TIME_TOO_OLD":            11,
+}
+
+func (x Error_ErrorCode) Enum() *Error_ErrorCode {
+        p := new(Error_ErrorCode)
+        *p = x
+        return p
+}
+func (x Error_ErrorCode) String() string {
+        return proto.EnumName(Error_ErrorCode_name, int32(x))
+}
+func (x *Error_ErrorCode) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(Error_ErrorCode_value, data, "Error_ErrorCode")
+        if err != nil {
+                return err
+        }
+        *x = Error_ErrorCode(value)
+        return nil
+}
+func (Error_ErrorCode) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{19, 0}
+}
+
+type PutRequest_AutoIdPolicy int32
+
+const (
+        PutRequest_CURRENT    PutRequest_AutoIdPolicy = 0
+        PutRequest_SEQUENTIAL PutRequest_AutoIdPolicy = 1
+)
+
+var PutRequest_AutoIdPolicy_name = map[int32]string{
+        0: "CURRENT",
+        1: "SEQUENTIAL",
+}
+var PutRequest_AutoIdPolicy_value = map[string]int32{
+        "CURRENT":    0,
+        "SEQUENTIAL": 1,
+}
+
+func (x PutRequest_AutoIdPolicy) Enum() *PutRequest_AutoIdPolicy {
+        p := new(PutRequest_AutoIdPolicy)
+        *p = x
+        return p
+}
+func (x PutRequest_AutoIdPolicy) String() string {
+        return proto.EnumName(PutRequest_AutoIdPolicy_name, int32(x))
+}
+func (x *PutRequest_AutoIdPolicy) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(PutRequest_AutoIdPolicy_value, data, "PutRequest_AutoIdPolicy")
+        if err != nil {
+                return err
+        }
+        *x = PutRequest_AutoIdPolicy(value)
+        return nil
+}
+func (PutRequest_AutoIdPolicy) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{23, 0}
+}
+
+type BeginTransactionRequest_TransactionMode int32
+
+const (
+        BeginTransactionRequest_UNKNOWN    BeginTransactionRequest_TransactionMode = 0
+        BeginTransactionRequest_READ_ONLY  BeginTransactionRequest_TransactionMode = 1
+        BeginTransactionRequest_READ_WRITE BeginTransactionRequest_TransactionMode = 2
+)
+
+var BeginTransactionRequest_TransactionMode_name = map[int32]string{
+        0: "UNKNOWN",
+        1: "READ_ONLY",
+        2: "READ_WRITE",
+}
+var BeginTransactionRequest_TransactionMode_value = map[string]int32{
+        "UNKNOWN":    0,
+        "READ_ONLY":  1,
+        "READ_WRITE": 2,
+}
+
+func (x BeginTransactionRequest_TransactionMode) Enum() *BeginTransactionRequest_TransactionMode {
+        p := new(BeginTransactionRequest_TransactionMode)
+        *p = x
+        return p
+}
+func (x BeginTransactionRequest_TransactionMode) String() string {
+        return proto.EnumName(BeginTransactionRequest_TransactionMode_name, int32(x))
+}
+func (x *BeginTransactionRequest_TransactionMode) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(BeginTransactionRequest_TransactionMode_value, data, "BeginTransactionRequest_TransactionMode")
+        if err != nil {
+                return err
+        }
+        *x = BeginTransactionRequest_TransactionMode(value)
+        return nil
+}
+func (BeginTransactionRequest_TransactionMode) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{36, 0}
+}
+
+type Action struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Action) Reset()         { *m = Action{} }
+func (m *Action) String() string { return proto.CompactTextString(m) }
+func (*Action) ProtoMessage()    {}
+func (*Action) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{0}
+}
+func (m *Action) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Action.Unmarshal(m, b)
+}
+func (m *Action) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Action.Marshal(b, m, deterministic)
+}
+func (dst *Action) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Action.Merge(dst, src)
+}
+func (m *Action) XXX_Size() int {
+        return xxx_messageInfo_Action.Size(m)
+}
+func (m *Action) XXX_DiscardUnknown() {
+        xxx_messageInfo_Action.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Action proto.InternalMessageInfo
+
+type PropertyValue struct {
+        Int64Value           *int64                        `protobuf:"varint,1,opt,name=int64Value" json:"int64Value,omitempty"`
+        BooleanValue         *bool                         `protobuf:"varint,2,opt,name=booleanValue" json:"booleanValue,omitempty"`
+        StringValue          *string                       `protobuf:"bytes,3,opt,name=stringValue" json:"stringValue,omitempty"`
+        DoubleValue          *float64                      `protobuf:"fixed64,4,opt,name=doubleValue" json:"doubleValue,omitempty"`
+        Pointvalue           *PropertyValue_PointValue     `protobuf:"group,5,opt,name=PointValue,json=pointvalue" json:"pointvalue,omitempty"`
+        Uservalue            *PropertyValue_UserValue      `protobuf:"group,8,opt,name=UserValue,json=uservalue" json:"uservalue,omitempty"`
+        Referencevalue       *PropertyValue_ReferenceValue `protobuf:"group,12,opt,name=ReferenceValue,json=referencevalue" json:"referencevalue,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
+        XXX_unrecognized     []byte                        `json:"-"`
+        XXX_sizecache        int32                         `json:"-"`
+}
+
+func (m *PropertyValue) Reset()         { *m = PropertyValue{} }
+func (m *PropertyValue) String() string { return proto.CompactTextString(m) }
+func (*PropertyValue) ProtoMessage()    {}
+func (*PropertyValue) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1}
+}
+func (m *PropertyValue) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_PropertyValue.Unmarshal(m, b)
+}
+func (m *PropertyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_PropertyValue.Marshal(b, m, deterministic)
+}
+func (dst *PropertyValue) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_PropertyValue.Merge(dst, src)
+}
+func (m *PropertyValue) XXX_Size() int {
+        return xxx_messageInfo_PropertyValue.Size(m)
+}
+func (m *PropertyValue) XXX_DiscardUnknown() {
+        xxx_messageInfo_PropertyValue.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PropertyValue proto.InternalMessageInfo
+
+func (m *PropertyValue) GetInt64Value() int64 {
+        if m != nil && m.Int64Value != nil {
+                return *m.Int64Value
+        }
+        return 0
+}
+
+func (m *PropertyValue) GetBooleanValue() bool {
+        if m != nil && m.BooleanValue != nil {
+                return *m.BooleanValue
+        }
+        return false
+}
+
+func (m *PropertyValue) GetStringValue() string {
+        if m != nil && m.StringValue != nil {
+                return *m.StringValue
+        }
+        return ""
+}
+
+func (m *PropertyValue) GetDoubleValue() float64 {
+        if m != nil && m.DoubleValue != nil {
+                return *m.DoubleValue
+        }
+        return 0
+}
+
+func (m *PropertyValue) GetPointvalue() *PropertyValue_PointValue {
+        if m != nil {
+                return m.Pointvalue
+        }
+        return nil
+}
+
+func (m *PropertyValue) GetUservalue() *PropertyValue_UserValue {
+        if m != nil {
+                return m.Uservalue
+        }
+        return nil
+}
+
+func (m *PropertyValue) GetReferencevalue() *PropertyValue_ReferenceValue {
+        if m != nil {
+                return m.Referencevalue
+        }
+        return nil
+}
+
+type PropertyValue_PointValue struct {
+        X                    *float64 `protobuf:"fixed64,6,req,name=x" json:"x,omitempty"`
+        Y                    *float64 `protobuf:"fixed64,7,req,name=y" json:"y,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PropertyValue_PointValue) Reset()         { *m = PropertyValue_PointValue{} }
+func (m *PropertyValue_PointValue) String() string { return proto.CompactTextString(m) }
+func (*PropertyValue_PointValue) ProtoMessage()    {}
+func (*PropertyValue_PointValue) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1, 0}
+}
+func (m *PropertyValue_PointValue) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_PropertyValue_PointValue.Unmarshal(m, b)
+}
+func (m *PropertyValue_PointValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_PropertyValue_PointValue.Marshal(b, m, deterministic)
+}
+func (dst *PropertyValue_PointValue) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_PropertyValue_PointValue.Merge(dst, src)
+}
+func (m *PropertyValue_PointValue) XXX_Size() int {
+        return xxx_messageInfo_PropertyValue_PointValue.Size(m)
+}
+func (m *PropertyValue_PointValue) XXX_DiscardUnknown() {
+        xxx_messageInfo_PropertyValue_PointValue.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PropertyValue_PointValue proto.InternalMessageInfo
+
+func (m *PropertyValue_PointValue) GetX() float64 {
+        if m != nil && m.X != nil {
+                return *m.X
+        }
+        return 0
+}
+
+func (m *PropertyValue_PointValue) GetY() float64 {
+        if m != nil && m.Y != nil {
+                return *m.Y
+        }
+        return 0
+}
+
+type PropertyValue_UserValue struct {
+        Email                *string  `protobuf:"bytes,9,req,name=email" json:"email,omitempty"`
+        AuthDomain           *string  `protobuf:"bytes,10,req,name=auth_domain,json=authDomain" json:"auth_domain,omitempty"`
+        Nickname             *string  `protobuf:"bytes,11,opt,name=nickname" json:"nickname,omitempty"`
+        FederatedIdentity    *string  `protobuf:"bytes,21,opt,name=federated_identity,json=federatedIdentity" json:"federated_identity,omitempty"`
+        FederatedProvider    *string  `protobuf:"bytes,22,opt,name=federated_provider,json=federatedProvider" json:"federated_provider,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PropertyValue_UserValue) Reset()         { *m = PropertyValue_UserValue{} }
+func (m *PropertyValue_UserValue) String() string { return proto.CompactTextString(m) }
+func (*PropertyValue_UserValue) ProtoMessage()    {}
+func (*PropertyValue_UserValue) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1, 1}
+}
+func (m *PropertyValue_UserValue) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_PropertyValue_UserValue.Unmarshal(m, b)
+}
+func (m *PropertyValue_UserValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_PropertyValue_UserValue.Marshal(b, m, deterministic)
+}
+func (dst *PropertyValue_UserValue) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_PropertyValue_UserValue.Merge(dst, src)
+}
+func (m *PropertyValue_UserValue) XXX_Size() int {
+        return xxx_messageInfo_PropertyValue_UserValue.Size(m)
+}
+func (m *PropertyValue_UserValue) XXX_DiscardUnknown() {
+        xxx_messageInfo_PropertyValue_UserValue.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PropertyValue_UserValue proto.InternalMessageInfo
+
+func (m *PropertyValue_UserValue) GetEmail() string {
+        if m != nil && m.Email != nil {
+                return *m.Email
+        }
+        return ""
+}
+
+func (m *PropertyValue_UserValue) GetAuthDomain() string {
+        if m != nil && m.AuthDomain != nil {
+                return *m.AuthDomain
+        }
+        return ""
+}
+
+func (m *PropertyValue_UserValue) GetNickname() string {
+        if m != nil && m.Nickname != nil {
+                return *m.Nickname
+        }
+        return ""
+}
+
+func (m *PropertyValue_UserValue) GetFederatedIdentity() string {
+        if m != nil && m.FederatedIdentity != nil {
+                return *m.FederatedIdentity
+        }
+        return ""
+}
+
+func (m *PropertyValue_UserValue) GetFederatedProvider() string {
+        if m != nil && m.FederatedProvider != nil {
+                return *m.FederatedProvider
+        }
+        return ""
+}
+
+type PropertyValue_ReferenceValue struct {
+        App                  *string                                     `protobuf:"bytes,13,req,name=app" json:"app,omitempty"`
+        NameSpace            *string                                     `protobuf:"bytes,20,opt,name=name_space,json=nameSpace" json:"name_space,omitempty"`
+        Pathelement          []*PropertyValue_ReferenceValue_PathElement `protobuf:"group,14,rep,name=PathElement,json=pathelement" json:"pathelement,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                                    `json:"-"`
+        XXX_unrecognized     []byte                                      `json:"-"`
+        XXX_sizecache        int32                                       `json:"-"`
+}
+
+func (m *PropertyValue_ReferenceValue) Reset()         { *m = PropertyValue_ReferenceValue{} }
+func (m *PropertyValue_ReferenceValue) String() string { return proto.CompactTextString(m) }
+func (*PropertyValue_ReferenceValue) ProtoMessage()    {}
+func (*PropertyValue_ReferenceValue) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1, 2}
+}
+func (m *PropertyValue_ReferenceValue) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_PropertyValue_ReferenceValue.Unmarshal(m, b)
+}
+func (m *PropertyValue_ReferenceValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_PropertyValue_ReferenceValue.Marshal(b, m, deterministic)
+}
+func (dst *PropertyValue_ReferenceValue) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_PropertyValue_ReferenceValue.Merge(dst, src)
+}
+func (m *PropertyValue_ReferenceValue) XXX_Size() int {
+        return xxx_messageInfo_PropertyValue_ReferenceValue.Size(m)
+}
+func (m *PropertyValue_ReferenceValue) XXX_DiscardUnknown() {
+        xxx_messageInfo_PropertyValue_ReferenceValue.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PropertyValue_ReferenceValue proto.InternalMessageInfo
+
+func (m *PropertyValue_ReferenceValue) GetApp() string {
+        if m != nil && m.App != nil {
+                return *m.App
+        }
+        return ""
+}
+
+func (m *PropertyValue_ReferenceValue) GetNameSpace() string {
+        if m != nil && m.NameSpace != nil {
+                return *m.NameSpace
+        }
+        return ""
+}
+
+func (m *PropertyValue_ReferenceValue) GetPathelement() []*PropertyValue_ReferenceValue_PathElement {
+        if m != nil {
+                return m.Pathelement
+        }
+        return nil
+}
+
+type PropertyValue_ReferenceValue_PathElement struct {
+        Type                 *string  `protobuf:"bytes,15,req,name=type" json:"type,omitempty"`
+        Id                   *int64   `protobuf:"varint,16,opt,name=id" json:"id,omitempty"`
+        Name                 *string  `protobuf:"bytes,17,opt,name=name" json:"name,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PropertyValue_ReferenceValue_PathElement) Reset() {
+        *m = PropertyValue_ReferenceValue_PathElement{}
+}
+func (m *PropertyValue_ReferenceValue_PathElement) String() string { return proto.CompactTextString(m) }
+func (*PropertyValue_ReferenceValue_PathElement) ProtoMessage()    {}
+func (*PropertyValue_ReferenceValue_PathElement) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1, 2, 0}
+}
+func (m *PropertyValue_ReferenceValue_PathElement) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.Unmarshal(m, b)
+}
+func (m *PropertyValue_ReferenceValue_PathElement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.Marshal(b, m, deterministic)
+}
+func (dst *PropertyValue_ReferenceValue_PathElement) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.Merge(dst, src)
+}
+func (m *PropertyValue_ReferenceValue_PathElement) XXX_Size() int {
+        return xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.Size(m)
+}
+func (m *PropertyValue_ReferenceValue_PathElement) XXX_DiscardUnknown() {
+        xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PropertyValue_ReferenceValue_PathElement proto.InternalMessageInfo
+
+func (m *PropertyValue_ReferenceValue_PathElement) GetType() string {
+        if m != nil && m.Type != nil {
+                return *m.Type
+        }
+        return ""
+}
+
+func (m *PropertyValue_ReferenceValue_PathElement) GetId() int64 {
+        if m != nil && m.Id != nil {
+                return *m.Id
+        }
+        return 0
+}
+
+func (m *PropertyValue_ReferenceValue_PathElement) GetName() string {
+        if m != nil && m.Name != nil {
+                return *m.Name
+        }
+        return ""
+}
+
+type Property struct {
+        Meaning               *Property_Meaning               `protobuf:"varint,1,opt,name=meaning,enum=appengine.Property_Meaning,def=0" json:"meaning,omitempty"`
+        MeaningUri            *string                         `protobuf:"bytes,2,opt,name=meaning_uri,json=meaningUri" json:"meaning_uri,omitempty"`
+        Name                  *string                         `protobuf:"bytes,3,req,name=name" json:"name,omitempty"`
+        Value                 *PropertyValue                  `protobuf:"bytes,5,req,name=value" json:"value,omitempty"`
+        Multiple              *bool                           `protobuf:"varint,4,req,name=multiple" json:"multiple,omitempty"`
+        Searchable            *bool                           `protobuf:"varint,6,opt,name=searchable,def=0" json:"searchable,omitempty"`
+        FtsTokenizationOption *Property_FtsTokenizationOption `protobuf:"varint,8,opt,name=fts_tokenization_option,json=ftsTokenizationOption,enum=appengine.Property_FtsTokenizationOption" json:"fts_tokenization_option,omitempty"`
+        Locale                *string                         `protobuf:"bytes,9,opt,name=locale,def=en" json:"locale,omitempty"`
+        XXX_NoUnkeyedLiteral  struct{}                        `json:"-"`
+        XXX_unrecognized      []byte                          `json:"-"`
+        XXX_sizecache         int32                           `json:"-"`
+}
+
+func (m *Property) Reset()         { *m = Property{} }
+func (m *Property) String() string { return proto.CompactTextString(m) }
+func (*Property) ProtoMessage()    {}
+func (*Property) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{2}
+}
+func (m *Property) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Property.Unmarshal(m, b)
+}
+func (m *Property) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Property.Marshal(b, m, deterministic)
+}
+func (dst *Property) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Property.Merge(dst, src)
+}
+func (m *Property) XXX_Size() int {
+        return xxx_messageInfo_Property.Size(m)
+}
+func (m *Property) XXX_DiscardUnknown() {
+        xxx_messageInfo_Property.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Property proto.InternalMessageInfo
+
+const Default_Property_Meaning Property_Meaning = Property_NO_MEANING
+const Default_Property_Searchable bool = false
+const Default_Property_Locale string = "en"
+
+func (m *Property) GetMeaning() Property_Meaning {
+        if m != nil && m.Meaning != nil {
+                return *m.Meaning
+        }
+        return Default_Property_Meaning
+}
+
+func (m *Property) GetMeaningUri() string {
+        if m != nil && m.MeaningUri != nil {
+                return *m.MeaningUri
+        }
+        return ""
+}
+
+func (m *Property) GetName() string {
+        if m != nil && m.Name != nil {
+                return *m.Name
+        }
+        return ""
+}
+
+func (m *Property) GetValue() *PropertyValue {
+        if m != nil {
+                return m.Value
+        }
+        return nil
+}
+
+func (m *Property) GetMultiple() bool {
+        if m != nil && m.Multiple != nil {
+                return *m.Multiple
+        }
+        return false
+}
+
+func (m *Property) GetSearchable() bool {
+        if m != nil && m.Searchable != nil {
+                return *m.Searchable
+        }
+        return Default_Property_Searchable
+}
+
+func (m *Property) GetFtsTokenizationOption() Property_FtsTokenizationOption {
+        if m != nil && m.FtsTokenizationOption != nil {
+                return *m.FtsTokenizationOption
+        }
+        return Property_HTML
+}
+
+func (m *Property) GetLocale() string {
+        if m != nil && m.Locale != nil {
+                return *m.Locale
+        }
+        return Default_Property_Locale
+}
+
+type Path struct {
+        Element              []*Path_Element `protobuf:"group,1,rep,name=Element,json=element" json:"element,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+        XXX_unrecognized     []byte          `json:"-"`
+        XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *Path) Reset()         { *m = Path{} }
+func (m *Path) String() string { return proto.CompactTextString(m) }
+func (*Path) ProtoMessage()    {}
+func (*Path) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{3}
+}
+func (m *Path) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Path.Unmarshal(m, b)
+}
+func (m *Path) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Path.Marshal(b, m, deterministic)
+}
+func (dst *Path) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Path.Merge(dst, src)
+}
+func (m *Path) XXX_Size() int {
+        return xxx_messageInfo_Path.Size(m)
+}
+func (m *Path) XXX_DiscardUnknown() {
+        xxx_messageInfo_Path.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Path proto.InternalMessageInfo
+
+func (m *Path) GetElement() []*Path_Element {
+        if m != nil {
+                return m.Element
+        }
+        return nil
+}
+
+type Path_Element struct {
+        Type                 *string  `protobuf:"bytes,2,req,name=type" json:"type,omitempty"`
+        Id                   *int64   `protobuf:"varint,3,opt,name=id" json:"id,omitempty"`
+        Name                 *string  `protobuf:"bytes,4,opt,name=name" json:"name,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Path_Element) Reset()         { *m = Path_Element{} }
+func (m *Path_Element) String() string { return proto.CompactTextString(m) }
+func (*Path_Element) ProtoMessage()    {}
+func (*Path_Element) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{3, 0}
+}
+func (m *Path_Element) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Path_Element.Unmarshal(m, b)
+}
+func (m *Path_Element) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Path_Element.Marshal(b, m, deterministic)
+}
+func (dst *Path_Element) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Path_Element.Merge(dst, src)
+}
+func (m *Path_Element) XXX_Size() int {
+        return xxx_messageInfo_Path_Element.Size(m)
+}
+func (m *Path_Element) XXX_DiscardUnknown() {
+        xxx_messageInfo_Path_Element.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Path_Element proto.InternalMessageInfo
+
+func (m *Path_Element) GetType() string {
+        if m != nil && m.Type != nil {
+                return *m.Type
+        }
+        return ""
+}
+
+func (m *Path_Element) GetId() int64 {
+        if m != nil && m.Id != nil {
+                return *m.Id
+        }
+        return 0
+}
+
+func (m *Path_Element) GetName() string {
+        if m != nil && m.Name != nil {
+                return *m.Name
+        }
+        return ""
+}
+
+type Reference struct {
+        App                  *string  `protobuf:"bytes,13,req,name=app" json:"app,omitempty"`
+        NameSpace            *string  `protobuf:"bytes,20,opt,name=name_space,json=nameSpace" json:"name_space,omitempty"`
+        Path                 *Path    `protobuf:"bytes,14,req,name=path" json:"path,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Reference) Reset()         { *m = Reference{} }
+func (m *Reference) String() string { return proto.CompactTextString(m) }
+func (*Reference) ProtoMessage()    {}
+func (*Reference) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{4}
+}
+func (m *Reference) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Reference.Unmarshal(m, b)
+}
+func (m *Reference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Reference.Marshal(b, m, deterministic)
+}
+func (dst *Reference) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Reference.Merge(dst, src)
+}
+func (m *Reference) XXX_Size() int {
+        return xxx_messageInfo_Reference.Size(m)
+}
+func (m *Reference) XXX_DiscardUnknown() {
+        xxx_messageInfo_Reference.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Reference proto.InternalMessageInfo
+
+func (m *Reference) GetApp() string {
+        if m != nil && m.App != nil {
+                return *m.App
+        }
+        return ""
+}
+
+func (m *Reference) GetNameSpace() string {
+        if m != nil && m.NameSpace != nil {
+                return *m.NameSpace
+        }
+        return ""
+}
+
+func (m *Reference) GetPath() *Path {
+        if m != nil {
+                return m.Path
+        }
+        return nil
+}
+
+type User struct {
+        Email                *string  `protobuf:"bytes,1,req,name=email" json:"email,omitempty"`
+        AuthDomain           *string  `protobuf:"bytes,2,req,name=auth_domain,json=authDomain" json:"auth_domain,omitempty"`
+        Nickname             *string  `protobuf:"bytes,3,opt,name=nickname" json:"nickname,omitempty"`
+        FederatedIdentity    *string  `protobuf:"bytes,6,opt,name=federated_identity,json=federatedIdentity" json:"federated_identity,omitempty"`
+        FederatedProvider    *string  `protobuf:"bytes,7,opt,name=federated_provider,json=federatedProvider" json:"federated_provider,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *User) Reset()         { *m = User{} }
+func (m *User) String() string { return proto.CompactTextString(m) }
+func (*User) ProtoMessage()    {}
+func (*User) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{5}
+}
+func (m *User) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_User.Unmarshal(m, b)
+}
+func (m *User) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_User.Marshal(b, m, deterministic)
+}
+func (dst *User) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_User.Merge(dst, src)
+}
+func (m *User) XXX_Size() int {
+        return xxx_messageInfo_User.Size(m)
+}
+func (m *User) XXX_DiscardUnknown() {
+        xxx_messageInfo_User.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_User proto.InternalMessageInfo
+
+func (m *User) GetEmail() string {
+        if m != nil && m.Email != nil {
+                return *m.Email
+        }
+        return ""
+}
+
+func (m *User) GetAuthDomain() string {
+        if m != nil && m.AuthDomain != nil {
+                return *m.AuthDomain
+        }
+        return ""
+}
+
+func (m *User) GetNickname() string {
+        if m != nil && m.Nickname != nil {
+                return *m.Nickname
+        }
+        return ""
+}
+
+func (m *User) GetFederatedIdentity() string {
+        if m != nil && m.FederatedIdentity != nil {
+                return *m.FederatedIdentity
+        }
+        return ""
+}
+
+func (m *User) GetFederatedProvider() string {
+        if m != nil && m.FederatedProvider != nil {
+                return *m.FederatedProvider
+        }
+        return ""
+}
+
+type EntityProto struct {
+        Key                  *Reference        `protobuf:"bytes,13,req,name=key" json:"key,omitempty"`
+        EntityGroup          *Path             `protobuf:"bytes,16,req,name=entity_group,json=entityGroup" json:"entity_group,omitempty"`
+        Owner                *User             `protobuf:"bytes,17,opt,name=owner" json:"owner,omitempty"`
+        Kind                 *EntityProto_Kind `protobuf:"varint,4,opt,name=kind,enum=appengine.EntityProto_Kind" json:"kind,omitempty"`
+        KindUri              *string           `protobuf:"bytes,5,opt,name=kind_uri,json=kindUri" json:"kind_uri,omitempty"`
+        Property             []*Property       `protobuf:"bytes,14,rep,name=property" json:"property,omitempty"`
+        RawProperty          []*Property       `protobuf:"bytes,15,rep,name=raw_property,json=rawProperty" json:"raw_property,omitempty"`
+        Rank                 *int32            `protobuf:"varint,18,opt,name=rank" json:"rank,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+        XXX_unrecognized     []byte            `json:"-"`
+        XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *EntityProto) Reset()         { *m = EntityProto{} }
+func (m *EntityProto) String() string { return proto.CompactTextString(m) }
+func (*EntityProto) ProtoMessage()    {}
+func (*EntityProto) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{6}
+}
+func (m *EntityProto) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_EntityProto.Unmarshal(m, b)
+}
+func (m *EntityProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_EntityProto.Marshal(b, m, deterministic)
+}
+func (dst *EntityProto) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_EntityProto.Merge(dst, src)
+}
+func (m *EntityProto) XXX_Size() int {
+        return xxx_messageInfo_EntityProto.Size(m)
+}
+func (m *EntityProto) XXX_DiscardUnknown() {
+        xxx_messageInfo_EntityProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EntityProto proto.InternalMessageInfo
+
+func (m *EntityProto) GetKey() *Reference {
+        if m != nil {
+                return m.Key
+        }
+        return nil
+}
+
+func (m *EntityProto) GetEntityGroup() *Path {
+        if m != nil {
+                return m.EntityGroup
+        }
+        return nil
+}
+
+func (m *EntityProto) GetOwner() *User {
+        if m != nil {
+                return m.Owner
+        }
+        return nil
+}
+
+func (m *EntityProto) GetKind() EntityProto_Kind {
+        if m != nil && m.Kind != nil {
+                return *m.Kind
+        }
+        return EntityProto_GD_CONTACT
+}
+
+func (m *EntityProto) GetKindUri() string {
+        if m != nil && m.KindUri != nil {
+                return *m.KindUri
+        }
+        return ""
+}
+
+func (m *EntityProto) GetProperty() []*Property {
+        if m != nil {
+                return m.Property
+        }
+        return nil
+}
+
+func (m *EntityProto) GetRawProperty() []*Property {
+        if m != nil {
+                return m.RawProperty
+        }
+        return nil
+}
+
+func (m *EntityProto) GetRank() int32 {
+        if m != nil && m.Rank != nil {
+                return *m.Rank
+        }
+        return 0
+}
+
+type CompositeProperty struct {
+        IndexId              *int64   `protobuf:"varint,1,req,name=index_id,json=indexId" json:"index_id,omitempty"`
+        Value                []string `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *CompositeProperty) Reset()         { *m = CompositeProperty{} }
+func (m *CompositeProperty) String() string { return proto.CompactTextString(m) }
+func (*CompositeProperty) ProtoMessage()    {}
+func (*CompositeProperty) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{7}
+}
+func (m *CompositeProperty) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CompositeProperty.Unmarshal(m, b)
+}
+func (m *CompositeProperty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CompositeProperty.Marshal(b, m, deterministic)
+}
+func (dst *CompositeProperty) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CompositeProperty.Merge(dst, src)
+}
+func (m *CompositeProperty) XXX_Size() int {
+        return xxx_messageInfo_CompositeProperty.Size(m)
+}
+func (m *CompositeProperty) XXX_DiscardUnknown() {
+        xxx_messageInfo_CompositeProperty.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompositeProperty proto.InternalMessageInfo
+
+func (m *CompositeProperty) GetIndexId() int64 {
+        if m != nil && m.IndexId != nil {
+                return *m.IndexId
+        }
+        return 0
+}
+
+func (m *CompositeProperty) GetValue() []string {
+        if m != nil {
+                return m.Value
+        }
+        return nil
+}
+
+type Index struct {
+        EntityType           *string           `protobuf:"bytes,1,req,name=entity_type,json=entityType" json:"entity_type,omitempty"`
+        Ancestor             *bool             `protobuf:"varint,5,req,name=ancestor" json:"ancestor,omitempty"`
+        Property             []*Index_Property `protobuf:"group,2,rep,name=Property,json=property" json:"property,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+        XXX_unrecognized     []byte            `json:"-"`
+        XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *Index) Reset()         { *m = Index{} }
+func (m *Index) String() string { return proto.CompactTextString(m) }
+func (*Index) ProtoMessage()    {}
+func (*Index) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{8}
+}
+func (m *Index) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Index.Unmarshal(m, b)
+}
+func (m *Index) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Index.Marshal(b, m, deterministic)
+}
+func (dst *Index) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Index.Merge(dst, src)
+}
+func (m *Index) XXX_Size() int {
+        return xxx_messageInfo_Index.Size(m)
+}
+func (m *Index) XXX_DiscardUnknown() {
+        xxx_messageInfo_Index.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Index proto.InternalMessageInfo
+
+func (m *Index) GetEntityType() string {
+        if m != nil && m.EntityType != nil {
+                return *m.EntityType
+        }
+        return ""
+}
+
+func (m *Index) GetAncestor() bool {
+        if m != nil && m.Ancestor != nil {
+                return *m.Ancestor
+        }
+        return false
+}
+
+func (m *Index) GetProperty() []*Index_Property {
+        if m != nil {
+                return m.Property
+        }
+        return nil
+}
+
+type Index_Property struct {
+        Name                 *string                   `protobuf:"bytes,3,req,name=name" json:"name,omitempty"`
+        Direction            *Index_Property_Direction `protobuf:"varint,4,opt,name=direction,enum=appengine.Index_Property_Direction,def=1" json:"direction,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
+        XXX_unrecognized     []byte                    `json:"-"`
+        XXX_sizecache        int32                     `json:"-"`
+}
+
+func (m *Index_Property) Reset()         { *m = Index_Property{} }
+func (m *Index_Property) String() string { return proto.CompactTextString(m) }
+func (*Index_Property) ProtoMessage()    {}
+func (*Index_Property) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{8, 0}
+}
+func (m *Index_Property) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Index_Property.Unmarshal(m, b)
+}
+func (m *Index_Property) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Index_Property.Marshal(b, m, deterministic)
+}
+func (dst *Index_Property) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Index_Property.Merge(dst, src)
+}
+func (m *Index_Property) XXX_Size() int {
+        return xxx_messageInfo_Index_Property.Size(m)
+}
+func (m *Index_Property) XXX_DiscardUnknown() {
+        xxx_messageInfo_Index_Property.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Index_Property proto.InternalMessageInfo
+
+const Default_Index_Property_Direction Index_Property_Direction = Index_Property_ASCENDING
+
+func (m *Index_Property) GetName() string {
+        if m != nil && m.Name != nil {
+                return *m.Name
+        }
+        return ""
+}
+
+func (m *Index_Property) GetDirection() Index_Property_Direction {
+        if m != nil && m.Direction != nil {
+                return *m.Direction
+        }
+        return Default_Index_Property_Direction
+}
+
+type CompositeIndex struct {
+        AppId                *string               `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
+        Id                   *int64                `protobuf:"varint,2,req,name=id" json:"id,omitempty"`
+        Definition           *Index                `protobuf:"bytes,3,req,name=definition" json:"definition,omitempty"`
+        State                *CompositeIndex_State `protobuf:"varint,4,req,name=state,enum=appengine.CompositeIndex_State" json:"state,omitempty"`
+        OnlyUseIfRequired    *bool                 `protobuf:"varint,6,opt,name=only_use_if_required,json=onlyUseIfRequired,def=0" json:"only_use_if_required,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}              `json:"-"`
+        XXX_unrecognized     []byte                `json:"-"`
+        XXX_sizecache        int32                 `json:"-"`
+}
+
+func (m *CompositeIndex) Reset()         { *m = CompositeIndex{} }
+func (m *CompositeIndex) String() string { return proto.CompactTextString(m) }
+func (*CompositeIndex) ProtoMessage()    {}
+func (*CompositeIndex) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{9}
+}
+func (m *CompositeIndex) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CompositeIndex.Unmarshal(m, b)
+}
+func (m *CompositeIndex) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CompositeIndex.Marshal(b, m, deterministic)
+}
+func (dst *CompositeIndex) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CompositeIndex.Merge(dst, src)
+}
+func (m *CompositeIndex) XXX_Size() int {
+        return xxx_messageInfo_CompositeIndex.Size(m)
+}
+func (m *CompositeIndex) XXX_DiscardUnknown() {
+        xxx_messageInfo_CompositeIndex.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompositeIndex proto.InternalMessageInfo
+
+const Default_CompositeIndex_OnlyUseIfRequired bool = false
+
+func (m *CompositeIndex) GetAppId() string {
+        if m != nil && m.AppId != nil {
+                return *m.AppId
+        }
+        return ""
+}
+
+func (m *CompositeIndex) GetId() int64 {
+        if m != nil && m.Id != nil {
+                return *m.Id
+        }
+        return 0
+}
+
+func (m *CompositeIndex) GetDefinition() *Index {
+        if m != nil {
+                return m.Definition
+        }
+        return nil
+}
+
+func (m *CompositeIndex) GetState() CompositeIndex_State {
+        if m != nil && m.State != nil {
+                return *m.State
+        }
+        return CompositeIndex_WRITE_ONLY
+}
+
+func (m *CompositeIndex) GetOnlyUseIfRequired() bool {
+        if m != nil && m.OnlyUseIfRequired != nil {
+                return *m.OnlyUseIfRequired
+        }
+        return Default_CompositeIndex_OnlyUseIfRequired
+}
+
+type IndexPostfix struct {
+        IndexValue           []*IndexPostfix_IndexValue `protobuf:"bytes,1,rep,name=index_value,json=indexValue" json:"index_value,omitempty"`
+        Key                  *Reference                 `protobuf:"bytes,2,opt,name=key" json:"key,omitempty"`
+        Before               *bool                      `protobuf:"varint,3,opt,name=before,def=1" json:"before,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
+        XXX_unrecognized     []byte                     `json:"-"`
+        XXX_sizecache        int32                      `json:"-"`
+}
+
+func (m *IndexPostfix) Reset()         { *m = IndexPostfix{} }
+func (m *IndexPostfix) String() string { return proto.CompactTextString(m) }
+func (*IndexPostfix) ProtoMessage()    {}
+func (*IndexPostfix) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{10}
+}
+func (m *IndexPostfix) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_IndexPostfix.Unmarshal(m, b)
+}
+func (m *IndexPostfix) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_IndexPostfix.Marshal(b, m, deterministic)
+}
+func (dst *IndexPostfix) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_IndexPostfix.Merge(dst, src)
+}
+func (m *IndexPostfix) XXX_Size() int {
+        return xxx_messageInfo_IndexPostfix.Size(m)
+}
+func (m *IndexPostfix) XXX_DiscardUnknown() {
+        xxx_messageInfo_IndexPostfix.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IndexPostfix proto.InternalMessageInfo
+
+const Default_IndexPostfix_Before bool = true
+
+func (m *IndexPostfix) GetIndexValue() []*IndexPostfix_IndexValue {
+        if m != nil {
+                return m.IndexValue
+        }
+        return nil
+}
+
+func (m *IndexPostfix) GetKey() *Reference {
+        if m != nil {
+                return m.Key
+        }
+        return nil
+}
+
+func (m *IndexPostfix) GetBefore() bool {
+        if m != nil && m.Before != nil {
+                return *m.Before
+        }
+        return Default_IndexPostfix_Before
+}
+
+type IndexPostfix_IndexValue struct {
+        PropertyName         *string        `protobuf:"bytes,1,req,name=property_name,json=propertyName" json:"property_name,omitempty"`
+        Value                *PropertyValue `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}       `json:"-"`
+        XXX_unrecognized     []byte         `json:"-"`
+        XXX_sizecache        int32          `json:"-"`
+}
+
+func (m *IndexPostfix_IndexValue) Reset()         { *m = IndexPostfix_IndexValue{} }
+func (m *IndexPostfix_IndexValue) String() string { return proto.CompactTextString(m) }
+func (*IndexPostfix_IndexValue) ProtoMessage()    {}
+func (*IndexPostfix_IndexValue) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{10, 0}
+}
+func (m *IndexPostfix_IndexValue) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_IndexPostfix_IndexValue.Unmarshal(m, b)
+}
+func (m *IndexPostfix_IndexValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_IndexPostfix_IndexValue.Marshal(b, m, deterministic)
+}
+func (dst *IndexPostfix_IndexValue) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_IndexPostfix_IndexValue.Merge(dst, src)
+}
+func (m *IndexPostfix_IndexValue) XXX_Size() int {
+        return xxx_messageInfo_IndexPostfix_IndexValue.Size(m)
+}
+func (m *IndexPostfix_IndexValue) XXX_DiscardUnknown() {
+        xxx_messageInfo_IndexPostfix_IndexValue.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IndexPostfix_IndexValue proto.InternalMessageInfo
+
+func (m *IndexPostfix_IndexValue) GetPropertyName() string {
+        if m != nil && m.PropertyName != nil {
+                return *m.PropertyName
+        }
+        return ""
+}
+
+func (m *IndexPostfix_IndexValue) GetValue() *PropertyValue {
+        if m != nil {
+                return m.Value
+        }
+        return nil
+}
+
+type IndexPosition struct {
+        Key                  *string  `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
+        Before               *bool    `protobuf:"varint,2,opt,name=before,def=1" json:"before,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *IndexPosition) Reset()         { *m = IndexPosition{} }
+func (m *IndexPosition) String() string { return proto.CompactTextString(m) }
+func (*IndexPosition) ProtoMessage()    {}
+func (*IndexPosition) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{11}
+}
+func (m *IndexPosition) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_IndexPosition.Unmarshal(m, b)
+}
+func (m *IndexPosition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_IndexPosition.Marshal(b, m, deterministic)
+}
+func (dst *IndexPosition) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_IndexPosition.Merge(dst, src)
+}
+func (m *IndexPosition) XXX_Size() int {
+        return xxx_messageInfo_IndexPosition.Size(m)
+}
+func (m *IndexPosition) XXX_DiscardUnknown() {
+        xxx_messageInfo_IndexPosition.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IndexPosition proto.InternalMessageInfo
+
+const Default_IndexPosition_Before bool = true
+
+func (m *IndexPosition) GetKey() string {
+        if m != nil && m.Key != nil {
+                return *m.Key
+        }
+        return ""
+}
+
+func (m *IndexPosition) GetBefore() bool {
+        if m != nil && m.Before != nil {
+                return *m.Before
+        }
+        return Default_IndexPosition_Before
+}
+
+type Snapshot struct {
+        Ts                   *int64   `protobuf:"varint,1,req,name=ts" json:"ts,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Snapshot) Reset()         { *m = Snapshot{} }
+func (m *Snapshot) String() string { return proto.CompactTextString(m) }
+func (*Snapshot) ProtoMessage()    {}
+func (*Snapshot) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{12}
+}
+func (m *Snapshot) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Snapshot.Unmarshal(m, b)
+}
+func (m *Snapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Snapshot.Marshal(b, m, deterministic)
+}
+func (dst *Snapshot) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Snapshot.Merge(dst, src)
+}
+func (m *Snapshot) XXX_Size() int {
+        return xxx_messageInfo_Snapshot.Size(m)
+}
+func (m *Snapshot) XXX_DiscardUnknown() {
+        xxx_messageInfo_Snapshot.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Snapshot proto.InternalMessageInfo
+
+func (m *Snapshot) GetTs() int64 {
+        if m != nil && m.Ts != nil {
+                return *m.Ts
+        }
+        return 0
+}
+
+type InternalHeader struct {
+        Qos                  *string  `protobuf:"bytes,1,opt,name=qos" json:"qos,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *InternalHeader) Reset()         { *m = InternalHeader{} }
+func (m *InternalHeader) String() string { return proto.CompactTextString(m) }
+func (*InternalHeader) ProtoMessage()    {}
+func (*InternalHeader) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{13}
+}
+func (m *InternalHeader) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_InternalHeader.Unmarshal(m, b)
+}
+func (m *InternalHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_InternalHeader.Marshal(b, m, deterministic)
+}
+func (dst *InternalHeader) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_InternalHeader.Merge(dst, src)
+}
+func (m *InternalHeader) XXX_Size() int {
+        return xxx_messageInfo_InternalHeader.Size(m)
+}
+func (m *InternalHeader) XXX_DiscardUnknown() {
+        xxx_messageInfo_InternalHeader.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_InternalHeader proto.InternalMessageInfo
+
+func (m *InternalHeader) GetQos() string {
+        if m != nil && m.Qos != nil {
+                return *m.Qos
+        }
+        return ""
+}
+
+type Transaction struct {
+        Header               *InternalHeader `protobuf:"bytes,4,opt,name=header" json:"header,omitempty"`
+        Handle               *uint64         `protobuf:"fixed64,1,req,name=handle" json:"handle,omitempty"`
+        App                  *string         `protobuf:"bytes,2,req,name=app" json:"app,omitempty"`
+        MarkChanges          *bool           `protobuf:"varint,3,opt,name=mark_changes,json=markChanges,def=0" json:"mark_changes,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+        XXX_unrecognized     []byte          `json:"-"`
+        XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *Transaction) Reset()         { *m = Transaction{} }
+func (m *Transaction) String() string { return proto.CompactTextString(m) }
+func (*Transaction) ProtoMessage()    {}
+func (*Transaction) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{14}
+}
+func (m *Transaction) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Transaction.Unmarshal(m, b)
+}
+func (m *Transaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Transaction.Marshal(b, m, deterministic)
+}
+func (dst *Transaction) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Transaction.Merge(dst, src)
+}
+func (m *Transaction) XXX_Size() int {
+        return xxx_messageInfo_Transaction.Size(m)
+}
+func (m *Transaction) XXX_DiscardUnknown() {
+        xxx_messageInfo_Transaction.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Transaction proto.InternalMessageInfo
+
+const Default_Transaction_MarkChanges bool = false
+
+func (m *Transaction) GetHeader() *InternalHeader {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *Transaction) GetHandle() uint64 {
+        if m != nil && m.Handle != nil {
+                return *m.Handle
+        }
+        return 0
+}
+
+func (m *Transaction) GetApp() string {
+        if m != nil && m.App != nil {
+                return *m.App
+        }
+        return ""
+}
+
+func (m *Transaction) GetMarkChanges() bool {
+        if m != nil && m.MarkChanges != nil {
+                return *m.MarkChanges
+        }
+        return Default_Transaction_MarkChanges
+}
+
+type Query struct {
+        Header               *InternalHeader   `protobuf:"bytes,39,opt,name=header" json:"header,omitempty"`
+        App                  *string           `protobuf:"bytes,1,req,name=app" json:"app,omitempty"`
+        NameSpace            *string           `protobuf:"bytes,29,opt,name=name_space,json=nameSpace" json:"name_space,omitempty"`
+        Kind                 *string           `protobuf:"bytes,3,opt,name=kind" json:"kind,omitempty"`
+        Ancestor             *Reference        `protobuf:"bytes,17,opt,name=ancestor" json:"ancestor,omitempty"`
+        Filter               []*Query_Filter   `protobuf:"group,4,rep,name=Filter,json=filter" json:"filter,omitempty"`
+        SearchQuery          *string           `protobuf:"bytes,8,opt,name=search_query,json=searchQuery" json:"search_query,omitempty"`
+        Order                []*Query_Order    `protobuf:"group,9,rep,name=Order,json=order" json:"order,omitempty"`
+        Hint                 *Query_Hint       `protobuf:"varint,18,opt,name=hint,enum=appengine.Query_Hint" json:"hint,omitempty"`
+        Count                *int32            `protobuf:"varint,23,opt,name=count" json:"count,omitempty"`
+        Offset               *int32            `protobuf:"varint,12,opt,name=offset,def=0" json:"offset,omitempty"`
+        Limit                *int32            `protobuf:"varint,16,opt,name=limit" json:"limit,omitempty"`
+        CompiledCursor       *CompiledCursor   `protobuf:"bytes,30,opt,name=compiled_cursor,json=compiledCursor" json:"compiled_cursor,omitempty"`
+        EndCompiledCursor    *CompiledCursor   `protobuf:"bytes,31,opt,name=end_compiled_cursor,json=endCompiledCursor" json:"end_compiled_cursor,omitempty"`
+        CompositeIndex       []*CompositeIndex `protobuf:"bytes,19,rep,name=composite_index,json=compositeIndex" json:"composite_index,omitempty"`
+        RequirePerfectPlan   *bool             `protobuf:"varint,20,opt,name=require_perfect_plan,json=requirePerfectPlan,def=0" json:"require_perfect_plan,omitempty"`
+        KeysOnly             *bool             `protobuf:"varint,21,opt,name=keys_only,json=keysOnly,def=0" json:"keys_only,omitempty"`
+        Transaction          *Transaction      `protobuf:"bytes,22,opt,name=transaction" json:"transaction,omitempty"`
+        Compile              *bool             `protobuf:"varint,25,opt,name=compile,def=0" json:"compile,omitempty"`
+        FailoverMs           *int64            `protobuf:"varint,26,opt,name=failover_ms,json=failoverMs" json:"failover_ms,omitempty"`
+        Strong               *bool             `protobuf:"varint,32,opt,name=strong" json:"strong,omitempty"`
+        PropertyName         []string          `protobuf:"bytes,33,rep,name=property_name,json=propertyName" json:"property_name,omitempty"`
+        GroupByPropertyName  []string          `protobuf:"bytes,34,rep,name=group_by_property_name,json=groupByPropertyName" json:"group_by_property_name,omitempty"`
+        Distinct             *bool             `protobuf:"varint,24,opt,name=distinct" json:"distinct,omitempty"`
+        MinSafeTimeSeconds   *int64            `protobuf:"varint,35,opt,name=min_safe_time_seconds,json=minSafeTimeSeconds" json:"min_safe_time_seconds,omitempty"`
+        SafeReplicaName      []string          `protobuf:"bytes,36,rep,name=safe_replica_name,json=safeReplicaName" json:"safe_replica_name,omitempty"`
+        PersistOffset        *bool             `protobuf:"varint,37,opt,name=persist_offset,json=persistOffset,def=0" json:"persist_offset,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+        XXX_unrecognized     []byte            `json:"-"`
+        XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *Query) Reset()         { *m = Query{} }
+func (m *Query) String() string { return proto.CompactTextString(m) }
+func (*Query) ProtoMessage()    {}
+func (*Query) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15}
+}
+func (m *Query) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Query.Unmarshal(m, b)
+}
+func (m *Query) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Query.Marshal(b, m, deterministic)
+}
+func (dst *Query) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Query.Merge(dst, src)
+}
+func (m *Query) XXX_Size() int {
+        return xxx_messageInfo_Query.Size(m)
+}
+func (m *Query) XXX_DiscardUnknown() {
+        xxx_messageInfo_Query.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Query proto.InternalMessageInfo
+
+const Default_Query_Offset int32 = 0
+const Default_Query_RequirePerfectPlan bool = false
+const Default_Query_KeysOnly bool = false
+const Default_Query_Compile bool = false
+const Default_Query_PersistOffset bool = false
+
+func (m *Query) GetHeader() *InternalHeader {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *Query) GetApp() string {
+        if m != nil && m.App != nil {
+                return *m.App
+        }
+        return ""
+}
+
+func (m *Query) GetNameSpace() string {
+        if m != nil && m.NameSpace != nil {
+                return *m.NameSpace
+        }
+        return ""
+}
+
+func (m *Query) GetKind() string {
+        if m != nil && m.Kind != nil {
+                return *m.Kind
+        }
+        return ""
+}
+
+func (m *Query) GetAncestor() *Reference {
+        if m != nil {
+                return m.Ancestor
+        }
+        return nil
+}
+
+func (m *Query) GetFilter() []*Query_Filter {
+        if m != nil {
+                return m.Filter
+        }
+        return nil
+}
+
+func (m *Query) GetSearchQuery() string {
+        if m != nil && m.SearchQuery != nil {
+                return *m.SearchQuery
+        }
+        return ""
+}
+
+func (m *Query) GetOrder() []*Query_Order {
+        if m != nil {
+                return m.Order
+        }
+        return nil
+}
+
+func (m *Query) GetHint() Query_Hint {
+        if m != nil && m.Hint != nil {
+                return *m.Hint
+        }
+        return Query_ORDER_FIRST
+}
+
+func (m *Query) GetCount() int32 {
+        if m != nil && m.Count != nil {
+                return *m.Count
+        }
+        return 0
+}
+
+func (m *Query) GetOffset() int32 {
+        if m != nil && m.Offset != nil {
+                return *m.Offset
+        }
+        return Default_Query_Offset
+}
+
+func (m *Query) GetLimit() int32 {
+        if m != nil && m.Limit != nil {
+                return *m.Limit
+        }
+        return 0
+}
+
+func (m *Query) GetCompiledCursor() *CompiledCursor {
+        if m != nil {
+                return m.CompiledCursor
+        }
+        return nil
+}
+
+func (m *Query) GetEndCompiledCursor() *CompiledCursor {
+        if m != nil {
+                return m.EndCompiledCursor
+        }
+        return nil
+}
+
+func (m *Query) GetCompositeIndex() []*CompositeIndex {
+        if m != nil {
+                return m.CompositeIndex
+        }
+        return nil
+}
+
+func (m *Query) GetRequirePerfectPlan() bool {
+        if m != nil && m.RequirePerfectPlan != nil {
+                return *m.RequirePerfectPlan
+        }
+        return Default_Query_RequirePerfectPlan
+}
+
+func (m *Query) GetKeysOnly() bool {
+        if m != nil && m.KeysOnly != nil {
+                return *m.KeysOnly
+        }
+        return Default_Query_KeysOnly
+}
+
+func (m *Query) GetTransaction() *Transaction {
+        if m != nil {
+                return m.Transaction
+        }
+        return nil
+}
+
+func (m *Query) GetCompile() bool {
+        if m != nil && m.Compile != nil {
+                return *m.Compile
+        }
+        return Default_Query_Compile
+}
+
+func (m *Query) GetFailoverMs() int64 {
+        if m != nil && m.FailoverMs != nil {
+                return *m.FailoverMs
+        }
+        return 0
+}
+
+func (m *Query) GetStrong() bool {
+        if m != nil && m.Strong != nil {
+                return *m.Strong
+        }
+        return false
+}
+
+func (m *Query) GetPropertyName() []string {
+        if m != nil {
+                return m.PropertyName
+        }
+        return nil
+}
+
+func (m *Query) GetGroupByPropertyName() []string {
+        if m != nil {
+                return m.GroupByPropertyName
+        }
+        return nil
+}
+
+func (m *Query) GetDistinct() bool {
+        if m != nil && m.Distinct != nil {
+                return *m.Distinct
+        }
+        return false
+}
+
+func (m *Query) GetMinSafeTimeSeconds() int64 {
+        if m != nil && m.MinSafeTimeSeconds != nil {
+                return *m.MinSafeTimeSeconds
+        }
+        return 0
+}
+
+func (m *Query) GetSafeReplicaName() []string {
+        if m != nil {
+                return m.SafeReplicaName
+        }
+        return nil
+}
+
+func (m *Query) GetPersistOffset() bool {
+        if m != nil && m.PersistOffset != nil {
+                return *m.PersistOffset
+        }
+        return Default_Query_PersistOffset
+}
+
+type Query_Filter struct {
+        Op                   *Query_Filter_Operator `protobuf:"varint,6,req,name=op,enum=appengine.Query_Filter_Operator" json:"op,omitempty"`
+        Property             []*Property            `protobuf:"bytes,14,rep,name=property" json:"property,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}               `json:"-"`
+        XXX_unrecognized     []byte                 `json:"-"`
+        XXX_sizecache        int32                  `json:"-"`
+}
+
+func (m *Query_Filter) Reset()         { *m = Query_Filter{} }
+func (m *Query_Filter) String() string { return proto.CompactTextString(m) }
+func (*Query_Filter) ProtoMessage()    {}
+func (*Query_Filter) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 0}
+}
+func (m *Query_Filter) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Query_Filter.Unmarshal(m, b)
+}
+func (m *Query_Filter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Query_Filter.Marshal(b, m, deterministic)
+}
+func (dst *Query_Filter) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Query_Filter.Merge(dst, src)
+}
+func (m *Query_Filter) XXX_Size() int {
+        return xxx_messageInfo_Query_Filter.Size(m)
+}
+func (m *Query_Filter) XXX_DiscardUnknown() {
+        xxx_messageInfo_Query_Filter.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Query_Filter proto.InternalMessageInfo
+
+func (m *Query_Filter) GetOp() Query_Filter_Operator {
+        if m != nil && m.Op != nil {
+                return *m.Op
+        }
+        return Query_Filter_LESS_THAN
+}
+
+func (m *Query_Filter) GetProperty() []*Property {
+        if m != nil {
+                return m.Property
+        }
+        return nil
+}
+
+type Query_Order struct {
+        Property             *string                `protobuf:"bytes,10,req,name=property" json:"property,omitempty"`
+        Direction            *Query_Order_Direction `protobuf:"varint,11,opt,name=direction,enum=appengine.Query_Order_Direction,def=1" json:"direction,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}               `json:"-"`
+        XXX_unrecognized     []byte                 `json:"-"`
+        XXX_sizecache        int32                  `json:"-"`
+}
+
+func (m *Query_Order) Reset()         { *m = Query_Order{} }
+func (m *Query_Order) String() string { return proto.CompactTextString(m) }
+func (*Query_Order) ProtoMessage()    {}
+func (*Query_Order) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 1}
+}
+func (m *Query_Order) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Query_Order.Unmarshal(m, b)
+}
+func (m *Query_Order) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Query_Order.Marshal(b, m, deterministic)
+}
+func (dst *Query_Order) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Query_Order.Merge(dst, src)
+}
+func (m *Query_Order) XXX_Size() int {
+        return xxx_messageInfo_Query_Order.Size(m)
+}
+func (m *Query_Order) XXX_DiscardUnknown() {
+        xxx_messageInfo_Query_Order.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Query_Order proto.InternalMessageInfo
+
+const Default_Query_Order_Direction Query_Order_Direction = Query_Order_ASCENDING
+
+func (m *Query_Order) GetProperty() string {
+        if m != nil && m.Property != nil {
+                return *m.Property
+        }
+        return ""
+}
+
+func (m *Query_Order) GetDirection() Query_Order_Direction {
+        if m != nil && m.Direction != nil {
+                return *m.Direction
+        }
+        return Default_Query_Order_Direction
+}
+
+type CompiledQuery struct {
+        Primaryscan          *CompiledQuery_PrimaryScan     `protobuf:"group,1,req,name=PrimaryScan,json=primaryscan" json:"primaryscan,omitempty"`
+        Mergejoinscan        []*CompiledQuery_MergeJoinScan `protobuf:"group,7,rep,name=MergeJoinScan,json=mergejoinscan" json:"mergejoinscan,omitempty"`
+        IndexDef             *Index                         `protobuf:"bytes,21,opt,name=index_def,json=indexDef" json:"index_def,omitempty"`
+        Offset               *int32                         `protobuf:"varint,10,opt,name=offset,def=0" json:"offset,omitempty"`
+        Limit                *int32                         `protobuf:"varint,11,opt,name=limit" json:"limit,omitempty"`
+        KeysOnly             *bool                          `protobuf:"varint,12,req,name=keys_only,json=keysOnly" json:"keys_only,omitempty"`
+        PropertyName         []string                       `protobuf:"bytes,24,rep,name=property_name,json=propertyName" json:"property_name,omitempty"`
+        DistinctInfixSize    *int32                         `protobuf:"varint,25,opt,name=distinct_infix_size,json=distinctInfixSize" json:"distinct_infix_size,omitempty"`
+        Entityfilter         *CompiledQuery_EntityFilter    `protobuf:"group,13,opt,name=EntityFilter,json=entityfilter" json:"entityfilter,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                       `json:"-"`
+        XXX_unrecognized     []byte                         `json:"-"`
+        XXX_sizecache        int32                          `json:"-"`
+}
+
+func (m *CompiledQuery) Reset()         { *m = CompiledQuery{} }
+func (m *CompiledQuery) String() string { return proto.CompactTextString(m) }
+func (*CompiledQuery) ProtoMessage()    {}
+func (*CompiledQuery) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{16}
+}
+func (m *CompiledQuery) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CompiledQuery.Unmarshal(m, b)
+}
+func (m *CompiledQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CompiledQuery.Marshal(b, m, deterministic)
+}
+func (dst *CompiledQuery) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CompiledQuery.Merge(dst, src)
+}
+func (m *CompiledQuery) XXX_Size() int {
+        return xxx_messageInfo_CompiledQuery.Size(m)
+}
+func (m *CompiledQuery) XXX_DiscardUnknown() {
+        xxx_messageInfo_CompiledQuery.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompiledQuery proto.InternalMessageInfo
+
+const Default_CompiledQuery_Offset int32 = 0
+
+func (m *CompiledQuery) GetPrimaryscan() *CompiledQuery_PrimaryScan {
+        if m != nil {
+                return m.Primaryscan
+        }
+        return nil
+}
+
+func (m *CompiledQuery) GetMergejoinscan() []*CompiledQuery_MergeJoinScan {
+        if m != nil {
+                return m.Mergejoinscan
+        }
+        return nil
+}
+
+func (m *CompiledQuery) GetIndexDef() *Index {
+        if m != nil {
+                return m.IndexDef
+        }
+        return nil
+}
+
+func (m *CompiledQuery) GetOffset() int32 {
+        if m != nil && m.Offset != nil {
+                return *m.Offset
+        }
+        return Default_CompiledQuery_Offset
+}
+
+func (m *CompiledQuery) GetLimit() int32 {
+        if m != nil && m.Limit != nil {
+                return *m.Limit
+        }
+        return 0
+}
+
+func (m *CompiledQuery) GetKeysOnly() bool {
+        if m != nil && m.KeysOnly != nil {
+                return *m.KeysOnly
+        }
+        return false
+}
+
+func (m *CompiledQuery) GetPropertyName() []string {
+        if m != nil {
+                return m.PropertyName
+        }
+        return nil
+}
+
+func (m *CompiledQuery) GetDistinctInfixSize() int32 {
+        if m != nil && m.DistinctInfixSize != nil {
+                return *m.DistinctInfixSize
+        }
+        return 0
+}
+
+func (m *CompiledQuery) GetEntityfilter() *CompiledQuery_EntityFilter {
+        if m != nil {
+                return m.Entityfilter
+        }
+        return nil
+}
+
+type CompiledQuery_PrimaryScan struct {
+        IndexName                  *string  `protobuf:"bytes,2,opt,name=index_name,json=indexName" json:"index_name,omitempty"`
+        StartKey                   *string  `protobuf:"bytes,3,opt,name=start_key,json=startKey" json:"start_key,omitempty"`
+        StartInclusive             *bool    `protobuf:"varint,4,opt,name=start_inclusive,json=startInclusive" json:"start_inclusive,omitempty"`
+        EndKey                     *string  `protobuf:"bytes,5,opt,name=end_key,json=endKey" json:"end_key,omitempty"`
+        EndInclusive               *bool    `protobuf:"varint,6,opt,name=end_inclusive,json=endInclusive" json:"end_inclusive,omitempty"`
+        StartPostfixValue          []string `protobuf:"bytes,22,rep,name=start_postfix_value,json=startPostfixValue" json:"start_postfix_value,omitempty"`
+        EndPostfixValue            []string `protobuf:"bytes,23,rep,name=end_postfix_value,json=endPostfixValue" json:"end_postfix_value,omitempty"`
+        EndUnappliedLogTimestampUs *int64   `protobuf:"varint,19,opt,name=end_unapplied_log_timestamp_us,json=endUnappliedLogTimestampUs" json:"end_unapplied_log_timestamp_us,omitempty"`
+        XXX_NoUnkeyedLiteral       struct{} `json:"-"`
+        XXX_unrecognized           []byte   `json:"-"`
+        XXX_sizecache              int32    `json:"-"`
+}
+
+func (m *CompiledQuery_PrimaryScan) Reset()         { *m = CompiledQuery_PrimaryScan{} }
+func (m *CompiledQuery_PrimaryScan) String() string { return proto.CompactTextString(m) }
+func (*CompiledQuery_PrimaryScan) ProtoMessage()    {}
+func (*CompiledQuery_PrimaryScan) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{16, 0}
+}
+func (m *CompiledQuery_PrimaryScan) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CompiledQuery_PrimaryScan.Unmarshal(m, b)
+}
+func (m *CompiledQuery_PrimaryScan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CompiledQuery_PrimaryScan.Marshal(b, m, deterministic)
+}
+func (dst *CompiledQuery_PrimaryScan) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CompiledQuery_PrimaryScan.Merge(dst, src)
+}
+func (m *CompiledQuery_PrimaryScan) XXX_Size() int {
+        return xxx_messageInfo_CompiledQuery_PrimaryScan.Size(m)
+}
+func (m *CompiledQuery_PrimaryScan) XXX_DiscardUnknown() {
+        xxx_messageInfo_CompiledQuery_PrimaryScan.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompiledQuery_PrimaryScan proto.InternalMessageInfo
+
+func (m *CompiledQuery_PrimaryScan) GetIndexName() string {
+        if m != nil && m.IndexName != nil {
+                return *m.IndexName
+        }
+        return ""
+}
+
+func (m *CompiledQuery_PrimaryScan) GetStartKey() string {
+        if m != nil && m.StartKey != nil {
+                return *m.StartKey
+        }
+        return ""
+}
+
+func (m *CompiledQuery_PrimaryScan) GetStartInclusive() bool {
+        if m != nil && m.StartInclusive != nil {
+                return *m.StartInclusive
+        }
+        return false
+}
+
+func (m *CompiledQuery_PrimaryScan) GetEndKey() string {
+        if m != nil && m.EndKey != nil {
+                return *m.EndKey
+        }
+        return ""
+}
+
+func (m *CompiledQuery_PrimaryScan) GetEndInclusive() bool {
+        if m != nil && m.EndInclusive != nil {
+                return *m.EndInclusive
+        }
+        return false
+}
+
+func (m *CompiledQuery_PrimaryScan) GetStartPostfixValue() []string {
+        if m != nil {
+                return m.StartPostfixValue
+        }
+        return nil
+}
+
+func (m *CompiledQuery_PrimaryScan) GetEndPostfixValue() []string {
+        if m != nil {
+                return m.EndPostfixValue
+        }
+        return nil
+}
+
+func (m *CompiledQuery_PrimaryScan) GetEndUnappliedLogTimestampUs() int64 {
+        if m != nil && m.EndUnappliedLogTimestampUs != nil {
+                return *m.EndUnappliedLogTimestampUs
+        }
+        return 0
+}
+
+type CompiledQuery_MergeJoinScan struct {
+        IndexName            *string  `protobuf:"bytes,8,req,name=index_name,json=indexName" json:"index_name,omitempty"`
+        PrefixValue          []string `protobuf:"bytes,9,rep,name=prefix_value,json=prefixValue" json:"prefix_value,omitempty"`
+        ValuePrefix          *bool    `protobuf:"varint,20,opt,name=value_prefix,json=valuePrefix,def=0" json:"value_prefix,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *CompiledQuery_MergeJoinScan) Reset()         { *m = CompiledQuery_MergeJoinScan{} }
+func (m *CompiledQuery_MergeJoinScan) String() string { return proto.CompactTextString(m) }
+func (*CompiledQuery_MergeJoinScan) ProtoMessage()    {}
+func (*CompiledQuery_MergeJoinScan) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{16, 1}
+}
+func (m *CompiledQuery_MergeJoinScan) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CompiledQuery_MergeJoinScan.Unmarshal(m, b)
+}
+func (m *CompiledQuery_MergeJoinScan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CompiledQuery_MergeJoinScan.Marshal(b, m, deterministic)
+}
+func (dst *CompiledQuery_MergeJoinScan) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CompiledQuery_MergeJoinScan.Merge(dst, src)
+}
+func (m *CompiledQuery_MergeJoinScan) XXX_Size() int {
+        return xxx_messageInfo_CompiledQuery_MergeJoinScan.Size(m)
+}
+func (m *CompiledQuery_MergeJoinScan) XXX_DiscardUnknown() {
+        xxx_messageInfo_CompiledQuery_MergeJoinScan.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompiledQuery_MergeJoinScan proto.InternalMessageInfo
+
+const Default_CompiledQuery_MergeJoinScan_ValuePrefix bool = false
+
+func (m *CompiledQuery_MergeJoinScan) GetIndexName() string {
+        if m != nil && m.IndexName != nil {
+                return *m.IndexName
+        }
+        return ""
+}
+
+func (m *CompiledQuery_MergeJoinScan) GetPrefixValue() []string {
+        if m != nil {
+                return m.PrefixValue
+        }
+        return nil
+}
+
+func (m *CompiledQuery_MergeJoinScan) GetValuePrefix() bool {
+        if m != nil && m.ValuePrefix != nil {
+                return *m.ValuePrefix
+        }
+        return Default_CompiledQuery_MergeJoinScan_ValuePrefix
+}
+
+type CompiledQuery_EntityFilter struct {
+        Distinct             *bool      `protobuf:"varint,14,opt,name=distinct,def=0" json:"distinct,omitempty"`
+        Kind                 *string    `protobuf:"bytes,17,opt,name=kind" json:"kind,omitempty"`
+        Ancestor             *Reference `protobuf:"bytes,18,opt,name=ancestor" json:"ancestor,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}   `json:"-"`
+        XXX_unrecognized     []byte     `json:"-"`
+        XXX_sizecache        int32      `json:"-"`
+}
+
+func (m *CompiledQuery_EntityFilter) Reset()         { *m = CompiledQuery_EntityFilter{} }
+func (m *CompiledQuery_EntityFilter) String() string { return proto.CompactTextString(m) }
+func (*CompiledQuery_EntityFilter) ProtoMessage()    {}
+func (*CompiledQuery_EntityFilter) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{16, 2}
+}
+func (m *CompiledQuery_EntityFilter) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CompiledQuery_EntityFilter.Unmarshal(m, b)
+}
+func (m *CompiledQuery_EntityFilter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CompiledQuery_EntityFilter.Marshal(b, m, deterministic)
+}
+func (dst *CompiledQuery_EntityFilter) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CompiledQuery_EntityFilter.Merge(dst, src)
+}
+func (m *CompiledQuery_EntityFilter) XXX_Size() int {
+        return xxx_messageInfo_CompiledQuery_EntityFilter.Size(m)
+}
+func (m *CompiledQuery_EntityFilter) XXX_DiscardUnknown() {
+        xxx_messageInfo_CompiledQuery_EntityFilter.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompiledQuery_EntityFilter proto.InternalMessageInfo
+
+const Default_CompiledQuery_EntityFilter_Distinct bool = false
+
+func (m *CompiledQuery_EntityFilter) GetDistinct() bool {
+        if m != nil && m.Distinct != nil {
+                return *m.Distinct
+        }
+        return Default_CompiledQuery_EntityFilter_Distinct
+}
+
+func (m *CompiledQuery_EntityFilter) GetKind() string {
+        if m != nil && m.Kind != nil {
+                return *m.Kind
+        }
+        return ""
+}
+
+func (m *CompiledQuery_EntityFilter) GetAncestor() *Reference {
+        if m != nil {
+                return m.Ancestor
+        }
+        return nil
+}
+
+type CompiledCursor struct {
+        Position             *CompiledCursor_Position `protobuf:"group,2,opt,name=Position,json=position" json:"position,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
+        XXX_unrecognized     []byte                   `json:"-"`
+        XXX_sizecache        int32                    `json:"-"`
+}
+
+func (m *CompiledCursor) Reset()         { *m = CompiledCursor{} }
+func (m *CompiledCursor) String() string { return proto.CompactTextString(m) }
+func (*CompiledCursor) ProtoMessage()    {}
+func (*CompiledCursor) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{17}
+}
+func (m *CompiledCursor) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CompiledCursor.Unmarshal(m, b)
+}
+func (m *CompiledCursor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CompiledCursor.Marshal(b, m, deterministic)
+}
+func (dst *CompiledCursor) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CompiledCursor.Merge(dst, src)
+}
+func (m *CompiledCursor) XXX_Size() int {
+        return xxx_messageInfo_CompiledCursor.Size(m)
+}
+func (m *CompiledCursor) XXX_DiscardUnknown() {
+        xxx_messageInfo_CompiledCursor.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompiledCursor proto.InternalMessageInfo
+
+func (m *CompiledCursor) GetPosition() *CompiledCursor_Position {
+        if m != nil {
+                return m.Position
+        }
+        return nil
+}
+
+type CompiledCursor_Position struct {
+        StartKey             *string                               `protobuf:"bytes,27,opt,name=start_key,json=startKey" json:"start_key,omitempty"`
+        Indexvalue           []*CompiledCursor_Position_IndexValue `protobuf:"group,29,rep,name=IndexValue,json=indexvalue" json:"indexvalue,omitempty"`
+        Key                  *Reference                            `protobuf:"bytes,32,opt,name=key" json:"key,omitempty"`
+        StartInclusive       *bool                                 `protobuf:"varint,28,opt,name=start_inclusive,json=startInclusive,def=1" json:"start_inclusive,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                              `json:"-"`
+        XXX_unrecognized     []byte                                `json:"-"`
+        XXX_sizecache        int32                                 `json:"-"`
+}
+
+func (m *CompiledCursor_Position) Reset()         { *m = CompiledCursor_Position{} }
+func (m *CompiledCursor_Position) String() string { return proto.CompactTextString(m) }
+func (*CompiledCursor_Position) ProtoMessage()    {}
+func (*CompiledCursor_Position) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{17, 0}
+}
+func (m *CompiledCursor_Position) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CompiledCursor_Position.Unmarshal(m, b)
+}
+func (m *CompiledCursor_Position) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CompiledCursor_Position.Marshal(b, m, deterministic)
+}
+func (dst *CompiledCursor_Position) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CompiledCursor_Position.Merge(dst, src)
+}
+func (m *CompiledCursor_Position) XXX_Size() int {
+        return xxx_messageInfo_CompiledCursor_Position.Size(m)
+}
+func (m *CompiledCursor_Position) XXX_DiscardUnknown() {
+        xxx_messageInfo_CompiledCursor_Position.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompiledCursor_Position proto.InternalMessageInfo
+
+const Default_CompiledCursor_Position_StartInclusive bool = true
+
+func (m *CompiledCursor_Position) GetStartKey() string {
+        if m != nil && m.StartKey != nil {
+                return *m.StartKey
+        }
+        return ""
+}
+
+func (m *CompiledCursor_Position) GetIndexvalue() []*CompiledCursor_Position_IndexValue {
+        if m != nil {
+                return m.Indexvalue
+        }
+        return nil
+}
+
+func (m *CompiledCursor_Position) GetKey() *Reference {
+        if m != nil {
+                return m.Key
+        }
+        return nil
+}
+
+func (m *CompiledCursor_Position) GetStartInclusive() bool {
+        if m != nil && m.StartInclusive != nil {
+                return *m.StartInclusive
+        }
+        return Default_CompiledCursor_Position_StartInclusive
+}
+
+type CompiledCursor_Position_IndexValue struct {
+        Property             *string        `protobuf:"bytes,30,opt,name=property" json:"property,omitempty"`
+        Value                *PropertyValue `protobuf:"bytes,31,req,name=value" json:"value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}       `json:"-"`
+        XXX_unrecognized     []byte         `json:"-"`
+        XXX_sizecache        int32          `json:"-"`
+}
+
+func (m *CompiledCursor_Position_IndexValue) Reset()         { *m = CompiledCursor_Position_IndexValue{} }
+func (m *CompiledCursor_Position_IndexValue) String() string { return proto.CompactTextString(m) }
+func (*CompiledCursor_Position_IndexValue) ProtoMessage()    {}
+func (*CompiledCursor_Position_IndexValue) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{17, 0, 0}
+}
+func (m *CompiledCursor_Position_IndexValue) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CompiledCursor_Position_IndexValue.Unmarshal(m, b)
+}
+func (m *CompiledCursor_Position_IndexValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CompiledCursor_Position_IndexValue.Marshal(b, m, deterministic)
+}
+func (dst *CompiledCursor_Position_IndexValue) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CompiledCursor_Position_IndexValue.Merge(dst, src)
+}
+func (m *CompiledCursor_Position_IndexValue) XXX_Size() int {
+        return xxx_messageInfo_CompiledCursor_Position_IndexValue.Size(m)
+}
+func (m *CompiledCursor_Position_IndexValue) XXX_DiscardUnknown() {
+        xxx_messageInfo_CompiledCursor_Position_IndexValue.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompiledCursor_Position_IndexValue proto.InternalMessageInfo
+
+func (m *CompiledCursor_Position_IndexValue) GetProperty() string {
+        if m != nil && m.Property != nil {
+                return *m.Property
+        }
+        return ""
+}
+
+func (m *CompiledCursor_Position_IndexValue) GetValue() *PropertyValue {
+        if m != nil {
+                return m.Value
+        }
+        return nil
+}
+
+type Cursor struct {
+        Cursor               *uint64  `protobuf:"fixed64,1,req,name=cursor" json:"cursor,omitempty"`
+        App                  *string  `protobuf:"bytes,2,opt,name=app" json:"app,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Cursor) Reset()         { *m = Cursor{} }
+func (m *Cursor) String() string { return proto.CompactTextString(m) }
+func (*Cursor) ProtoMessage()    {}
+func (*Cursor) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{18}
+}
+func (m *Cursor) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Cursor.Unmarshal(m, b)
+}
+func (m *Cursor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Cursor.Marshal(b, m, deterministic)
+}
+func (dst *Cursor) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Cursor.Merge(dst, src)
+}
+func (m *Cursor) XXX_Size() int {
+        return xxx_messageInfo_Cursor.Size(m)
+}
+func (m *Cursor) XXX_DiscardUnknown() {
+        xxx_messageInfo_Cursor.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Cursor proto.InternalMessageInfo
+
+func (m *Cursor) GetCursor() uint64 {
+        if m != nil && m.Cursor != nil {
+                return *m.Cursor
+        }
+        return 0
+}
+
+func (m *Cursor) GetApp() string {
+        if m != nil && m.App != nil {
+                return *m.App
+        }
+        return ""
+}
+
+type Error struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Error) Reset()         { *m = Error{} }
+func (m *Error) String() string { return proto.CompactTextString(m) }
+func (*Error) ProtoMessage()    {}
+func (*Error) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{19}
+}
+func (m *Error) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Error.Unmarshal(m, b)
+}
+func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Error.Marshal(b, m, deterministic)
+}
+func (dst *Error) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Error.Merge(dst, src)
+}
+func (m *Error) XXX_Size() int {
+        return xxx_messageInfo_Error.Size(m)
+}
+func (m *Error) XXX_DiscardUnknown() {
+        xxx_messageInfo_Error.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Error proto.InternalMessageInfo
+
+type Cost struct {
+        IndexWrites             *int32           `protobuf:"varint,1,opt,name=index_writes,json=indexWrites" json:"index_writes,omitempty"`
+        IndexWriteBytes         *int32           `protobuf:"varint,2,opt,name=index_write_bytes,json=indexWriteBytes" json:"index_write_bytes,omitempty"`
+        EntityWrites            *int32           `protobuf:"varint,3,opt,name=entity_writes,json=entityWrites" json:"entity_writes,omitempty"`
+        EntityWriteBytes        *int32           `protobuf:"varint,4,opt,name=entity_write_bytes,json=entityWriteBytes" json:"entity_write_bytes,omitempty"`
+        Commitcost              *Cost_CommitCost `protobuf:"group,5,opt,name=CommitCost,json=commitcost" json:"commitcost,omitempty"`
+        ApproximateStorageDelta *int32           `protobuf:"varint,8,opt,name=approximate_storage_delta,json=approximateStorageDelta" json:"approximate_storage_delta,omitempty"`
+        IdSequenceUpdates       *int32           `protobuf:"varint,9,opt,name=id_sequence_updates,json=idSequenceUpdates" json:"id_sequence_updates,omitempty"`
+        XXX_NoUnkeyedLiteral    struct{}         `json:"-"`
+        XXX_unrecognized        []byte           `json:"-"`
+        XXX_sizecache           int32            `json:"-"`
+}
+
+func (m *Cost) Reset()         { *m = Cost{} }
+func (m *Cost) String() string { return proto.CompactTextString(m) }
+func (*Cost) ProtoMessage()    {}
+func (*Cost) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{20}
+}
+func (m *Cost) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Cost.Unmarshal(m, b)
+}
+func (m *Cost) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Cost.Marshal(b, m, deterministic)
+}
+func (dst *Cost) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Cost.Merge(dst, src)
+}
+func (m *Cost) XXX_Size() int {
+        return xxx_messageInfo_Cost.Size(m)
+}
+func (m *Cost) XXX_DiscardUnknown() {
+        xxx_messageInfo_Cost.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Cost proto.InternalMessageInfo
+
+func (m *Cost) GetIndexWrites() int32 {
+        if m != nil && m.IndexWrites != nil {
+                return *m.IndexWrites
+        }
+        return 0
+}
+
+func (m *Cost) GetIndexWriteBytes() int32 {
+        if m != nil && m.IndexWriteBytes != nil {
+                return *m.IndexWriteBytes
+        }
+        return 0
+}
+
+func (m *Cost) GetEntityWrites() int32 {
+        if m != nil && m.EntityWrites != nil {
+                return *m.EntityWrites
+        }
+        return 0
+}
+
+func (m *Cost) GetEntityWriteBytes() int32 {
+        if m != nil && m.EntityWriteBytes != nil {
+                return *m.EntityWriteBytes
+        }
+        return 0
+}
+
+func (m *Cost) GetCommitcost() *Cost_CommitCost {
+        if m != nil {
+                return m.Commitcost
+        }
+        return nil
+}
+
+func (m *Cost) GetApproximateStorageDelta() int32 {
+        if m != nil && m.ApproximateStorageDelta != nil {
+                return *m.ApproximateStorageDelta
+        }
+        return 0
+}
+
+func (m *Cost) GetIdSequenceUpdates() int32 {
+        if m != nil && m.IdSequenceUpdates != nil {
+                return *m.IdSequenceUpdates
+        }
+        return 0
+}
+
+type Cost_CommitCost struct {
+        RequestedEntityPuts    *int32   `protobuf:"varint,6,opt,name=requested_entity_puts,json=requestedEntityPuts" json:"requested_entity_puts,omitempty"`
+        RequestedEntityDeletes *int32   `protobuf:"varint,7,opt,name=requested_entity_deletes,json=requestedEntityDeletes" json:"requested_entity_deletes,omitempty"`
+        XXX_NoUnkeyedLiteral   struct{} `json:"-"`
+        XXX_unrecognized       []byte   `json:"-"`
+        XXX_sizecache          int32    `json:"-"`
+}
+
+func (m *Cost_CommitCost) Reset()         { *m = Cost_CommitCost{} }
+func (m *Cost_CommitCost) String() string { return proto.CompactTextString(m) }
+func (*Cost_CommitCost) ProtoMessage()    {}
+func (*Cost_CommitCost) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{20, 0}
+}
+func (m *Cost_CommitCost) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Cost_CommitCost.Unmarshal(m, b)
+}
+func (m *Cost_CommitCost) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Cost_CommitCost.Marshal(b, m, deterministic)
+}
+func (dst *Cost_CommitCost) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Cost_CommitCost.Merge(dst, src)
+}
+func (m *Cost_CommitCost) XXX_Size() int {
+        return xxx_messageInfo_Cost_CommitCost.Size(m)
+}
+func (m *Cost_CommitCost) XXX_DiscardUnknown() {
+        xxx_messageInfo_Cost_CommitCost.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Cost_CommitCost proto.InternalMessageInfo
+
+func (m *Cost_CommitCost) GetRequestedEntityPuts() int32 {
+        if m != nil && m.RequestedEntityPuts != nil {
+                return *m.RequestedEntityPuts
+        }
+        return 0
+}
+
+func (m *Cost_CommitCost) GetRequestedEntityDeletes() int32 {
+        if m != nil && m.RequestedEntityDeletes != nil {
+                return *m.RequestedEntityDeletes
+        }
+        return 0
+}
+
+type GetRequest struct {
+        Header               *InternalHeader `protobuf:"bytes,6,opt,name=header" json:"header,omitempty"`
+        Key                  []*Reference    `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
+        Transaction          *Transaction    `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"`
+        FailoverMs           *int64          `protobuf:"varint,3,opt,name=failover_ms,json=failoverMs" json:"failover_ms,omitempty"`
+        Strong               *bool           `protobuf:"varint,4,opt,name=strong" json:"strong,omitempty"`
+        AllowDeferred        *bool           `protobuf:"varint,5,opt,name=allow_deferred,json=allowDeferred,def=0" json:"allow_deferred,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+        XXX_unrecognized     []byte          `json:"-"`
+        XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *GetRequest) Reset()         { *m = GetRequest{} }
+func (m *GetRequest) String() string { return proto.CompactTextString(m) }
+func (*GetRequest) ProtoMessage()    {}
+func (*GetRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{21}
+}
+func (m *GetRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetRequest.Unmarshal(m, b)
+}
+func (m *GetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetRequest.Merge(dst, src)
+}
+func (m *GetRequest) XXX_Size() int {
+        return xxx_messageInfo_GetRequest.Size(m)
+}
+func (m *GetRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetRequest proto.InternalMessageInfo
+
+const Default_GetRequest_AllowDeferred bool = false
+
+func (m *GetRequest) GetHeader() *InternalHeader {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *GetRequest) GetKey() []*Reference {
+        if m != nil {
+                return m.Key
+        }
+        return nil
+}
+
+func (m *GetRequest) GetTransaction() *Transaction {
+        if m != nil {
+                return m.Transaction
+        }
+        return nil
+}
+
+func (m *GetRequest) GetFailoverMs() int64 {
+        if m != nil && m.FailoverMs != nil {
+                return *m.FailoverMs
+        }
+        return 0
+}
+
+func (m *GetRequest) GetStrong() bool {
+        if m != nil && m.Strong != nil {
+                return *m.Strong
+        }
+        return false
+}
+
+func (m *GetRequest) GetAllowDeferred() bool {
+        if m != nil && m.AllowDeferred != nil {
+                return *m.AllowDeferred
+        }
+        return Default_GetRequest_AllowDeferred
+}
+
+type GetResponse struct {
+        Entity               []*GetResponse_Entity `protobuf:"group,1,rep,name=Entity,json=entity" json:"entity,omitempty"`
+        Deferred             []*Reference          `protobuf:"bytes,5,rep,name=deferred" json:"deferred,omitempty"`
+        InOrder              *bool                 `protobuf:"varint,6,opt,name=in_order,json=inOrder,def=1" json:"in_order,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}              `json:"-"`
+        XXX_unrecognized     []byte                `json:"-"`
+        XXX_sizecache        int32                 `json:"-"`
+}
+
+func (m *GetResponse) Reset()         { *m = GetResponse{} }
+func (m *GetResponse) String() string { return proto.CompactTextString(m) }
+func (*GetResponse) ProtoMessage()    {}
+func (*GetResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{22}
+}
+func (m *GetResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetResponse.Unmarshal(m, b)
+}
+func (m *GetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetResponse.Merge(dst, src)
+}
+func (m *GetResponse) XXX_Size() int {
+        return xxx_messageInfo_GetResponse.Size(m)
+}
+func (m *GetResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetResponse proto.InternalMessageInfo
+
+const Default_GetResponse_InOrder bool = true
+
+func (m *GetResponse) GetEntity() []*GetResponse_Entity {
+        if m != nil {
+                return m.Entity
+        }
+        return nil
+}
+
+func (m *GetResponse) GetDeferred() []*Reference {
+        if m != nil {
+                return m.Deferred
+        }
+        return nil
+}
+
+func (m *GetResponse) GetInOrder() bool {
+        if m != nil && m.InOrder != nil {
+                return *m.InOrder
+        }
+        return Default_GetResponse_InOrder
+}
+
+type GetResponse_Entity struct {
+        Entity               *EntityProto `protobuf:"bytes,2,opt,name=entity" json:"entity,omitempty"`
+        Key                  *Reference   `protobuf:"bytes,4,opt,name=key" json:"key,omitempty"`
+        Version              *int64       `protobuf:"varint,3,opt,name=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}     `json:"-"`
+        XXX_unrecognized     []byte       `json:"-"`
+        XXX_sizecache        int32        `json:"-"`
+}
+
+func (m *GetResponse_Entity) Reset()         { *m = GetResponse_Entity{} }
+func (m *GetResponse_Entity) String() string { return proto.CompactTextString(m) }
+func (*GetResponse_Entity) ProtoMessage()    {}
+func (*GetResponse_Entity) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{22, 0}
+}
+func (m *GetResponse_Entity) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetResponse_Entity.Unmarshal(m, b)
+}
+func (m *GetResponse_Entity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetResponse_Entity.Marshal(b, m, deterministic)
+}
+func (dst *GetResponse_Entity) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetResponse_Entity.Merge(dst, src)
+}
+func (m *GetResponse_Entity) XXX_Size() int {
+        return xxx_messageInfo_GetResponse_Entity.Size(m)
+}
+func (m *GetResponse_Entity) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetResponse_Entity.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetResponse_Entity proto.InternalMessageInfo
+
+func (m *GetResponse_Entity) GetEntity() *EntityProto {
+        if m != nil {
+                return m.Entity
+        }
+        return nil
+}
+
+func (m *GetResponse_Entity) GetKey() *Reference {
+        if m != nil {
+                return m.Key
+        }
+        return nil
+}
+
+func (m *GetResponse_Entity) GetVersion() int64 {
+        if m != nil && m.Version != nil {
+                return *m.Version
+        }
+        return 0
+}
+
+type PutRequest struct {
+        Header               *InternalHeader          `protobuf:"bytes,11,opt,name=header" json:"header,omitempty"`
+        Entity               []*EntityProto           `protobuf:"bytes,1,rep,name=entity" json:"entity,omitempty"`
+        Transaction          *Transaction             `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"`
+        CompositeIndex       []*CompositeIndex        `protobuf:"bytes,3,rep,name=composite_index,json=compositeIndex" json:"composite_index,omitempty"`
+        Trusted              *bool                    `protobuf:"varint,4,opt,name=trusted,def=0" json:"trusted,omitempty"`
+        Force                *bool                    `protobuf:"varint,7,opt,name=force,def=0" json:"force,omitempty"`
+        MarkChanges          *bool                    `protobuf:"varint,8,opt,name=mark_changes,json=markChanges,def=0" json:"mark_changes,omitempty"`
+        Snapshot             []*Snapshot              `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"`
+        AutoIdPolicy         *PutRequest_AutoIdPolicy `protobuf:"varint,10,opt,name=auto_id_policy,json=autoIdPolicy,enum=appengine.PutRequest_AutoIdPolicy,def=0" json:"auto_id_policy,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
+        XXX_unrecognized     []byte                   `json:"-"`
+        XXX_sizecache        int32                    `json:"-"`
+}
+
+func (m *PutRequest) Reset()         { *m = PutRequest{} }
+func (m *PutRequest) String() string { return proto.CompactTextString(m) }
+func (*PutRequest) ProtoMessage()    {}
+func (*PutRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{23}
+}
+func (m *PutRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_PutRequest.Unmarshal(m, b)
+}
+func (m *PutRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_PutRequest.Marshal(b, m, deterministic)
+}
+func (dst *PutRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_PutRequest.Merge(dst, src)
+}
+func (m *PutRequest) XXX_Size() int {
+        return xxx_messageInfo_PutRequest.Size(m)
+}
+func (m *PutRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_PutRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PutRequest proto.InternalMessageInfo
+
+const Default_PutRequest_Trusted bool = false
+const Default_PutRequest_Force bool = false
+const Default_PutRequest_MarkChanges bool = false
+const Default_PutRequest_AutoIdPolicy PutRequest_AutoIdPolicy = PutRequest_CURRENT
+
+func (m *PutRequest) GetHeader() *InternalHeader {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *PutRequest) GetEntity() []*EntityProto {
+        if m != nil {
+                return m.Entity
+        }
+        return nil
+}
+
+func (m *PutRequest) GetTransaction() *Transaction {
+        if m != nil {
+                return m.Transaction
+        }
+        return nil
+}
+
+func (m *PutRequest) GetCompositeIndex() []*CompositeIndex {
+        if m != nil {
+                return m.CompositeIndex
+        }
+        return nil
+}
+
+func (m *PutRequest) GetTrusted() bool {
+        if m != nil && m.Trusted != nil {
+                return *m.Trusted
+        }
+        return Default_PutRequest_Trusted
+}
+
+func (m *PutRequest) GetForce() bool {
+        if m != nil && m.Force != nil {
+                return *m.Force
+        }
+        return Default_PutRequest_Force
+}
+
+func (m *PutRequest) GetMarkChanges() bool {
+        if m != nil && m.MarkChanges != nil {
+                return *m.MarkChanges
+        }
+        return Default_PutRequest_MarkChanges
+}
+
+func (m *PutRequest) GetSnapshot() []*Snapshot {
+        if m != nil {
+                return m.Snapshot
+        }
+        return nil
+}
+
+func (m *PutRequest) GetAutoIdPolicy() PutRequest_AutoIdPolicy {
+        if m != nil && m.AutoIdPolicy != nil {
+                return *m.AutoIdPolicy
+        }
+        return Default_PutRequest_AutoIdPolicy
+}
+
+type PutResponse struct {
+        Key                  []*Reference `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
+        Cost                 *Cost        `protobuf:"bytes,2,opt,name=cost" json:"cost,omitempty"`
+        Version              []int64      `protobuf:"varint,3,rep,name=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}     `json:"-"`
+        XXX_unrecognized     []byte       `json:"-"`
+        XXX_sizecache        int32        `json:"-"`
+}
+
+func (m *PutResponse) Reset()         { *m = PutResponse{} }
+func (m *PutResponse) String() string { return proto.CompactTextString(m) }
+func (*PutResponse) ProtoMessage()    {}
+func (*PutResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{24}
+}
+func (m *PutResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_PutResponse.Unmarshal(m, b)
+}
+func (m *PutResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_PutResponse.Marshal(b, m, deterministic)
+}
+func (dst *PutResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_PutResponse.Merge(dst, src)
+}
+func (m *PutResponse) XXX_Size() int {
+        return xxx_messageInfo_PutResponse.Size(m)
+}
+func (m *PutResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_PutResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PutResponse proto.InternalMessageInfo
+
+func (m *PutResponse) GetKey() []*Reference {
+        if m != nil {
+                return m.Key
+        }
+        return nil
+}
+
+func (m *PutResponse) GetCost() *Cost {
+        if m != nil {
+                return m.Cost
+        }
+        return nil
+}
+
+func (m *PutResponse) GetVersion() []int64 {
+        if m != nil {
+                return m.Version
+        }
+        return nil
+}
+
+type TouchRequest struct {
+        Header               *InternalHeader   `protobuf:"bytes,10,opt,name=header" json:"header,omitempty"`
+        Key                  []*Reference      `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
+        CompositeIndex       []*CompositeIndex `protobuf:"bytes,2,rep,name=composite_index,json=compositeIndex" json:"composite_index,omitempty"`
+        Force                *bool             `protobuf:"varint,3,opt,name=force,def=0" json:"force,omitempty"`
+        Snapshot             []*Snapshot       `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+        XXX_unrecognized     []byte            `json:"-"`
+        XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *TouchRequest) Reset()         { *m = TouchRequest{} }
+func (m *TouchRequest) String() string { return proto.CompactTextString(m) }
+func (*TouchRequest) ProtoMessage()    {}
+func (*TouchRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{25}
+}
+func (m *TouchRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_TouchRequest.Unmarshal(m, b)
+}
+func (m *TouchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_TouchRequest.Marshal(b, m, deterministic)
+}
+func (dst *TouchRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_TouchRequest.Merge(dst, src)
+}
+func (m *TouchRequest) XXX_Size() int {
+        return xxx_messageInfo_TouchRequest.Size(m)
+}
+func (m *TouchRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_TouchRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TouchRequest proto.InternalMessageInfo
+
+const Default_TouchRequest_Force bool = false
+
+func (m *TouchRequest) GetHeader() *InternalHeader {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *TouchRequest) GetKey() []*Reference {
+        if m != nil {
+                return m.Key
+        }
+        return nil
+}
+
+func (m *TouchRequest) GetCompositeIndex() []*CompositeIndex {
+        if m != nil {
+                return m.CompositeIndex
+        }
+        return nil
+}
+
+func (m *TouchRequest) GetForce() bool {
+        if m != nil && m.Force != nil {
+                return *m.Force
+        }
+        return Default_TouchRequest_Force
+}
+
+func (m *TouchRequest) GetSnapshot() []*Snapshot {
+        if m != nil {
+                return m.Snapshot
+        }
+        return nil
+}
+
+type TouchResponse struct {
+        Cost                 *Cost    `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *TouchResponse) Reset()         { *m = TouchResponse{} }
+func (m *TouchResponse) String() string { return proto.CompactTextString(m) }
+func (*TouchResponse) ProtoMessage()    {}
+func (*TouchResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{26}
+}
+func (m *TouchResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_TouchResponse.Unmarshal(m, b)
+}
+func (m *TouchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_TouchResponse.Marshal(b, m, deterministic)
+}
+func (dst *TouchResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_TouchResponse.Merge(dst, src)
+}
+func (m *TouchResponse) XXX_Size() int {
+        return xxx_messageInfo_TouchResponse.Size(m)
+}
+func (m *TouchResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_TouchResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TouchResponse proto.InternalMessageInfo
+
+func (m *TouchResponse) GetCost() *Cost {
+        if m != nil {
+                return m.Cost
+        }
+        return nil
+}
+
+type DeleteRequest struct {
+        Header               *InternalHeader `protobuf:"bytes,10,opt,name=header" json:"header,omitempty"`
+        Key                  []*Reference    `protobuf:"bytes,6,rep,name=key" json:"key,omitempty"`
+        Transaction          *Transaction    `protobuf:"bytes,5,opt,name=transaction" json:"transaction,omitempty"`
+        Trusted              *bool           `protobuf:"varint,4,opt,name=trusted,def=0" json:"trusted,omitempty"`
+        Force                *bool           `protobuf:"varint,7,opt,name=force,def=0" json:"force,omitempty"`
+        MarkChanges          *bool           `protobuf:"varint,8,opt,name=mark_changes,json=markChanges,def=0" json:"mark_changes,omitempty"`
+        Snapshot             []*Snapshot     `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+        XXX_unrecognized     []byte          `json:"-"`
+        XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *DeleteRequest) Reset()         { *m = DeleteRequest{} }
+func (m *DeleteRequest) String() string { return proto.CompactTextString(m) }
+func (*DeleteRequest) ProtoMessage()    {}
+func (*DeleteRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{27}
+}
+func (m *DeleteRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_DeleteRequest.Unmarshal(m, b)
+}
+func (m *DeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_DeleteRequest.Marshal(b, m, deterministic)
+}
+func (dst *DeleteRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_DeleteRequest.Merge(dst, src)
+}
+func (m *DeleteRequest) XXX_Size() int {
+        return xxx_messageInfo_DeleteRequest.Size(m)
+}
+func (m *DeleteRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_DeleteRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DeleteRequest proto.InternalMessageInfo
+
+const Default_DeleteRequest_Trusted bool = false
+const Default_DeleteRequest_Force bool = false
+const Default_DeleteRequest_MarkChanges bool = false
+
+func (m *DeleteRequest) GetHeader() *InternalHeader {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *DeleteRequest) GetKey() []*Reference {
+        if m != nil {
+                return m.Key
+        }
+        return nil
+}
+
+func (m *DeleteRequest) GetTransaction() *Transaction {
+        if m != nil {
+                return m.Transaction
+        }
+        return nil
+}
+
+func (m *DeleteRequest) GetTrusted() bool {
+        if m != nil && m.Trusted != nil {
+                return *m.Trusted
+        }
+        return Default_DeleteRequest_Trusted
+}
+
+func (m *DeleteRequest) GetForce() bool {
+        if m != nil && m.Force != nil {
+                return *m.Force
+        }
+        return Default_DeleteRequest_Force
+}
+
+func (m *DeleteRequest) GetMarkChanges() bool {
+        if m != nil && m.MarkChanges != nil {
+                return *m.MarkChanges
+        }
+        return Default_DeleteRequest_MarkChanges
+}
+
+func (m *DeleteRequest) GetSnapshot() []*Snapshot {
+        if m != nil {
+                return m.Snapshot
+        }
+        return nil
+}
+
+type DeleteResponse struct {
+        Cost                 *Cost    `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"`
+        Version              []int64  `protobuf:"varint,3,rep,name=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *DeleteResponse) Reset()         { *m = DeleteResponse{} }
+func (m *DeleteResponse) String() string { return proto.CompactTextString(m) }
+func (*DeleteResponse) ProtoMessage()    {}
+func (*DeleteResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{28}
+}
+func (m *DeleteResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_DeleteResponse.Unmarshal(m, b)
+}
+func (m *DeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_DeleteResponse.Marshal(b, m, deterministic)
+}
+func (dst *DeleteResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_DeleteResponse.Merge(dst, src)
+}
+func (m *DeleteResponse) XXX_Size() int {
+        return xxx_messageInfo_DeleteResponse.Size(m)
+}
+func (m *DeleteResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_DeleteResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DeleteResponse proto.InternalMessageInfo
+
+func (m *DeleteResponse) GetCost() *Cost {
+        if m != nil {
+                return m.Cost
+        }
+        return nil
+}
+
+func (m *DeleteResponse) GetVersion() []int64 {
+        if m != nil {
+                return m.Version
+        }
+        return nil
+}
+
+type NextRequest struct {
+        Header               *InternalHeader `protobuf:"bytes,5,opt,name=header" json:"header,omitempty"`
+        Cursor               *Cursor         `protobuf:"bytes,1,req,name=cursor" json:"cursor,omitempty"`
+        Count                *int32          `protobuf:"varint,2,opt,name=count" json:"count,omitempty"`
+        Offset               *int32          `protobuf:"varint,4,opt,name=offset,def=0" json:"offset,omitempty"`
+        Compile              *bool           `protobuf:"varint,3,opt,name=compile,def=0" json:"compile,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+        XXX_unrecognized     []byte          `json:"-"`
+        XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *NextRequest) Reset()         { *m = NextRequest{} }
+func (m *NextRequest) String() string { return proto.CompactTextString(m) }
+func (*NextRequest) ProtoMessage()    {}
+func (*NextRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{29}
+}
+func (m *NextRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_NextRequest.Unmarshal(m, b)
+}
+func (m *NextRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_NextRequest.Marshal(b, m, deterministic)
+}
+func (dst *NextRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_NextRequest.Merge(dst, src)
+}
+func (m *NextRequest) XXX_Size() int {
+        return xxx_messageInfo_NextRequest.Size(m)
+}
+func (m *NextRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_NextRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_NextRequest proto.InternalMessageInfo
+
+const Default_NextRequest_Offset int32 = 0
+const Default_NextRequest_Compile bool = false
+
+func (m *NextRequest) GetHeader() *InternalHeader {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *NextRequest) GetCursor() *Cursor {
+        if m != nil {
+                return m.Cursor
+        }
+        return nil
+}
+
+func (m *NextRequest) GetCount() int32 {
+        if m != nil && m.Count != nil {
+                return *m.Count
+        }
+        return 0
+}
+
+func (m *NextRequest) GetOffset() int32 {
+        if m != nil && m.Offset != nil {
+                return *m.Offset
+        }
+        return Default_NextRequest_Offset
+}
+
+func (m *NextRequest) GetCompile() bool {
+        if m != nil && m.Compile != nil {
+                return *m.Compile
+        }
+        return Default_NextRequest_Compile
+}
+
+type QueryResult struct {
+        Cursor               *Cursor           `protobuf:"bytes,1,opt,name=cursor" json:"cursor,omitempty"`
+        Result               []*EntityProto    `protobuf:"bytes,2,rep,name=result" json:"result,omitempty"`
+        SkippedResults       *int32            `protobuf:"varint,7,opt,name=skipped_results,json=skippedResults" json:"skipped_results,omitempty"`
+        MoreResults          *bool             `protobuf:"varint,3,req,name=more_results,json=moreResults" json:"more_results,omitempty"`
+        KeysOnly             *bool             `protobuf:"varint,4,opt,name=keys_only,json=keysOnly" json:"keys_only,omitempty"`
+        IndexOnly            *bool             `protobuf:"varint,9,opt,name=index_only,json=indexOnly" json:"index_only,omitempty"`
+        SmallOps             *bool             `protobuf:"varint,10,opt,name=small_ops,json=smallOps" json:"small_ops,omitempty"`
+        CompiledQuery        *CompiledQuery    `protobuf:"bytes,5,opt,name=compiled_query,json=compiledQuery" json:"compiled_query,omitempty"`
+        CompiledCursor       *CompiledCursor   `protobuf:"bytes,6,opt,name=compiled_cursor,json=compiledCursor" json:"compiled_cursor,omitempty"`
+        Index                []*CompositeIndex `protobuf:"bytes,8,rep,name=index" json:"index,omitempty"`
+        Version              []int64           `protobuf:"varint,11,rep,name=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+        XXX_unrecognized     []byte            `json:"-"`
+        XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *QueryResult) Reset()         { *m = QueryResult{} }
+func (m *QueryResult) String() string { return proto.CompactTextString(m) }
+func (*QueryResult) ProtoMessage()    {}
+func (*QueryResult) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{30}
+}
+func (m *QueryResult) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_QueryResult.Unmarshal(m, b)
+}
+func (m *QueryResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_QueryResult.Marshal(b, m, deterministic)
+}
+func (dst *QueryResult) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_QueryResult.Merge(dst, src)
+}
+func (m *QueryResult) XXX_Size() int {
+        return xxx_messageInfo_QueryResult.Size(m)
+}
+func (m *QueryResult) XXX_DiscardUnknown() {
+        xxx_messageInfo_QueryResult.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryResult proto.InternalMessageInfo
+
+func (m *QueryResult) GetCursor() *Cursor {
+        if m != nil {
+                return m.Cursor
+        }
+        return nil
+}
+
+func (m *QueryResult) GetResult() []*EntityProto {
+        if m != nil {
+                return m.Result
+        }
+        return nil
+}
+
+func (m *QueryResult) GetSkippedResults() int32 {
+        if m != nil && m.SkippedResults != nil {
+                return *m.SkippedResults
+        }
+        return 0
+}
+
+func (m *QueryResult) GetMoreResults() bool {
+        if m != nil && m.MoreResults != nil {
+                return *m.MoreResults
+        }
+        return false
+}
+
+func (m *QueryResult) GetKeysOnly() bool {
+        if m != nil && m.KeysOnly != nil {
+                return *m.KeysOnly
+        }
+        return false
+}
+
+func (m *QueryResult) GetIndexOnly() bool {
+        if m != nil && m.IndexOnly != nil {
+                return *m.IndexOnly
+        }
+        return false
+}
+
+func (m *QueryResult) GetSmallOps() bool {
+        if m != nil && m.SmallOps != nil {
+                return *m.SmallOps
+        }
+        return false
+}
+
+func (m *QueryResult) GetCompiledQuery() *CompiledQuery {
+        if m != nil {
+                return m.CompiledQuery
+        }
+        return nil
+}
+
+func (m *QueryResult) GetCompiledCursor() *CompiledCursor {
+        if m != nil {
+                return m.CompiledCursor
+        }
+        return nil
+}
+
+func (m *QueryResult) GetIndex() []*CompositeIndex {
+        if m != nil {
+                return m.Index
+        }
+        return nil
+}
+
+func (m *QueryResult) GetVersion() []int64 {
+        if m != nil {
+                return m.Version
+        }
+        return nil
+}
+
+type AllocateIdsRequest struct {
+        Header               *InternalHeader `protobuf:"bytes,4,opt,name=header" json:"header,omitempty"`
+        ModelKey             *Reference      `protobuf:"bytes,1,opt,name=model_key,json=modelKey" json:"model_key,omitempty"`
+        Size                 *int64          `protobuf:"varint,2,opt,name=size" json:"size,omitempty"`
+        Max                  *int64          `protobuf:"varint,3,opt,name=max" json:"max,omitempty"`
+        Reserve              []*Reference    `protobuf:"bytes,5,rep,name=reserve" json:"reserve,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+        XXX_unrecognized     []byte          `json:"-"`
+        XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *AllocateIdsRequest) Reset()         { *m = AllocateIdsRequest{} }
+func (m *AllocateIdsRequest) String() string { return proto.CompactTextString(m) }
+func (*AllocateIdsRequest) ProtoMessage()    {}
+func (*AllocateIdsRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{31}
+}
+func (m *AllocateIdsRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_AllocateIdsRequest.Unmarshal(m, b)
+}
+func (m *AllocateIdsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_AllocateIdsRequest.Marshal(b, m, deterministic)
+}
+func (dst *AllocateIdsRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_AllocateIdsRequest.Merge(dst, src)
+}
+func (m *AllocateIdsRequest) XXX_Size() int {
+        return xxx_messageInfo_AllocateIdsRequest.Size(m)
+}
+func (m *AllocateIdsRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_AllocateIdsRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AllocateIdsRequest proto.InternalMessageInfo
+
+func (m *AllocateIdsRequest) GetHeader() *InternalHeader {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *AllocateIdsRequest) GetModelKey() *Reference {
+        if m != nil {
+                return m.ModelKey
+        }
+        return nil
+}
+
+func (m *AllocateIdsRequest) GetSize() int64 {
+        if m != nil && m.Size != nil {
+                return *m.Size
+        }
+        return 0
+}
+
+func (m *AllocateIdsRequest) GetMax() int64 {
+        if m != nil && m.Max != nil {
+                return *m.Max
+        }
+        return 0
+}
+
+func (m *AllocateIdsRequest) GetReserve() []*Reference {
+        if m != nil {
+                return m.Reserve
+        }
+        return nil
+}
+
+type AllocateIdsResponse struct {
+        Start                *int64   `protobuf:"varint,1,req,name=start" json:"start,omitempty"`
+        End                  *int64   `protobuf:"varint,2,req,name=end" json:"end,omitempty"`
+        Cost                 *Cost    `protobuf:"bytes,3,opt,name=cost" json:"cost,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *AllocateIdsResponse) Reset()         { *m = AllocateIdsResponse{} }
+func (m *AllocateIdsResponse) String() string { return proto.CompactTextString(m) }
+func (*AllocateIdsResponse) ProtoMessage()    {}
+func (*AllocateIdsResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{32}
+}
+func (m *AllocateIdsResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_AllocateIdsResponse.Unmarshal(m, b)
+}
+func (m *AllocateIdsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_AllocateIdsResponse.Marshal(b, m, deterministic)
+}
+func (dst *AllocateIdsResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_AllocateIdsResponse.Merge(dst, src)
+}
+func (m *AllocateIdsResponse) XXX_Size() int {
+        return xxx_messageInfo_AllocateIdsResponse.Size(m)
+}
+func (m *AllocateIdsResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_AllocateIdsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AllocateIdsResponse proto.InternalMessageInfo
+
+func (m *AllocateIdsResponse) GetStart() int64 {
+        if m != nil && m.Start != nil {
+                return *m.Start
+        }
+        return 0
+}
+
+func (m *AllocateIdsResponse) GetEnd() int64 {
+        if m != nil && m.End != nil {
+                return *m.End
+        }
+        return 0
+}
+
+func (m *AllocateIdsResponse) GetCost() *Cost {
+        if m != nil {
+                return m.Cost
+        }
+        return nil
+}
+
+type CompositeIndices struct {
+        Index                []*CompositeIndex `protobuf:"bytes,1,rep,name=index" json:"index,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+        XXX_unrecognized     []byte            `json:"-"`
+        XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *CompositeIndices) Reset()         { *m = CompositeIndices{} }
+func (m *CompositeIndices) String() string { return proto.CompactTextString(m) }
+func (*CompositeIndices) ProtoMessage()    {}
+func (*CompositeIndices) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{33}
+}
+func (m *CompositeIndices) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CompositeIndices.Unmarshal(m, b)
+}
+func (m *CompositeIndices) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CompositeIndices.Marshal(b, m, deterministic)
+}
+func (dst *CompositeIndices) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CompositeIndices.Merge(dst, src)
+}
+func (m *CompositeIndices) XXX_Size() int {
+        return xxx_messageInfo_CompositeIndices.Size(m)
+}
+func (m *CompositeIndices) XXX_DiscardUnknown() {
+        xxx_messageInfo_CompositeIndices.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompositeIndices proto.InternalMessageInfo
+
+func (m *CompositeIndices) GetIndex() []*CompositeIndex {
+        if m != nil {
+                return m.Index
+        }
+        return nil
+}
+
+type AddActionsRequest struct {
+        Header               *InternalHeader `protobuf:"bytes,3,opt,name=header" json:"header,omitempty"`
+        Transaction          *Transaction    `protobuf:"bytes,1,req,name=transaction" json:"transaction,omitempty"`
+        Action               []*Action       `protobuf:"bytes,2,rep,name=action" json:"action,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+        XXX_unrecognized     []byte          `json:"-"`
+        XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *AddActionsRequest) Reset()         { *m = AddActionsRequest{} }
+func (m *AddActionsRequest) String() string { return proto.CompactTextString(m) }
+func (*AddActionsRequest) ProtoMessage()    {}
+func (*AddActionsRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{34}
+}
+func (m *AddActionsRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_AddActionsRequest.Unmarshal(m, b)
+}
+func (m *AddActionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_AddActionsRequest.Marshal(b, m, deterministic)
+}
+func (dst *AddActionsRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_AddActionsRequest.Merge(dst, src)
+}
+func (m *AddActionsRequest) XXX_Size() int {
+        return xxx_messageInfo_AddActionsRequest.Size(m)
+}
+func (m *AddActionsRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_AddActionsRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AddActionsRequest proto.InternalMessageInfo
+
+func (m *AddActionsRequest) GetHeader() *InternalHeader {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *AddActionsRequest) GetTransaction() *Transaction {
+        if m != nil {
+                return m.Transaction
+        }
+        return nil
+}
+
+func (m *AddActionsRequest) GetAction() []*Action {
+        if m != nil {
+                return m.Action
+        }
+        return nil
+}
+
+type AddActionsResponse struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *AddActionsResponse) Reset()         { *m = AddActionsResponse{} }
+func (m *AddActionsResponse) String() string { return proto.CompactTextString(m) }
+func (*AddActionsResponse) ProtoMessage()    {}
+func (*AddActionsResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{35}
+}
+func (m *AddActionsResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_AddActionsResponse.Unmarshal(m, b)
+}
+func (m *AddActionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_AddActionsResponse.Marshal(b, m, deterministic)
+}
+func (dst *AddActionsResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_AddActionsResponse.Merge(dst, src)
+}
+func (m *AddActionsResponse) XXX_Size() int {
+        return xxx_messageInfo_AddActionsResponse.Size(m)
+}
+func (m *AddActionsResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_AddActionsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AddActionsResponse proto.InternalMessageInfo
+
+type BeginTransactionRequest struct {
+        Header               *InternalHeader                          `protobuf:"bytes,3,opt,name=header" json:"header,omitempty"`
+        App                  *string                                  `protobuf:"bytes,1,req,name=app" json:"app,omitempty"`
+        AllowMultipleEg      *bool                                    `protobuf:"varint,2,opt,name=allow_multiple_eg,json=allowMultipleEg,def=0" json:"allow_multiple_eg,omitempty"`
+        DatabaseId           *string                                  `protobuf:"bytes,4,opt,name=database_id,json=databaseId" json:"database_id,omitempty"`
+        Mode                 *BeginTransactionRequest_TransactionMode `protobuf:"varint,5,opt,name=mode,enum=appengine.BeginTransactionRequest_TransactionMode,def=0" json:"mode,omitempty"`
+        PreviousTransaction  *Transaction                             `protobuf:"bytes,7,opt,name=previous_transaction,json=previousTransaction" json:"previous_transaction,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                                 `json:"-"`
+        XXX_unrecognized     []byte                                   `json:"-"`
+        XXX_sizecache        int32                                    `json:"-"`
+}
+
+func (m *BeginTransactionRequest) Reset()         { *m = BeginTransactionRequest{} }
+func (m *BeginTransactionRequest) String() string { return proto.CompactTextString(m) }
+func (*BeginTransactionRequest) ProtoMessage()    {}
+func (*BeginTransactionRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{36}
+}
+func (m *BeginTransactionRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_BeginTransactionRequest.Unmarshal(m, b)
+}
+func (m *BeginTransactionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_BeginTransactionRequest.Marshal(b, m, deterministic)
+}
+func (dst *BeginTransactionRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_BeginTransactionRequest.Merge(dst, src)
+}
+func (m *BeginTransactionRequest) XXX_Size() int {
+        return xxx_messageInfo_BeginTransactionRequest.Size(m)
+}
+func (m *BeginTransactionRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_BeginTransactionRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BeginTransactionRequest proto.InternalMessageInfo
+
+const Default_BeginTransactionRequest_AllowMultipleEg bool = false
+const Default_BeginTransactionRequest_Mode BeginTransactionRequest_TransactionMode = BeginTransactionRequest_UNKNOWN
+
+func (m *BeginTransactionRequest) GetHeader() *InternalHeader {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *BeginTransactionRequest) GetApp() string {
+        if m != nil && m.App != nil {
+                return *m.App
+        }
+        return ""
+}
+
+func (m *BeginTransactionRequest) GetAllowMultipleEg() bool {
+        if m != nil && m.AllowMultipleEg != nil {
+                return *m.AllowMultipleEg
+        }
+        return Default_BeginTransactionRequest_AllowMultipleEg
+}
+
+func (m *BeginTransactionRequest) GetDatabaseId() string {
+        if m != nil && m.DatabaseId != nil {
+                return *m.DatabaseId
+        }
+        return ""
+}
+
+func (m *BeginTransactionRequest) GetMode() BeginTransactionRequest_TransactionMode {
+        if m != nil && m.Mode != nil {
+                return *m.Mode
+        }
+        return Default_BeginTransactionRequest_Mode
+}
+
+func (m *BeginTransactionRequest) GetPreviousTransaction() *Transaction {
+        if m != nil {
+                return m.PreviousTransaction
+        }
+        return nil
+}
+
+type CommitResponse struct {
+        Cost                 *Cost                     `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"`
+        Version              []*CommitResponse_Version `protobuf:"group,3,rep,name=Version,json=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
+        XXX_unrecognized     []byte                    `json:"-"`
+        XXX_sizecache        int32                     `json:"-"`
+}
+
+func (m *CommitResponse) Reset()         { *m = CommitResponse{} }
+func (m *CommitResponse) String() string { return proto.CompactTextString(m) }
+func (*CommitResponse) ProtoMessage()    {}
+func (*CommitResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{37}
+}
+func (m *CommitResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CommitResponse.Unmarshal(m, b)
+}
+func (m *CommitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CommitResponse.Marshal(b, m, deterministic)
+}
+func (dst *CommitResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CommitResponse.Merge(dst, src)
+}
+func (m *CommitResponse) XXX_Size() int {
+        return xxx_messageInfo_CommitResponse.Size(m)
+}
+func (m *CommitResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_CommitResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CommitResponse proto.InternalMessageInfo
+
+func (m *CommitResponse) GetCost() *Cost {
+        if m != nil {
+                return m.Cost
+        }
+        return nil
+}
+
+func (m *CommitResponse) GetVersion() []*CommitResponse_Version {
+        if m != nil {
+                return m.Version
+        }
+        return nil
+}
+
+type CommitResponse_Version struct {
+        RootEntityKey        *Reference `protobuf:"bytes,4,req,name=root_entity_key,json=rootEntityKey" json:"root_entity_key,omitempty"`
+        Version              *int64     `protobuf:"varint,5,req,name=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}   `json:"-"`
+        XXX_unrecognized     []byte     `json:"-"`
+        XXX_sizecache        int32      `json:"-"`
+}
+
+func (m *CommitResponse_Version) Reset()         { *m = CommitResponse_Version{} }
+func (m *CommitResponse_Version) String() string { return proto.CompactTextString(m) }
+func (*CommitResponse_Version) ProtoMessage()    {}
+func (*CommitResponse_Version) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{37, 0}
+}
+func (m *CommitResponse_Version) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CommitResponse_Version.Unmarshal(m, b)
+}
+func (m *CommitResponse_Version) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CommitResponse_Version.Marshal(b, m, deterministic)
+}
+func (dst *CommitResponse_Version) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CommitResponse_Version.Merge(dst, src)
+}
+func (m *CommitResponse_Version) XXX_Size() int {
+        return xxx_messageInfo_CommitResponse_Version.Size(m)
+}
+func (m *CommitResponse_Version) XXX_DiscardUnknown() {
+        xxx_messageInfo_CommitResponse_Version.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CommitResponse_Version proto.InternalMessageInfo
+
+func (m *CommitResponse_Version) GetRootEntityKey() *Reference {
+        if m != nil {
+                return m.RootEntityKey
+        }
+        return nil
+}
+
+func (m *CommitResponse_Version) GetVersion() int64 {
+        if m != nil && m.Version != nil {
+                return *m.Version
+        }
+        return 0
+}
+
+func init() {
+        proto.RegisterType((*Action)(nil), "appengine.Action")
+        proto.RegisterType((*PropertyValue)(nil), "appengine.PropertyValue")
+        proto.RegisterType((*PropertyValue_PointValue)(nil), "appengine.PropertyValue.PointValue")
+        proto.RegisterType((*PropertyValue_UserValue)(nil), "appengine.PropertyValue.UserValue")
+        proto.RegisterType((*PropertyValue_ReferenceValue)(nil), "appengine.PropertyValue.ReferenceValue")
+        proto.RegisterType((*PropertyValue_ReferenceValue_PathElement)(nil), "appengine.PropertyValue.ReferenceValue.PathElement")
+        proto.RegisterType((*Property)(nil), "appengine.Property")
+        proto.RegisterType((*Path)(nil), "appengine.Path")
+        proto.RegisterType((*Path_Element)(nil), "appengine.Path.Element")
+        proto.RegisterType((*Reference)(nil), "appengine.Reference")
+        proto.RegisterType((*User)(nil), "appengine.User")
+        proto.RegisterType((*EntityProto)(nil), "appengine.EntityProto")
+        proto.RegisterType((*CompositeProperty)(nil), "appengine.CompositeProperty")
+        proto.RegisterType((*Index)(nil), "appengine.Index")
+        proto.RegisterType((*Index_Property)(nil), "appengine.Index.Property")
+        proto.RegisterType((*CompositeIndex)(nil), "appengine.CompositeIndex")
+        proto.RegisterType((*IndexPostfix)(nil), "appengine.IndexPostfix")
+        proto.RegisterType((*IndexPostfix_IndexValue)(nil), "appengine.IndexPostfix.IndexValue")
+        proto.RegisterType((*IndexPosition)(nil), "appengine.IndexPosition")
+        proto.RegisterType((*Snapshot)(nil), "appengine.Snapshot")
+        proto.RegisterType((*InternalHeader)(nil), "appengine.InternalHeader")
+        proto.RegisterType((*Transaction)(nil), "appengine.Transaction")
+        proto.RegisterType((*Query)(nil), "appengine.Query")
+        proto.RegisterType((*Query_Filter)(nil), "appengine.Query.Filter")
+        proto.RegisterType((*Query_Order)(nil), "appengine.Query.Order")
+        proto.RegisterType((*CompiledQuery)(nil), "appengine.CompiledQuery")
+        proto.RegisterType((*CompiledQuery_PrimaryScan)(nil), "appengine.CompiledQuery.PrimaryScan")
+        proto.RegisterType((*CompiledQuery_MergeJoinScan)(nil), "appengine.CompiledQuery.MergeJoinScan")
+        proto.RegisterType((*CompiledQuery_EntityFilter)(nil), "appengine.CompiledQuery.EntityFilter")
+        proto.RegisterType((*CompiledCursor)(nil), "appengine.CompiledCursor")
+        proto.RegisterType((*CompiledCursor_Position)(nil), "appengine.CompiledCursor.Position")
+        proto.RegisterType((*CompiledCursor_Position_IndexValue)(nil), "appengine.CompiledCursor.Position.IndexValue")
+        proto.RegisterType((*Cursor)(nil), "appengine.Cursor")
+        proto.RegisterType((*Error)(nil), "appengine.Error")
+        proto.RegisterType((*Cost)(nil), "appengine.Cost")
+        proto.RegisterType((*Cost_CommitCost)(nil), "appengine.Cost.CommitCost")
+        proto.RegisterType((*GetRequest)(nil), "appengine.GetRequest")
+        proto.RegisterType((*GetResponse)(nil), "appengine.GetResponse")
+        proto.RegisterType((*GetResponse_Entity)(nil), "appengine.GetResponse.Entity")
+        proto.RegisterType((*PutRequest)(nil), "appengine.PutRequest")
+        proto.RegisterType((*PutResponse)(nil), "appengine.PutResponse")
+        proto.RegisterType((*TouchRequest)(nil), "appengine.TouchRequest")
+        proto.RegisterType((*TouchResponse)(nil), "appengine.TouchResponse")
+        proto.RegisterType((*DeleteRequest)(nil), "appengine.DeleteRequest")
+        proto.RegisterType((*DeleteResponse)(nil), "appengine.DeleteResponse")
+        proto.RegisterType((*NextRequest)(nil), "appengine.NextRequest")
+        proto.RegisterType((*QueryResult)(nil), "appengine.QueryResult")
+        proto.RegisterType((*AllocateIdsRequest)(nil), "appengine.AllocateIdsRequest")
+        proto.RegisterType((*AllocateIdsResponse)(nil), "appengine.AllocateIdsResponse")
+        proto.RegisterType((*CompositeIndices)(nil), "appengine.CompositeIndices")
+        proto.RegisterType((*AddActionsRequest)(nil), "appengine.AddActionsRequest")
+        proto.RegisterType((*AddActionsResponse)(nil), "appengine.AddActionsResponse")
+        proto.RegisterType((*BeginTransactionRequest)(nil), "appengine.BeginTransactionRequest")
+        proto.RegisterType((*CommitResponse)(nil), "appengine.CommitResponse")
+        proto.RegisterType((*CommitResponse_Version)(nil), "appengine.CommitResponse.Version")
+}
+
+func init() {
+        proto.RegisterFile("google.golang.org/appengine/internal/datastore/datastore_v3.proto", fileDescriptor_datastore_v3_83b17b80c34f6179)
+}
+
+var fileDescriptor_datastore_v3_83b17b80c34f6179 = []byte{
+        // 4156 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xcd, 0x73, 0xe3, 0x46,
+        0x76, 0x37, 0xc1, 0xef, 0x47, 0x89, 0x82, 0x5a, 0xf3, 0xc1, 0xa1, 0x3f, 0x46, 0xc6, 0xac, 0x6d,
+        0xd9, 0x6b, 0x73, 0x6c, 0xf9, 0x23, 0x5b, 0x4a, 0x76, 0x1d, 0x4a, 0xc4, 0x68, 0x90, 0xa1, 0x48,
+        0xb9, 0x09, 0xd9, 0x9e, 0x5c, 0x50, 0x18, 0xa2, 0x29, 0x21, 0x43, 0x02, 0x30, 0x00, 0x6a, 0x46,
+        0x93, 0xe4, 0x90, 0x4b, 0x2a, 0x55, 0x5b, 0xa9, 0x1c, 0x92, 0x4a, 0x25, 0xf9, 0x07, 0x72, 0xc8,
+        0x39, 0x95, 0xaa, 0x54, 0xf6, 0x98, 0x5b, 0x0e, 0x7b, 0xc9, 0x31, 0x95, 0x73, 0xf2, 0x27, 0x24,
+        0x39, 0xa4, 0xfa, 0x75, 0x03, 0x02, 0x28, 0x4a, 0x23, 0x6d, 0xf6, 0x90, 0x13, 0xd1, 0xef, 0xfd,
+        0xba, 0xf1, 0xfa, 0xf5, 0xfb, 0x6c, 0x10, 0xba, 0xc7, 0xbe, 0x7f, 0x3c, 0x65, 0x9d, 0x63, 0x7f,
+        0x6a, 0x7b, 0xc7, 0x1d, 0x3f, 0x3c, 0x7e, 0x68, 0x07, 0x01, 0xf3, 0x8e, 0x5d, 0x8f, 0x3d, 0x74,
+        0xbd, 0x98, 0x85, 0x9e, 0x3d, 0x7d, 0xe8, 0xd8, 0xb1, 0x1d, 0xc5, 0x7e, 0xc8, 0xce, 0x9f, 0xac,
+        0xd3, 0xcf, 0x3b, 0x41, 0xe8, 0xc7, 0x3e, 0xa9, 0xa7, 0x13, 0xb4, 0x1a, 0x54, 0xba, 0xe3, 0xd8,
+        0xf5, 0x3d, 0xed, 0x1f, 0x2b, 0xb0, 0x7a, 0x18, 0xfa, 0x01, 0x0b, 0xe3, 0xb3, 0x6f, 0xed, 0xe9,
+        0x9c, 0x91, 0x77, 0x00, 0x5c, 0x2f, 0xfe, 0xea, 0x0b, 0x1c, 0xb5, 0x0a, 0x9b, 0x85, 0xad, 0x22,
+        0xcd, 0x50, 0x88, 0x06, 0x2b, 0xcf, 0x7c, 0x7f, 0xca, 0x6c, 0x4f, 0x20, 0x94, 0xcd, 0xc2, 0x56,
+        0x8d, 0xe6, 0x68, 0x64, 0x13, 0x1a, 0x51, 0x1c, 0xba, 0xde, 0xb1, 0x80, 0x14, 0x37, 0x0b, 0x5b,
+        0x75, 0x9a, 0x25, 0x71, 0x84, 0xe3, 0xcf, 0x9f, 0x4d, 0x99, 0x40, 0x94, 0x36, 0x0b, 0x5b, 0x05,
+        0x9a, 0x25, 0x91, 0x3d, 0x80, 0xc0, 0x77, 0xbd, 0xf8, 0x14, 0x01, 0xe5, 0xcd, 0xc2, 0x16, 0x6c,
+        0x3f, 0xe8, 0xa4, 0x7b, 0xe8, 0xe4, 0xa4, 0xee, 0x1c, 0x72, 0x28, 0x3e, 0xd2, 0xcc, 0x34, 0xf2,
+        0xdb, 0x50, 0x9f, 0x47, 0x2c, 0x14, 0x6b, 0xd4, 0x70, 0x0d, 0xed, 0xd2, 0x35, 0x8e, 0x22, 0x16,
+        0x8a, 0x25, 0xce, 0x27, 0x91, 0x21, 0x34, 0x43, 0x36, 0x61, 0x21, 0xf3, 0xc6, 0x4c, 0x2c, 0xb3,
+        0x82, 0xcb, 0x7c, 0x70, 0xe9, 0x32, 0x34, 0x81, 0x8b, 0xb5, 0x16, 0xa6, 0xb7, 0xb7, 0x00, 0xce,
+        0x85, 0x25, 0x2b, 0x50, 0x78, 0xd9, 0xaa, 0x6c, 0x2a, 0x5b, 0x05, 0x5a, 0x78, 0xc9, 0x47, 0x67,
+        0xad, 0xaa, 0x18, 0x9d, 0xb5, 0xff, 0xa9, 0x00, 0xf5, 0x54, 0x26, 0x72, 0x0b, 0xca, 0x6c, 0x66,
+        0xbb, 0xd3, 0x56, 0x7d, 0x53, 0xd9, 0xaa, 0x53, 0x31, 0x20, 0xf7, 0xa1, 0x61, 0xcf, 0xe3, 0x13,
+        0xcb, 0xf1, 0x67, 0xb6, 0xeb, 0xb5, 0x00, 0x79, 0xc0, 0x49, 0x3d, 0xa4, 0x90, 0x36, 0xd4, 0x3c,
+        0x77, 0xfc, 0xdc, 0xb3, 0x67, 0xac, 0xd5, 0xc0, 0x73, 0x48, 0xc7, 0xe4, 0x13, 0x20, 0x13, 0xe6,
+        0xb0, 0xd0, 0x8e, 0x99, 0x63, 0xb9, 0x0e, 0xf3, 0x62, 0x37, 0x3e, 0x6b, 0xdd, 0x46, 0xd4, 0x7a,
+        0xca, 0x31, 0x24, 0x23, 0x0f, 0x0f, 0x42, 0xff, 0xd4, 0x75, 0x58, 0xd8, 0xba, 0xb3, 0x00, 0x3f,
+        0x94, 0x8c, 0xf6, 0xbf, 0x17, 0xa0, 0x99, 0xd7, 0x05, 0x51, 0xa1, 0x68, 0x07, 0x41, 0x6b, 0x15,
+        0xa5, 0xe4, 0x8f, 0xe4, 0x6d, 0x00, 0x2e, 0x8a, 0x15, 0x05, 0xf6, 0x98, 0xb5, 0x6e, 0xe1, 0x5a,
+        0x75, 0x4e, 0x19, 0x71, 0x02, 0x39, 0x82, 0x46, 0x60, 0xc7, 0x27, 0x6c, 0xca, 0x66, 0xcc, 0x8b,
+        0x5b, 0xcd, 0xcd, 0xe2, 0x16, 0x6c, 0x7f, 0x7e, 0x4d, 0xd5, 0x77, 0x0e, 0xed, 0xf8, 0x44, 0x17,
+        0x53, 0x69, 0x76, 0x9d, 0xb6, 0x0e, 0x8d, 0x0c, 0x8f, 0x10, 0x28, 0xc5, 0x67, 0x01, 0x6b, 0xad,
+        0xa1, 0x5c, 0xf8, 0x4c, 0x9a, 0xa0, 0xb8, 0x4e, 0x4b, 0x45, 0xf3, 0x57, 0x5c, 0x87, 0x63, 0x50,
+        0x87, 0xeb, 0x28, 0x22, 0x3e, 0x6b, 0xff, 0x51, 0x86, 0x5a, 0x22, 0x00, 0xe9, 0x42, 0x75, 0xc6,
+        0x6c, 0xcf, 0xf5, 0x8e, 0xd1, 0x69, 0x9a, 0xdb, 0x6f, 0x2e, 0x11, 0xb3, 0x73, 0x20, 0x20, 0x3b,
+        0x30, 0x18, 0x5a, 0x07, 0x7a, 0x77, 0x60, 0x0c, 0xf6, 0x69, 0x32, 0x8f, 0x1f, 0xa6, 0x7c, 0xb4,
+        0xe6, 0xa1, 0x8b, 0x9e, 0x55, 0xa7, 0x20, 0x49, 0x47, 0xa1, 0x9b, 0x0a, 0x51, 0x14, 0x82, 0xe2,
+        0x21, 0x76, 0xa0, 0x9c, 0xb8, 0x88, 0xb2, 0xd5, 0xd8, 0x6e, 0x5d, 0xa6, 0x1c, 0x2a, 0x60, 0xdc,
+        0x20, 0x66, 0xf3, 0x69, 0xec, 0x06, 0x53, 0xee, 0x76, 0xca, 0x56, 0x8d, 0xa6, 0x63, 0xf2, 0x1e,
+        0x40, 0xc4, 0xec, 0x70, 0x7c, 0x62, 0x3f, 0x9b, 0xb2, 0x56, 0x85, 0x7b, 0xf6, 0x4e, 0x79, 0x62,
+        0x4f, 0x23, 0x46, 0x33, 0x0c, 0x62, 0xc3, 0xdd, 0x49, 0x1c, 0x59, 0xb1, 0xff, 0x9c, 0x79, 0xee,
+        0x2b, 0x9b, 0x07, 0x12, 0xcb, 0x0f, 0xf8, 0x0f, 0xfa, 0x58, 0x73, 0xfb, 0xc3, 0x65, 0x5b, 0x7f,
+        0x14, 0x47, 0x66, 0x66, 0xc6, 0x10, 0x27, 0xd0, 0xdb, 0x93, 0x65, 0x64, 0xd2, 0x86, 0xca, 0xd4,
+        0x1f, 0xdb, 0x53, 0xd6, 0xaa, 0x73, 0x2d, 0xec, 0x28, 0xcc, 0xa3, 0x92, 0xa2, 0xfd, 0xb3, 0x02,
+        0x55, 0xa9, 0x47, 0xd2, 0x84, 0x8c, 0x26, 0xd5, 0x37, 0x48, 0x0d, 0x4a, 0xbb, 0xfd, 0xe1, 0xae,
+        0xda, 0xe4, 0x4f, 0xa6, 0xfe, 0xbd, 0xa9, 0xae, 0x71, 0xcc, 0xee, 0x53, 0x53, 0x1f, 0x99, 0x94,
+        0x63, 0x54, 0xb2, 0x0e, 0xab, 0x5d, 0x73, 0x78, 0x60, 0xed, 0x75, 0x4d, 0x7d, 0x7f, 0x48, 0x9f,
+        0xaa, 0x05, 0xb2, 0x0a, 0x75, 0x24, 0xf5, 0x8d, 0xc1, 0x13, 0x55, 0xe1, 0x33, 0x70, 0x68, 0x1a,
+        0x66, 0x5f, 0x57, 0x8b, 0x44, 0x85, 0x15, 0x31, 0x63, 0x38, 0x30, 0xf5, 0x81, 0xa9, 0x96, 0x52,
+        0xca, 0xe8, 0xe8, 0xe0, 0xa0, 0x4b, 0x9f, 0xaa, 0x65, 0xb2, 0x06, 0x0d, 0xa4, 0x74, 0x8f, 0xcc,
+        0xc7, 0x43, 0xaa, 0x56, 0x48, 0x03, 0xaa, 0xfb, 0x3d, 0xeb, 0xbb, 0xc7, 0xfa, 0x40, 0xad, 0x92,
+        0x15, 0xa8, 0xed, 0xf7, 0x2c, 0xfd, 0xa0, 0x6b, 0xf4, 0xd5, 0x1a, 0x9f, 0xbd, 0xaf, 0x0f, 0xe9,
+        0x68, 0x64, 0x1d, 0x0e, 0x8d, 0x81, 0xa9, 0xd6, 0x49, 0x1d, 0xca, 0xfb, 0x3d, 0xcb, 0x38, 0x50,
+        0x81, 0x10, 0x68, 0xee, 0xf7, 0xac, 0xc3, 0xc7, 0xc3, 0x81, 0x3e, 0x38, 0x3a, 0xd8, 0xd5, 0xa9,
+        0xda, 0x20, 0xb7, 0x40, 0xe5, 0xb4, 0xe1, 0xc8, 0xec, 0xf6, 0xbb, 0xbd, 0x1e, 0xd5, 0x47, 0x23,
+        0x75, 0x85, 0x4b, 0xbd, 0xdf, 0xb3, 0x68, 0xd7, 0xe4, 0xfb, 0x5a, 0xe5, 0x2f, 0xe4, 0x7b, 0x7f,
+        0xa2, 0x3f, 0x55, 0xd7, 0xf9, 0x2b, 0xf4, 0x81, 0x69, 0x98, 0x4f, 0xad, 0x43, 0x3a, 0x34, 0x87,
+        0xea, 0x06, 0x17, 0xd0, 0x18, 0xf4, 0xf4, 0xef, 0xad, 0x6f, 0xbb, 0xfd, 0x23, 0x5d, 0x25, 0xda,
+        0x8f, 0xe1, 0xf6, 0xd2, 0x33, 0xe1, 0xaa, 0x7b, 0x6c, 0x1e, 0xf4, 0xd5, 0x02, 0x7f, 0xe2, 0x9b,
+        0x52, 0x15, 0xed, 0x0f, 0xa0, 0xc4, 0x5d, 0x86, 0x7c, 0x06, 0xd5, 0xc4, 0x1b, 0x0b, 0xe8, 0x8d,
+        0x77, 0xb3, 0x67, 0x6d, 0xc7, 0x27, 0x9d, 0xc4, 0xe3, 0x12, 0x5c, 0xbb, 0x0b, 0xd5, 0x45, 0x4f,
+        0x53, 0x2e, 0x78, 0x5a, 0xf1, 0x82, 0xa7, 0x95, 0x32, 0x9e, 0x66, 0x43, 0x3d, 0xf5, 0xed, 0x9b,
+        0x47, 0x91, 0x07, 0x50, 0xe2, 0xde, 0xdf, 0x6a, 0xa2, 0x87, 0xac, 0x2d, 0x08, 0x4c, 0x91, 0xa9,
+        0xfd, 0x43, 0x01, 0x4a, 0x3c, 0xda, 0x9e, 0x07, 0xda, 0xc2, 0x15, 0x81, 0x56, 0xb9, 0x32, 0xd0,
+        0x16, 0xaf, 0x15, 0x68, 0x2b, 0x37, 0x0b, 0xb4, 0xd5, 0x4b, 0x02, 0xad, 0xf6, 0x67, 0x45, 0x68,
+        0xe8, 0x38, 0xf3, 0x10, 0x13, 0xfd, 0xfb, 0x50, 0x7c, 0xce, 0xce, 0x50, 0x3f, 0x8d, 0xed, 0x5b,
+        0x99, 0xdd, 0xa6, 0x2a, 0xa4, 0x1c, 0x40, 0xb6, 0x61, 0x45, 0xbc, 0xd0, 0x3a, 0x0e, 0xfd, 0x79,
+        0xd0, 0x52, 0x97, 0xab, 0xa7, 0x21, 0x40, 0xfb, 0x1c, 0x43, 0xde, 0x83, 0xb2, 0xff, 0xc2, 0x63,
+        0x21, 0xc6, 0xc1, 0x3c, 0x98, 0x2b, 0x8f, 0x0a, 0x2e, 0x79, 0x08, 0xa5, 0xe7, 0xae, 0xe7, 0xe0,
+        0x19, 0xe6, 0x23, 0x61, 0x46, 0xd0, 0xce, 0x13, 0xd7, 0x73, 0x28, 0x02, 0xc9, 0x3d, 0xa8, 0xf1,
+        0x5f, 0x8c, 0x7b, 0x65, 0xdc, 0x68, 0x95, 0x8f, 0x79, 0xd0, 0x7b, 0x08, 0xb5, 0x40, 0xc6, 0x10,
+        0x4c, 0x00, 0x8d, 0xed, 0x8d, 0x25, 0xe1, 0x85, 0xa6, 0x20, 0xf2, 0x15, 0xac, 0x84, 0xf6, 0x0b,
+        0x2b, 0x9d, 0xb4, 0x76, 0xf9, 0xa4, 0x46, 0x68, 0xbf, 0x48, 0x23, 0x38, 0x81, 0x52, 0x68, 0x7b,
+        0xcf, 0x5b, 0x64, 0xb3, 0xb0, 0x55, 0xa6, 0xf8, 0xac, 0x7d, 0x01, 0x25, 0x2e, 0x25, 0x8f, 0x08,
+        0xfb, 0x3d, 0xf4, 0xff, 0xee, 0x9e, 0xa9, 0x16, 0x12, 0x7f, 0xfe, 0x96, 0x47, 0x03, 0x45, 0x72,
+        0x0f, 0xf4, 0xd1, 0xa8, 0xbb, 0xaf, 0xab, 0x45, 0xad, 0x07, 0xeb, 0x7b, 0xfe, 0x2c, 0xf0, 0x23,
+        0x37, 0x66, 0xe9, 0xf2, 0xf7, 0xa0, 0xe6, 0x7a, 0x0e, 0x7b, 0x69, 0xb9, 0x0e, 0x9a, 0x56, 0x91,
+        0x56, 0x71, 0x6c, 0x38, 0xdc, 0xe4, 0x4e, 0x65, 0x31, 0x55, 0xe4, 0x26, 0x87, 0x03, 0xed, 0x2f,
+        0x15, 0x28, 0x1b, 0x1c, 0xc1, 0x8d, 0x4f, 0x9e, 0x14, 0x7a, 0x8f, 0x30, 0x4c, 0x10, 0x24, 0x93,
+        0xfb, 0x50, 0x1b, 0x6a, 0xb6, 0x37, 0x66, 0xbc, 0xe2, 0xc3, 0x3c, 0x50, 0xa3, 0xe9, 0x98, 0x7c,
+        0x99, 0xd1, 0x9f, 0x82, 0x2e, 0x7b, 0x2f, 0xa3, 0x0a, 0x7c, 0xc1, 0x12, 0x2d, 0xb6, 0xff, 0xaa,
+        0x90, 0x49, 0x6e, 0xcb, 0x12, 0x4f, 0x1f, 0xea, 0x8e, 0x1b, 0x32, 0xac, 0x23, 0xe5, 0x41, 0x3f,
+        0xb8, 0x74, 0xe1, 0x4e, 0x2f, 0x81, 0xee, 0xd4, 0xbb, 0xa3, 0x3d, 0x7d, 0xd0, 0xe3, 0x99, 0xef,
+        0x7c, 0x01, 0xed, 0x23, 0xa8, 0xa7, 0x10, 0x0c, 0xc7, 0x09, 0x48, 0x2d, 0x70, 0xf5, 0xf6, 0xf4,
+        0x74, 0xac, 0x68, 0x7f, 0xad, 0x40, 0x33, 0xd5, 0xaf, 0xd0, 0xd0, 0x6d, 0xa8, 0xd8, 0x41, 0x90,
+        0xa8, 0xb6, 0x4e, 0xcb, 0x76, 0x10, 0x18, 0x8e, 0x8c, 0x2d, 0x0a, 0x6a, 0x9b, 0xc7, 0x96, 0x4f,
+        0x01, 0x1c, 0x36, 0x71, 0x3d, 0x17, 0x85, 0x2e, 0xa2, 0xc1, 0xab, 0x8b, 0x42, 0xd3, 0x0c, 0x86,
+        0x7c, 0x09, 0xe5, 0x28, 0xb6, 0x63, 0x91, 0x2b, 0x9b, 0xdb, 0xf7, 0x33, 0xe0, 0xbc, 0x08, 0x9d,
+        0x11, 0x87, 0x51, 0x81, 0x26, 0x5f, 0xc1, 0x2d, 0xdf, 0x9b, 0x9e, 0x59, 0xf3, 0x88, 0x59, 0xee,
+        0xc4, 0x0a, 0xd9, 0x0f, 0x73, 0x37, 0x64, 0x4e, 0x3e, 0xa7, 0xae, 0x73, 0xc8, 0x51, 0xc4, 0x8c,
+        0x09, 0x95, 0x7c, 0xed, 0x6b, 0x28, 0xe3, 0x3a, 0x7c, 0xcf, 0xdf, 0x51, 0xc3, 0xd4, 0xad, 0xe1,
+        0xa0, 0xff, 0x54, 0xe8, 0x80, 0xea, 0xdd, 0x9e, 0x85, 0x44, 0x55, 0xe1, 0xc1, 0xbe, 0xa7, 0xf7,
+        0x75, 0x53, 0xef, 0xa9, 0x45, 0x9e, 0x3d, 0x74, 0x4a, 0x87, 0x54, 0x2d, 0x69, 0xff, 0x53, 0x80,
+        0x15, 0x94, 0xe7, 0xd0, 0x8f, 0xe2, 0x89, 0xfb, 0x92, 0xec, 0x41, 0x43, 0x98, 0xdd, 0xa9, 0x2c,
+        0xe8, 0xb9, 0x33, 0x68, 0x8b, 0x7b, 0x96, 0x68, 0x31, 0x90, 0x75, 0xb4, 0x9b, 0x3e, 0x27, 0x21,
+        0x45, 0x41, 0xa7, 0xbf, 0x22, 0xa4, 0xbc, 0x05, 0x95, 0x67, 0x6c, 0xe2, 0x87, 0x22, 0x04, 0xd6,
+        0x76, 0x4a, 0x71, 0x38, 0x67, 0x54, 0xd2, 0xda, 0x36, 0xc0, 0xf9, 0xfa, 0xe4, 0x01, 0xac, 0x26,
+        0xc6, 0x66, 0xa1, 0x71, 0x89, 0x93, 0x5b, 0x49, 0x88, 0x83, 0x5c, 0x75, 0xa3, 0x5c, 0xab, 0xba,
+        0xd1, 0xbe, 0x86, 0xd5, 0x64, 0x3f, 0xe2, 0xfc, 0x54, 0x21, 0x79, 0x01, 0x63, 0xca, 0x82, 0x8c,
+        0xca, 0x45, 0x19, 0xb5, 0x9f, 0x41, 0x6d, 0xe4, 0xd9, 0x41, 0x74, 0xe2, 0xc7, 0xdc, 0x7a, 0xe2,
+        0x48, 0xfa, 0xaa, 0x12, 0x47, 0x9a, 0x06, 0x15, 0x7e, 0x38, 0xf3, 0x88, 0xbb, 0xbf, 0x31, 0xe8,
+        0xee, 0x99, 0xc6, 0xb7, 0xba, 0xfa, 0x06, 0x01, 0xa8, 0xc8, 0xe7, 0x82, 0xa6, 0x41, 0xd3, 0x90,
+        0xed, 0xd8, 0x63, 0x66, 0x3b, 0x2c, 0xe4, 0x12, 0xfc, 0xe0, 0x47, 0x89, 0x04, 0x3f, 0xf8, 0x91,
+        0xf6, 0x17, 0x05, 0x68, 0x98, 0xa1, 0xed, 0x45, 0xb6, 0x30, 0xf7, 0xcf, 0xa0, 0x72, 0x82, 0x58,
+        0x74, 0xa3, 0xc6, 0x82, 0x7f, 0x66, 0x17, 0xa3, 0x12, 0x48, 0xee, 0x40, 0xe5, 0xc4, 0xf6, 0x9c,
+        0xa9, 0xd0, 0x5a, 0x85, 0xca, 0x51, 0x92, 0x1b, 0x95, 0xf3, 0xdc, 0xb8, 0x05, 0x2b, 0x33, 0x3b,
+        0x7c, 0x6e, 0x8d, 0x4f, 0x6c, 0xef, 0x98, 0x45, 0xf2, 0x60, 0xa4, 0x05, 0x36, 0x38, 0x6b, 0x4f,
+        0x70, 0xb4, 0xbf, 0x5f, 0x81, 0xf2, 0x37, 0x73, 0x16, 0x9e, 0x65, 0x04, 0xfa, 0xe0, 0xba, 0x02,
+        0xc9, 0x17, 0x17, 0x2e, 0x4b, 0xca, 0x6f, 0x2f, 0x26, 0x65, 0x22, 0x53, 0x84, 0xc8, 0x95, 0x22,
+        0x0b, 0x7c, 0x9a, 0x09, 0x63, 0xeb, 0x57, 0xd8, 0xda, 0x79, 0x70, 0x7b, 0x08, 0x95, 0x89, 0x3b,
+        0x8d, 0x51, 0x75, 0x8b, 0xd5, 0x08, 0xee, 0xa5, 0xf3, 0x08, 0xd9, 0x54, 0xc2, 0xc8, 0xbb, 0xb0,
+        0x22, 0x2a, 0x59, 0xeb, 0x07, 0xce, 0xc6, 0x82, 0x95, 0xf7, 0xa6, 0x48, 0x13, 0xbb, 0xff, 0x18,
+        0xca, 0x7e, 0xc8, 0x37, 0x5f, 0xc7, 0x25, 0xef, 0x5c, 0x58, 0x72, 0xc8, 0xb9, 0x54, 0x80, 0xc8,
+        0x87, 0x50, 0x3a, 0x71, 0xbd, 0x18, 0xb3, 0x46, 0x73, 0xfb, 0xf6, 0x05, 0xf0, 0x63, 0xd7, 0x8b,
+        0x29, 0x42, 0x78, 0x98, 0x1f, 0xfb, 0x73, 0x2f, 0x6e, 0xdd, 0xc5, 0x0c, 0x23, 0x06, 0xe4, 0x1e,
+        0x54, 0xfc, 0xc9, 0x24, 0x62, 0x31, 0x76, 0x96, 0xe5, 0x9d, 0xc2, 0xa7, 0x54, 0x12, 0xf8, 0x84,
+        0xa9, 0x3b, 0x73, 0x63, 0xec, 0x43, 0xca, 0x54, 0x0c, 0xc8, 0x2e, 0xac, 0x8d, 0xfd, 0x59, 0xe0,
+        0x4e, 0x99, 0x63, 0x8d, 0xe7, 0x61, 0xe4, 0x87, 0xad, 0x77, 0x2e, 0x1c, 0xd3, 0x9e, 0x44, 0xec,
+        0x21, 0x80, 0x36, 0xc7, 0xb9, 0x31, 0x31, 0x60, 0x83, 0x79, 0x8e, 0xb5, 0xb8, 0xce, 0xfd, 0xd7,
+        0xad, 0xb3, 0xce, 0x3c, 0x27, 0x4f, 0x4a, 0xc4, 0xc1, 0x48, 0x68, 0x61, 0xcc, 0x68, 0x6d, 0x60,
+        0x90, 0xb9, 0x77, 0x69, 0xac, 0x14, 0xe2, 0x64, 0xc2, 0xf7, 0x6f, 0xc0, 0x2d, 0x19, 0x22, 0xad,
+        0x80, 0x85, 0x13, 0x36, 0x8e, 0xad, 0x60, 0x6a, 0x7b, 0x58, 0xca, 0xa5, 0xc6, 0x4a, 0x24, 0xe4,
+        0x50, 0x20, 0x0e, 0xa7, 0xb6, 0x47, 0x34, 0xa8, 0x3f, 0x67, 0x67, 0x91, 0xc5, 0x23, 0x29, 0x76,
+        0xae, 0x29, 0xba, 0xc6, 0xe9, 0x43, 0x6f, 0x7a, 0x46, 0x7e, 0x02, 0x8d, 0xf8, 0xdc, 0xdb, 0xb0,
+        0x61, 0x6d, 0xe4, 0x4e, 0x35, 0xe3, 0x8b, 0x34, 0x0b, 0x25, 0xf7, 0xa1, 0x2a, 0x35, 0xd4, 0xba,
+        0x97, 0x5d, 0x3b, 0xa1, 0xf2, 0xc4, 0x3c, 0xb1, 0xdd, 0xa9, 0x7f, 0xca, 0x42, 0x6b, 0x16, 0xb5,
+        0xda, 0xe2, 0xb6, 0x24, 0x21, 0x1d, 0x44, 0xdc, 0x4f, 0xa3, 0x38, 0xf4, 0xbd, 0xe3, 0xd6, 0x26,
+        0xde, 0x93, 0xc8, 0xd1, 0xc5, 0xe0, 0xf7, 0x2e, 0x66, 0xfe, 0x7c, 0xf0, 0xfb, 0x1c, 0xee, 0x60,
+        0x65, 0x66, 0x3d, 0x3b, 0xb3, 0xf2, 0x68, 0x0d, 0xd1, 0x1b, 0xc8, 0xdd, 0x3d, 0x3b, 0xcc, 0x4e,
+        0x6a, 0x43, 0xcd, 0x71, 0xa3, 0xd8, 0xf5, 0xc6, 0x71, 0xab, 0x85, 0xef, 0x4c, 0xc7, 0xe4, 0x33,
+        0xb8, 0x3d, 0x73, 0x3d, 0x2b, 0xb2, 0x27, 0xcc, 0x8a, 0x5d, 0xee, 0x9b, 0x6c, 0xec, 0x7b, 0x4e,
+        0xd4, 0x7a, 0x80, 0x82, 0x93, 0x99, 0xeb, 0x8d, 0xec, 0x09, 0x33, 0xdd, 0x19, 0x1b, 0x09, 0x0e,
+        0xf9, 0x08, 0xd6, 0x11, 0x1e, 0xb2, 0x60, 0xea, 0x8e, 0x6d, 0xf1, 0xfa, 0x1f, 0xe1, 0xeb, 0xd7,
+        0x38, 0x83, 0x0a, 0x3a, 0xbe, 0xfa, 0x63, 0x68, 0x06, 0x2c, 0x8c, 0xdc, 0x28, 0xb6, 0xa4, 0x45,
+        0xbf, 0x97, 0xd5, 0xda, 0xaa, 0x64, 0x0e, 0x91, 0xd7, 0xfe, 0xcf, 0x02, 0x54, 0x84, 0x73, 0x92,
+        0x4f, 0x41, 0xf1, 0x03, 0xbc, 0x06, 0x69, 0x6e, 0x6f, 0x5e, 0xe2, 0xc1, 0x9d, 0x61, 0xc0, 0xeb,
+        0x5e, 0x3f, 0xa4, 0x8a, 0x1f, 0xdc, 0xb8, 0x28, 0xd4, 0xfe, 0x10, 0x6a, 0xc9, 0x02, 0xbc, 0xbc,
+        0xe8, 0xeb, 0xa3, 0x91, 0x65, 0x3e, 0xee, 0x0e, 0xd4, 0x02, 0xb9, 0x03, 0x24, 0x1d, 0x5a, 0x43,
+        0x6a, 0xe9, 0xdf, 0x1c, 0x75, 0xfb, 0xaa, 0x82, 0x5d, 0x1a, 0xd5, 0xbb, 0xa6, 0x4e, 0x05, 0xb2,
+        0x48, 0xee, 0xc1, 0xed, 0x2c, 0xe5, 0x1c, 0x5c, 0xc2, 0x14, 0x8c, 0x8f, 0x65, 0x52, 0x01, 0xc5,
+        0x18, 0xa8, 0x15, 0x9e, 0x16, 0xf4, 0xef, 0x8d, 0x91, 0x39, 0x52, 0xab, 0xed, 0xbf, 0x29, 0x40,
+        0x19, 0xc3, 0x06, 0x3f, 0x9f, 0x54, 0x72, 0x71, 0x5d, 0x73, 0x5e, 0xb9, 0x1a, 0xd9, 0x92, 0xaa,
+        0x81, 0x01, 0x65, 0x73, 0x79, 0xf4, 0xf9, 0xb5, 0xd6, 0x53, 0x3f, 0x85, 0x12, 0x8f, 0x52, 0xbc,
+        0x43, 0x1c, 0xd2, 0x9e, 0x4e, 0xad, 0x47, 0x06, 0x1d, 0xf1, 0x2a, 0x97, 0x40, 0xb3, 0x3b, 0xd8,
+        0xd3, 0x47, 0xe6, 0x30, 0xa1, 0xa1, 0x56, 0x1e, 0x19, 0x7d, 0x33, 0x45, 0x15, 0xb5, 0x9f, 0xd7,
+        0x60, 0x35, 0x89, 0x09, 0x22, 0x82, 0x3e, 0x82, 0x46, 0x10, 0xba, 0x33, 0x3b, 0x3c, 0x8b, 0xc6,
+        0xb6, 0x87, 0x49, 0x01, 0xb6, 0x7f, 0xb4, 0x24, 0xaa, 0x88, 0x1d, 0x1d, 0x0a, 0xec, 0x68, 0x6c,
+        0x7b, 0x34, 0x3b, 0x91, 0xf4, 0x61, 0x75, 0xc6, 0xc2, 0x63, 0xf6, 0x7b, 0xbe, 0xeb, 0xe1, 0x4a,
+        0x55, 0x8c, 0xc8, 0xef, 0x5f, 0xba, 0xd2, 0x01, 0x47, 0xff, 0x8e, 0xef, 0x7a, 0xb8, 0x56, 0x7e,
+        0x32, 0xf9, 0x04, 0xea, 0xa2, 0x12, 0x72, 0xd8, 0x04, 0x63, 0xc5, 0xb2, 0xda, 0x4f, 0xd4, 0xe8,
+        0x3d, 0x36, 0xc9, 0xc4, 0x65, 0xb8, 0x34, 0x2e, 0x37, 0xb2, 0x71, 0xf9, 0xcd, 0x6c, 0x2c, 0x5a,
+        0x11, 0x55, 0x78, 0x1a, 0x84, 0x2e, 0x38, 0x7c, 0x6b, 0x89, 0xc3, 0x77, 0x60, 0x23, 0xf1, 0x55,
+        0xcb, 0xf5, 0x26, 0xee, 0x4b, 0x2b, 0x72, 0x5f, 0x89, 0xd8, 0x53, 0xa6, 0xeb, 0x09, 0xcb, 0xe0,
+        0x9c, 0x91, 0xfb, 0x8a, 0x11, 0x23, 0xe9, 0xe0, 0x64, 0x0e, 0x5c, 0xc5, 0xab, 0xc9, 0xf7, 0x2e,
+        0x55, 0x8f, 0x68, 0xbe, 0x64, 0x46, 0xcc, 0x4d, 0x6d, 0xff, 0x52, 0x81, 0x46, 0xe6, 0x1c, 0x78,
+        0xf6, 0x16, 0xca, 0x42, 0x61, 0xc5, 0x55, 0x94, 0x50, 0x1f, 0x4a, 0xfa, 0x26, 0xd4, 0xa3, 0xd8,
+        0x0e, 0x63, 0x8b, 0x17, 0x57, 0xb2, 0xdd, 0x45, 0xc2, 0x13, 0x76, 0x46, 0x3e, 0x80, 0x35, 0xc1,
+        0x74, 0xbd, 0xf1, 0x74, 0x1e, 0xb9, 0xa7, 0xa2, 0x99, 0xaf, 0xd1, 0x26, 0x92, 0x8d, 0x84, 0x4a,
+        0xee, 0x42, 0x95, 0x67, 0x21, 0xbe, 0x86, 0x68, 0xfa, 0x2a, 0xcc, 0x73, 0xf8, 0x0a, 0x0f, 0x60,
+        0x95, 0x33, 0xce, 0xe7, 0x57, 0xc4, 0x2d, 0x33, 0xf3, 0x9c, 0xf3, 0xd9, 0x1d, 0xd8, 0x10, 0xaf,
+        0x09, 0x44, 0xf1, 0x2a, 0x2b, 0xdc, 0x3b, 0xa8, 0xd8, 0x75, 0x64, 0xc9, 0xb2, 0x56, 0x14, 0x9c,
+        0x1f, 0x01, 0xcf, 0x5e, 0x0b, 0xe8, 0xbb, 0x22, 0x94, 0x31, 0xcf, 0xc9, 0x61, 0x77, 0xe1, 0x1d,
+        0x8e, 0x9d, 0x7b, 0x76, 0x10, 0x4c, 0x5d, 0xe6, 0x58, 0x53, 0xff, 0x18, 0x43, 0x66, 0x14, 0xdb,
+        0xb3, 0xc0, 0x9a, 0x47, 0xad, 0x0d, 0x0c, 0x99, 0x6d, 0xe6, 0x39, 0x47, 0x09, 0xa8, 0xef, 0x1f,
+        0x9b, 0x09, 0xe4, 0x28, 0x6a, 0xff, 0x3e, 0xac, 0xe6, 0xec, 0x71, 0x41, 0xa7, 0x35, 0x74, 0xfe,
+        0x8c, 0x4e, 0xdf, 0x85, 0x95, 0x20, 0x64, 0xe7, 0xa2, 0xd5, 0x51, 0xb4, 0x86, 0xa0, 0x09, 0xb1,
+        0xb6, 0x60, 0x05, 0x79, 0x96, 0x20, 0xe6, 0xf3, 0x63, 0x03, 0x59, 0x87, 0xc8, 0x69, 0xbf, 0x80,
+        0x95, 0xec, 0x69, 0x93, 0x77, 0x33, 0x69, 0xa1, 0x99, 0xcb, 0x93, 0x69, 0x76, 0x48, 0x2a, 0xb2,
+        0xf5, 0x4b, 0x2a, 0x32, 0x72, 0x9d, 0x8a, 0x4c, 0xfb, 0x2f, 0xd9, 0x9c, 0x65, 0x2a, 0x84, 0x9f,
+        0x41, 0x2d, 0x90, 0xf5, 0x38, 0x5a, 0x52, 0xfe, 0x12, 0x3e, 0x0f, 0xee, 0x24, 0x95, 0x3b, 0x4d,
+        0xe7, 0xb4, 0xff, 0x56, 0x81, 0x5a, 0x5a, 0xd0, 0xe7, 0x2c, 0xef, 0xcd, 0x05, 0xcb, 0x3b, 0x90,
+        0x1a, 0x16, 0x0a, 0x7c, 0x1b, 0xa3, 0xc5, 0x27, 0xaf, 0x7f, 0xd7, 0xc5, 0xb6, 0xe7, 0x34, 0xdb,
+        0xf6, 0x6c, 0xbe, 0xae, 0xed, 0xf9, 0xe4, 0xa2, 0xc1, 0xbf, 0x95, 0xe9, 0x2d, 0x16, 0xcc, 0xbe,
+        0xfd, 0x7d, 0xae, 0x0f, 0xca, 0x26, 0x84, 0x77, 0xc4, 0x7e, 0xd2, 0x84, 0x90, 0xb6, 0x3f, 0xf7,
+        0xaf, 0xd7, 0xfe, 0x6c, 0x43, 0x45, 0xea, 0xfc, 0x0e, 0x54, 0x64, 0x4d, 0x27, 0x1b, 0x04, 0x31,
+        0x3a, 0x6f, 0x10, 0x0a, 0xb2, 0x4e, 0xd7, 0x7e, 0xae, 0x40, 0x59, 0x0f, 0x43, 0x3f, 0xd4, 0xfe,
+        0x48, 0x81, 0x3a, 0x3e, 0xed, 0xf9, 0x0e, 0xe3, 0xd9, 0x60, 0xb7, 0xdb, 0xb3, 0xa8, 0xfe, 0xcd,
+        0x91, 0x8e, 0xd9, 0xa0, 0x0d, 0x77, 0xf6, 0x86, 0x83, 0xbd, 0x23, 0x4a, 0xf5, 0x81, 0x69, 0x99,
+        0xb4, 0x3b, 0x18, 0xf1, 0xb6, 0x67, 0x38, 0x50, 0x15, 0x9e, 0x29, 0x8c, 0x81, 0xa9, 0xd3, 0x41,
+        0xb7, 0x6f, 0x89, 0x56, 0xb4, 0x88, 0x77, 0xb3, 0xba, 0xde, 0xb3, 0xf0, 0xd6, 0x51, 0x2d, 0xf1,
+        0x96, 0xd5, 0x34, 0x0e, 0xf4, 0xe1, 0x91, 0xa9, 0x96, 0xc9, 0x6d, 0x58, 0x3f, 0xd4, 0xe9, 0x81,
+        0x31, 0x1a, 0x19, 0xc3, 0x81, 0xd5, 0xd3, 0x07, 0x86, 0xde, 0x53, 0x2b, 0x7c, 0x9d, 0x5d, 0x63,
+        0xdf, 0xec, 0xee, 0xf6, 0x75, 0xb9, 0x4e, 0x95, 0x6c, 0xc2, 0x5b, 0x7b, 0xc3, 0x83, 0x03, 0xc3,
+        0x34, 0xf5, 0x9e, 0xb5, 0x7b, 0x64, 0x5a, 0x23, 0xd3, 0xe8, 0xf7, 0xad, 0xee, 0xe1, 0x61, 0xff,
+        0x29, 0x4f, 0x60, 0x35, 0x72, 0x17, 0x36, 0xf6, 0xba, 0x87, 0xdd, 0x5d, 0xa3, 0x6f, 0x98, 0x4f,
+        0xad, 0x9e, 0x31, 0xe2, 0xf3, 0x7b, 0x6a, 0x9d, 0x27, 0x6c, 0x93, 0x3e, 0xb5, 0xba, 0x7d, 0x14,
+        0xcd, 0xd4, 0xad, 0xdd, 0xee, 0xde, 0x13, 0x7d, 0xd0, 0x53, 0x81, 0x0b, 0x30, 0xea, 0x3e, 0xd2,
+        0x2d, 0x2e, 0x92, 0x65, 0x0e, 0x87, 0xd6, 0xb0, 0xdf, 0x53, 0x1b, 0xda, 0xbf, 0x14, 0xa1, 0xb4,
+        0xe7, 0x47, 0x31, 0xf7, 0x46, 0xe1, 0xac, 0x2f, 0x42, 0x37, 0x66, 0xa2, 0x7f, 0x2b, 0x53, 0xd1,
+        0x4b, 0x7f, 0x87, 0x24, 0x1e, 0x50, 0x32, 0x10, 0xeb, 0xd9, 0x19, 0xc7, 0x29, 0x88, 0x5b, 0x3b,
+        0xc7, 0xed, 0x72, 0xb2, 0x88, 0x68, 0x78, 0x85, 0x23, 0xd7, 0x2b, 0x22, 0x4e, 0x06, 0x61, 0xb9,
+        0xe0, 0xc7, 0x40, 0xb2, 0x20, 0xb9, 0x62, 0x09, 0x91, 0x6a, 0x06, 0x29, 0x96, 0xdc, 0x01, 0x18,
+        0xfb, 0xb3, 0x99, 0x1b, 0x8f, 0xfd, 0x28, 0x96, 0x5f, 0xc8, 0xda, 0x39, 0x63, 0x8f, 0x62, 0x6e,
+        0xf1, 0x33, 0x37, 0xe6, 0x8f, 0x34, 0x83, 0x26, 0x3b, 0x70, 0xcf, 0x0e, 0x82, 0xd0, 0x7f, 0xe9,
+        0xce, 0xec, 0x98, 0x59, 0xdc, 0x73, 0xed, 0x63, 0x66, 0x39, 0x6c, 0x1a, 0xdb, 0xd8, 0x13, 0x95,
+        0xe9, 0xdd, 0x0c, 0x60, 0x24, 0xf8, 0x3d, 0xce, 0xe6, 0x71, 0xd7, 0x75, 0xac, 0x88, 0xfd, 0x30,
+        0xe7, 0x1e, 0x60, 0xcd, 0x03, 0xc7, 0xe6, 0x62, 0xd6, 0x45, 0x96, 0x72, 0x9d, 0x91, 0xe4, 0x1c,
+        0x09, 0x46, 0xfb, 0x15, 0xc0, 0xb9, 0x14, 0x64, 0x1b, 0x6e, 0xf3, 0x3a, 0x9e, 0x45, 0x31, 0x73,
+        0x2c, 0xb9, 0xdb, 0x60, 0x1e, 0x47, 0x18, 0xe2, 0xcb, 0x74, 0x23, 0x65, 0xca, 0x9b, 0xc2, 0x79,
+        0x1c, 0x91, 0x9f, 0x40, 0xeb, 0xc2, 0x1c, 0x87, 0x4d, 0x19, 0x7f, 0x6d, 0x15, 0xa7, 0xdd, 0x59,
+        0x98, 0xd6, 0x13, 0x5c, 0xed, 0x4f, 0x14, 0x80, 0x7d, 0x16, 0x53, 0xc1, 0xcd, 0x34, 0xb6, 0x95,
+        0xeb, 0x36, 0xb6, 0xef, 0x27, 0x17, 0x08, 0xc5, 0xab, 0x63, 0xc0, 0x42, 0x97, 0xa1, 0xdc, 0xa4,
+        0xcb, 0xc8, 0x35, 0x11, 0xc5, 0x2b, 0x9a, 0x88, 0x52, 0xae, 0x89, 0xf8, 0x18, 0x9a, 0xf6, 0x74,
+        0xea, 0xbf, 0xe0, 0x05, 0x0d, 0x0b, 0x43, 0xe6, 0xa0, 0x11, 0x9c, 0xd7, 0xdb, 0xc8, 0xec, 0x49,
+        0x9e, 0xf6, 0xe7, 0x0a, 0x34, 0x50, 0x15, 0x51, 0xe0, 0x7b, 0x11, 0x23, 0x5f, 0x42, 0x45, 0x5e,
+        0x44, 0x8b, 0x8b, 0xfc, 0xb7, 0x33, 0xb2, 0x66, 0x70, 0xb2, 0x68, 0xa0, 0x12, 0xcc, 0x33, 0x42,
+        0xe6, 0x75, 0x97, 0x2b, 0x25, 0x45, 0x91, 0xfb, 0x50, 0x73, 0x3d, 0x4b, 0xb4, 0xd4, 0x95, 0x4c,
+        0x58, 0xac, 0xba, 0x1e, 0xd6, 0xb2, 0xed, 0x57, 0x50, 0x11, 0x2f, 0x21, 0x9d, 0x54, 0xa6, 0x8b,
+        0xfa, 0xcb, 0xdc, 0x1c, 0xa7, 0xc2, 0xc8, 0xc3, 0x29, 0xbd, 0x2e, 0x40, 0xb7, 0xa0, 0x7a, 0xca,
+        0x9b, 0x0f, 0xbc, 0xf4, 0xe3, 0xea, 0x4d, 0x86, 0xda, 0x1f, 0x97, 0x00, 0x0e, 0xe7, 0x4b, 0x0c,
+        0xa4, 0x71, 0x5d, 0x03, 0xe9, 0xe4, 0xf4, 0xf8, 0x7a, 0x99, 0x7f, 0x75, 0x43, 0x59, 0xd2, 0x69,
+        0x17, 0x6f, 0xda, 0x69, 0xdf, 0x87, 0x6a, 0x1c, 0xce, 0xb9, 0xa3, 0x08, 0x63, 0x4a, 0x5b, 0x5a,
+        0x49, 0x25, 0x6f, 0x42, 0x79, 0xe2, 0x87, 0x63, 0x86, 0x8e, 0x95, 0xb2, 0x05, 0xed, 0xc2, 0x65,
+        0x52, 0xed, 0xb2, 0xcb, 0x24, 0xde, 0xa0, 0x45, 0xf2, 0x1e, 0x0d, 0x0b, 0x99, 0x7c, 0x83, 0x96,
+        0x5c, 0xb1, 0xd1, 0x14, 0x44, 0xbe, 0x81, 0xa6, 0x3d, 0x8f, 0x7d, 0xcb, 0xe5, 0x15, 0xda, 0xd4,
+        0x1d, 0x9f, 0x61, 0xd9, 0xdd, 0xcc, 0x7f, 0xaf, 0x4f, 0x0f, 0xaa, 0xd3, 0x9d, 0xc7, 0xbe, 0xe1,
+        0x1c, 0x22, 0x72, 0xa7, 0x2a, 0x93, 0x12, 0x5d, 0xb1, 0x33, 0x64, 0xed, 0xc7, 0xb0, 0x92, 0x85,
+        0xf1, 0x04, 0x24, 0x81, 0xea, 0x1b, 0x3c, 0x3b, 0x8d, 0x78, 0x6a, 0x1b, 0x98, 0x46, 0xb7, 0xaf,
+        0x16, 0xb4, 0x18, 0x1a, 0xb8, 0xbc, 0xf4, 0x8e, 0xeb, 0xba, 0xfd, 0x03, 0x28, 0x61, 0xf8, 0x55,
+        0x2e, 0x7c, 0x0f, 0xc1, 0x98, 0x8b, 0xcc, 0xbc, 0xf9, 0x15, 0xb3, 0xe6, 0xf7, 0xdf, 0x05, 0x58,
+        0x31, 0xfd, 0xf9, 0xf8, 0xe4, 0xa2, 0x01, 0xc2, 0xaf, 0x3b, 0x42, 0x2d, 0x31, 0x1f, 0xe5, 0xa6,
+        0xe6, 0x93, 0x5a, 0x47, 0x71, 0x89, 0x75, 0xdc, 0xf4, 0xcc, 0xb5, 0x2f, 0x60, 0x55, 0x6e, 0x5e,
+        0x6a, 0x3d, 0xd1, 0x66, 0xe1, 0x0a, 0x6d, 0x6a, 0xbf, 0x50, 0x60, 0x55, 0xc4, 0xf7, 0xff, 0xbb,
+        0xd2, 0x2a, 0x37, 0x0c, 0xeb, 0xe5, 0x1b, 0x5d, 0x1e, 0xfd, 0xbf, 0xf4, 0x34, 0x6d, 0x08, 0xcd,
+        0x44, 0x7d, 0x37, 0x50, 0xfb, 0x15, 0x46, 0xfc, 0x8b, 0x02, 0x34, 0x06, 0xec, 0xe5, 0x92, 0x20,
+        0x5a, 0xbe, 0xee, 0x71, 0x7c, 0x98, 0x2b, 0x57, 0x1b, 0xdb, 0xeb, 0x59, 0x19, 0xc4, 0xd5, 0x63,
+        0x52, 0xc1, 0xa6, 0xb7, 0xa8, 0xca, 0xf2, 0x5b, 0xd4, 0xd2, 0x62, 0xb7, 0x9e, 0xb9, 0xc5, 0x2b,
+        0x2e, 0xbb, 0xc5, 0xd3, 0xfe, 0xad, 0x08, 0x0d, 0x6c, 0x90, 0x29, 0x8b, 0xe6, 0xd3, 0x38, 0x27,
+        0x4c, 0xe1, 0x6a, 0x61, 0x3a, 0x50, 0x09, 0x71, 0x92, 0x74, 0xa5, 0x4b, 0x83, 0xbf, 0x40, 0x61,
+        0x6b, 0xfc, 0xdc, 0x0d, 0x02, 0xe6, 0x58, 0x82, 0x92, 0x14, 0x30, 0x4d, 0x49, 0x16, 0x22, 0x44,
+        0xbc, 0xfc, 0x9c, 0xf9, 0x21, 0x4b, 0x51, 0x45, 0xbc, 0x4f, 0x68, 0x70, 0x5a, 0x02, 0xc9, 0xdd,
+        0x37, 0x88, 0xca, 0xe0, 0xfc, 0xbe, 0x21, 0xed, 0x35, 0x91, 0x5b, 0x47, 0xae, 0xe8, 0x35, 0x91,
+        0xcd, 0xbb, 0xa8, 0x99, 0x3d, 0x9d, 0x5a, 0x7e, 0x10, 0xa1, 0xd3, 0xd4, 0x68, 0x0d, 0x09, 0xc3,
+        0x20, 0x22, 0x5f, 0x43, 0x7a, 0x5d, 0x2c, 0x6f, 0xc9, 0xc5, 0x39, 0xb6, 0x2e, 0xbb, 0x58, 0xa0,
+        0xab, 0xe3, 0xdc, 0xfd, 0xcf, 0x92, 0x1b, 0xea, 0xca, 0x4d, 0x6f, 0xa8, 0x1f, 0x42, 0x59, 0xc4,
+        0xa8, 0xda, 0xeb, 0x62, 0x94, 0xc0, 0x65, 0xed, 0xb3, 0x91, 0xb7, 0xcf, 0x5f, 0x16, 0x80, 0x74,
+        0xa7, 0x53, 0x7f, 0x6c, 0xc7, 0xcc, 0x70, 0xa2, 0x8b, 0x66, 0x7a, 0xed, 0xcf, 0x2e, 0x9f, 0x41,
+        0x7d, 0xe6, 0x3b, 0x6c, 0x6a, 0x25, 0xdf, 0x94, 0x2e, 0xad, 0x7e, 0x10, 0xc6, 0x5b, 0x52, 0x02,
+        0x25, 0xbc, 0xc4, 0x51, 0xb0, 0xee, 0xc0, 0x67, 0xde, 0x84, 0xcd, 0xec, 0x97, 0xb2, 0x14, 0xe1,
+        0x8f, 0xa4, 0x03, 0xd5, 0x90, 0x45, 0x2c, 0x3c, 0x65, 0x57, 0x16, 0x55, 0x09, 0x48, 0x7b, 0x06,
+        0x1b, 0xb9, 0x1d, 0x49, 0x47, 0xbe, 0x85, 0x5f, 0x2b, 0xc3, 0x58, 0x7e, 0xb4, 0x12, 0x03, 0xfe,
+        0x3a, 0xe6, 0x25, 0x9f, 0x41, 0xf9, 0x63, 0xea, 0xf0, 0xc5, 0xab, 0xe2, 0xec, 0x1e, 0xa8, 0x59,
+        0x4d, 0xbb, 0x63, 0x0c, 0x36, 0xf2, 0x54, 0x0a, 0xd7, 0x3b, 0x15, 0xed, 0xef, 0x0a, 0xb0, 0xde,
+        0x75, 0x1c, 0xf1, 0x77, 0xc3, 0x25, 0xaa, 0x2f, 0x5e, 0x57, 0xf5, 0x0b, 0x81, 0x58, 0x84, 0x89,
+        0x6b, 0x05, 0xe2, 0x0f, 0xa1, 0x92, 0xd6, 0x5a, 0xc5, 0x05, 0x77, 0x16, 0x72, 0x51, 0x09, 0xd0,
+        0x6e, 0x01, 0xc9, 0x0a, 0x2b, 0xb4, 0xaa, 0xfd, 0x69, 0x11, 0xee, 0xee, 0xb2, 0x63, 0xd7, 0xcb,
+        0xbe, 0xe2, 0x57, 0xdf, 0xc9, 0xc5, 0x4f, 0x65, 0x9f, 0xc1, 0xba, 0x28, 0xe4, 0x93, 0x7f, 0x62,
+        0x59, 0xec, 0x58, 0x7e, 0x9d, 0x94, 0xb1, 0x6a, 0x0d, 0xf9, 0x07, 0x92, 0xad, 0xe3, 0x7f, 0xc5,
+        0x1c, 0x3b, 0xb6, 0x9f, 0xd9, 0x11, 0xb3, 0x5c, 0x47, 0xfe, 0x59, 0x06, 0x12, 0x92, 0xe1, 0x90,
+        0x21, 0x94, 0xb8, 0x0d, 0xa2, 0xeb, 0x36, 0xb7, 0xb7, 0x33, 0x62, 0x5d, 0xb2, 0x95, 0xac, 0x02,
+        0x0f, 0x7c, 0x87, 0xed, 0x54, 0x8f, 0x06, 0x4f, 0x06, 0xc3, 0xef, 0x06, 0x14, 0x17, 0x22, 0x06,
+        0xdc, 0x0a, 0x42, 0x76, 0xea, 0xfa, 0xf3, 0xc8, 0xca, 0x9e, 0x44, 0xf5, 0xca, 0x94, 0xb8, 0x91,
+        0xcc, 0xc9, 0x10, 0xb5, 0x9f, 0xc2, 0xda, 0xc2, 0xcb, 0x78, 0x6d, 0x26, 0x5f, 0xa7, 0xbe, 0x41,
+        0x56, 0xa1, 0x8e, 0x1f, 0xbb, 0x97, 0x7f, 0xfb, 0xd6, 0xfe, 0xb5, 0x80, 0x57, 0x4c, 0x33, 0x37,
+        0xbe, 0x59, 0x06, 0xfb, 0xcd, 0x7c, 0x06, 0x83, 0xed, 0x77, 0xf3, 0xe6, 0x9b, 0x59, 0xb0, 0xf3,
+        0xad, 0x00, 0xa6, 0x41, 0xa4, 0x6d, 0x43, 0x55, 0xd2, 0xc8, 0x6f, 0xc1, 0x5a, 0xe8, 0xfb, 0x71,
+        0xd2, 0x89, 0x8a, 0x0e, 0xe4, 0xf2, 0x3f, 0xdb, 0xac, 0x72, 0xb0, 0x48, 0x06, 0x4f, 0xf2, 0xbd,
+        0x48, 0x59, 0xfc, 0x0d, 0x44, 0x0e, 0x77, 0x1b, 0xbf, 0x5b, 0x4f, 0xff, 0xb7, 0xfb, 0xbf, 0x01,
+        0x00, 0x00, 0xff, 0xff, 0x35, 0x9f, 0x30, 0x98, 0xf2, 0x2b, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.proto b/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.proto
new file mode 100644
index 0000000..497b4d9
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.proto
@@ -0,0 +1,551 @@
+syntax = "proto2";
+option go_package = "datastore";
+
+package appengine;
+
+message Action{}
+
+message PropertyValue {
+  optional int64 int64Value = 1;
+  optional bool booleanValue = 2;
+  optional string stringValue = 3;
+  optional double doubleValue = 4;
+
+  optional group PointValue = 5 {
+    required double x = 6;
+    required double y = 7;
+  }
+
+  optional group UserValue = 8 {
+    required string email = 9;
+    required string auth_domain = 10;
+    optional string nickname = 11;
+    optional string federated_identity = 21;
+    optional string federated_provider = 22;
+  }
+
+  optional group ReferenceValue = 12 {
+    required string app = 13;
+    optional string name_space = 20;
+    repeated group PathElement = 14 {
+      required string type = 15;
+      optional int64 id = 16;
+      optional string name = 17;
+    }
+  }
+}
+
+message Property {
+  enum Meaning {
+    NO_MEANING = 0;
+    BLOB = 14;
+    TEXT = 15;
+    BYTESTRING = 16;
+
+    ATOM_CATEGORY = 1;
+    ATOM_LINK = 2;
+    ATOM_TITLE = 3;
+    ATOM_CONTENT = 4;
+    ATOM_SUMMARY = 5;
+    ATOM_AUTHOR = 6;
+
+    GD_WHEN = 7;
+    GD_EMAIL = 8;
+    GEORSS_POINT = 9;
+    GD_IM = 10;
+
+    GD_PHONENUMBER = 11;
+    GD_POSTALADDRESS = 12;
+
+    GD_RATING = 13;
+
+    BLOBKEY = 17;
+    ENTITY_PROTO = 19;
+
+    INDEX_VALUE = 18;
+  };
+
+  optional Meaning meaning = 1 [default = NO_MEANING];
+  optional string meaning_uri = 2;
+
+  required string name = 3;
+
+  required PropertyValue value = 5;
+
+  required bool multiple = 4;
+
+  optional bool searchable = 6 [default=false];
+
+  enum FtsTokenizationOption {
+    HTML = 1;
+    ATOM = 2;
+  }
+
+  optional FtsTokenizationOption fts_tokenization_option = 8;
+
+  optional string locale = 9 [default = "en"];
+}
+
+message Path {
+  repeated group Element = 1 {
+    required string type = 2;
+    optional int64 id = 3;
+    optional string name = 4;
+  }
+}
+
+message Reference {
+  required string app = 13;
+  optional string name_space = 20;
+  required Path path = 14;
+}
+
+message User {
+  required string email = 1;
+  required string auth_domain = 2;
+  optional string nickname = 3;
+  optional string federated_identity = 6;
+  optional string federated_provider = 7;
+}
+
+message EntityProto {
+  required Reference key = 13;
+  required Path entity_group = 16;
+  optional User owner = 17;
+
+  enum Kind {
+    GD_CONTACT = 1;
+    GD_EVENT = 2;
+    GD_MESSAGE = 3;
+  }
+  optional Kind kind = 4;
+  optional string kind_uri = 5;
+
+  repeated Property property = 14;
+  repeated Property raw_property = 15;
+
+  optional int32 rank = 18;
+}
+
+message CompositeProperty {
+  required int64 index_id = 1;
+  repeated string value = 2;
+}
+
+message Index {
+  required string entity_type = 1;
+  required bool ancestor = 5;
+  repeated group Property = 2 {
+    required string name = 3;
+    enum Direction {
+      ASCENDING = 1;
+      DESCENDING = 2;
+    }
+    optional Direction direction = 4 [default = ASCENDING];
+  }
+}
+
+message CompositeIndex {
+  required string app_id = 1;
+  required int64 id = 2;
+  required Index definition = 3;
+
+  enum State {
+    WRITE_ONLY = 1;
+    READ_WRITE = 2;
+    DELETED = 3;
+    ERROR = 4;
+  }
+  required State state = 4;
+
+  optional bool only_use_if_required = 6 [default = false];
+}
+
+message IndexPostfix {
+  message IndexValue {
+    required string property_name = 1;
+    required PropertyValue value = 2;
+  }
+
+  repeated IndexValue index_value = 1;
+
+  optional Reference key = 2;
+
+  optional bool before = 3 [default=true];
+}
+
+message IndexPosition {
+  optional string key = 1;
+
+  optional bool before = 2 [default=true];
+}
+
+message Snapshot {
+  enum Status {
+    INACTIVE = 0;
+    ACTIVE = 1;
+  }
+
+  required int64 ts = 1;
+}
+
+message InternalHeader {
+  optional string qos = 1;
+}
+
+message Transaction {
+  optional InternalHeader header = 4;
+  required fixed64 handle = 1;
+  required string app = 2;
+  optional bool mark_changes = 3 [default = false];
+}
+
+message Query {
+  optional InternalHeader header = 39;
+
+  required string app = 1;
+  optional string name_space = 29;
+
+  optional string kind = 3;
+  optional Reference ancestor = 17;
+
+  repeated group Filter = 4 {
+    enum Operator {
+      LESS_THAN = 1;
+      LESS_THAN_OR_EQUAL = 2;
+      GREATER_THAN = 3;
+      GREATER_THAN_OR_EQUAL = 4;
+      EQUAL = 5;
+      IN = 6;
+      EXISTS = 7;
+    }
+
+    required Operator op = 6;
+    repeated Property property = 14;
+  }
+
+  optional string search_query = 8;
+
+  repeated group Order = 9 {
+    enum Direction {
+      ASCENDING = 1;
+      DESCENDING = 2;
+    }
+
+    required string property = 10;
+    optional Direction direction = 11 [default = ASCENDING];
+  }
+
+  enum Hint {
+    ORDER_FIRST = 1;
+    ANCESTOR_FIRST = 2;
+    FILTER_FIRST = 3;
+  }
+  optional Hint hint = 18;
+
+  optional int32 count = 23;
+
+  optional int32 offset = 12 [default = 0];
+
+  optional int32 limit = 16;
+
+  optional CompiledCursor compiled_cursor = 30;
+  optional CompiledCursor end_compiled_cursor = 31;
+
+  repeated CompositeIndex composite_index = 19;
+
+  optional bool require_perfect_plan = 20 [default = false];
+
+  optional bool keys_only = 21 [default = false];
+
+  optional Transaction transaction = 22;
+
+  optional bool compile = 25 [default = false];
+
+  optional int64 failover_ms = 26;
+
+  optional bool strong = 32;
+
+  repeated string property_name = 33;
+
+  repeated string group_by_property_name = 34;
+
+  optional bool distinct = 24;
+
+  optional int64 min_safe_time_seconds = 35;
+
+  repeated string safe_replica_name = 36;
+
+  optional bool persist_offset = 37 [default=false];
+}
+
+message CompiledQuery {
+  required group PrimaryScan = 1 {
+    optional string index_name = 2;
+
+    optional string start_key = 3;
+    optional bool start_inclusive = 4;
+    optional string end_key = 5;
+    optional bool end_inclusive = 6;
+
+    repeated string start_postfix_value = 22;
+    repeated string end_postfix_value = 23;
+
+    optional int64 end_unapplied_log_timestamp_us = 19;
+  }
+
+  repeated group MergeJoinScan = 7 {
+    required string index_name = 8;
+
+    repeated string prefix_value = 9;
+
+    optional bool value_prefix = 20 [default=false];
+  }
+
+  optional Index index_def = 21;
+
+  optional int32 offset = 10 [default = 0];
+
+  optional int32 limit = 11;
+
+  required bool keys_only = 12;
+
+  repeated string property_name = 24;
+
+  optional int32 distinct_infix_size = 25;
+
+  optional group EntityFilter = 13 {
+    optional bool distinct = 14 [default=false];
+
+    optional string kind = 17;
+    optional Reference ancestor = 18;
+  }
+}
+
+message CompiledCursor {
+  optional group Position = 2 {
+    optional string start_key = 27;
+
+    repeated group IndexValue = 29 {
+      optional string property = 30;
+      required PropertyValue value = 31;
+    }
+
+    optional Reference key = 32;
+
+    optional bool start_inclusive = 28 [default=true];
+  }
+}
+
+message Cursor {
+  required fixed64 cursor = 1;
+
+  optional string app = 2;
+}
+
+message Error {
+  enum ErrorCode {
+    BAD_REQUEST = 1;
+    CONCURRENT_TRANSACTION = 2;
+    INTERNAL_ERROR = 3;
+    NEED_INDEX = 4;
+    TIMEOUT = 5;
+    PERMISSION_DENIED = 6;
+    BIGTABLE_ERROR = 7;
+    COMMITTED_BUT_STILL_APPLYING = 8;
+    CAPABILITY_DISABLED = 9;
+    TRY_ALTERNATE_BACKEND = 10;
+    SAFE_TIME_TOO_OLD = 11;
+  }
+}
+
+message Cost {
+  optional int32 index_writes = 1;
+  optional int32 index_write_bytes = 2;
+  optional int32 entity_writes = 3;
+  optional int32 entity_write_bytes = 4;
+  optional group CommitCost = 5 {
+    optional int32 requested_entity_puts = 6;
+    optional int32 requested_entity_deletes = 7;
+  };
+  optional int32 approximate_storage_delta = 8;
+  optional int32 id_sequence_updates = 9;
+}
+
+message GetRequest {
+  optional InternalHeader header = 6;
+
+  repeated Reference key = 1;
+  optional Transaction transaction = 2;
+
+  optional int64 failover_ms = 3;
+
+  optional bool strong = 4;
+
+  optional bool allow_deferred = 5 [default=false];
+}
+
+message GetResponse {
+  repeated group Entity = 1 {
+    optional EntityProto entity = 2;
+    optional Reference key = 4;
+
+    optional int64 version = 3;
+  }
+
+  repeated Reference deferred = 5;
+
+  optional bool in_order = 6 [default=true];
+}
+
+message PutRequest {
+  optional InternalHeader header = 11;
+
+  repeated EntityProto entity = 1;
+  optional Transaction transaction = 2;
+  repeated CompositeIndex composite_index = 3;
+
+  optional bool trusted = 4 [default = false];
+
+  optional bool force = 7 [default = false];
+
+  optional bool mark_changes = 8 [default = false];
+  repeated Snapshot snapshot = 9;
+
+  enum AutoIdPolicy {
+    CURRENT = 0;
+    SEQUENTIAL = 1;
+  }
+  optional AutoIdPolicy auto_id_policy = 10 [default = CURRENT];
+}
+
+message PutResponse {
+  repeated Reference key = 1;
+  optional Cost cost = 2;
+  repeated int64 version = 3;
+}
+
+message TouchRequest {
+  optional InternalHeader header = 10;
+
+  repeated Reference key = 1;
+  repeated CompositeIndex composite_index = 2;
+  optional bool force = 3 [default = false];
+  repeated Snapshot snapshot = 9;
+}
+
+message TouchResponse {
+  optional Cost cost = 1;
+}
+
+message DeleteRequest {
+  optional InternalHeader header = 10;
+
+  repeated Reference key = 6;
+  optional Transaction transaction = 5;
+
+  optional bool trusted = 4 [default = false];
+
+  optional bool force = 7 [default = false];
+
+  optional bool mark_changes = 8 [default = false];
+  repeated Snapshot snapshot = 9;
+}
+
+message DeleteResponse {
+  optional Cost cost = 1;
+  repeated int64 version = 3;
+}
+
+message NextRequest {
+  optional InternalHeader header = 5;
+
+  required Cursor cursor = 1;
+  optional int32 count = 2;
+
+  optional int32 offset = 4 [default = 0];
+
+  optional bool compile = 3 [default = false];
+}
+
+message QueryResult {
+  optional Cursor cursor = 1;
+
+  repeated EntityProto result = 2;
+
+  optional int32 skipped_results = 7;
+
+  required bool more_results = 3;
+
+  optional bool keys_only = 4;
+
+  optional bool index_only = 9;
+
+  optional bool small_ops = 10;
+
+  optional CompiledQuery compiled_query = 5;
+
+  optional CompiledCursor compiled_cursor = 6;
+
+  repeated CompositeIndex index = 8;
+
+  repeated int64 version = 11;
+}
+
+message AllocateIdsRequest {
+  optional InternalHeader header = 4;
+
+  optional Reference model_key = 1;
+
+  optional int64 size = 2;
+
+  optional int64 max = 3;
+
+  repeated Reference reserve = 5;
+}
+
+message AllocateIdsResponse {
+  required int64 start = 1;
+  required int64 end = 2;
+  optional Cost cost = 3;
+}
+
+message CompositeIndices {
+  repeated CompositeIndex index = 1;
+}
+
+message AddActionsRequest {
+  optional InternalHeader header = 3;
+
+  required Transaction transaction = 1;
+  repeated Action action = 2;
+}
+
+message AddActionsResponse {
+}
+
+message BeginTransactionRequest {
+  optional InternalHeader header = 3;
+
+  required string app = 1;
+  optional bool allow_multiple_eg = 2 [default = false];
+  optional string database_id = 4;
+
+  enum TransactionMode {
+    UNKNOWN = 0;
+    READ_ONLY = 1;
+    READ_WRITE = 2;
+  }
+  optional TransactionMode mode = 5 [default = UNKNOWN];
+
+  optional Transaction previous_transaction = 7;
+}
+
+message CommitResponse {
+  optional Cost cost = 1;
+
+  repeated group Version = 3 {
+    required Reference root_entity_key = 4;
+    required int64 version = 5;
+  }
+}
diff --git a/vendor/google.golang.org/appengine/internal/identity.go b/vendor/google.golang.org/appengine/internal/identity.go
new file mode 100644
index 0000000..9b4134e
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/identity.go
@@ -0,0 +1,55 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package internal
+
+import (
+        "os"
+
+        netcontext "golang.org/x/net/context"
+)
+
+var (
+        // This is set to true in identity_classic.go, which is behind the appengine build tag.
+        // The appengine build tag is set for the first generation runtimes (<= Go 1.9) but not
+        // the second generation runtimes (>= Go 1.11), so this indicates whether we're on a
+        // first-gen runtime. See IsStandard below for the second-gen check.
+        appengineStandard bool
+
+        // This is set to true in identity_flex.go, which is behind the appenginevm build tag.
+        appengineFlex bool
+)
+
+// AppID is the implementation of the wrapper function of the same name in
+// ../identity.go. See that file for commentary.
+func AppID(c netcontext.Context) string {
+        return appID(FullyQualifiedAppID(c))
+}
+
+// IsStandard is the implementation of the wrapper function of the same name in
+// ../appengine.go. See that file for commentary.
+func IsStandard() bool {
+        // appengineStandard will be true for first-gen runtimes (<= Go 1.9) but not
+        // second-gen (>= Go 1.11).
+        return appengineStandard || IsSecondGen()
+}
+
+// IsStandard is the implementation of the wrapper function of the same name in
+// ../appengine.go. See that file for commentary.
+func IsSecondGen() bool {
+        // Second-gen runtimes set $GAE_ENV so we use that to check if we're on a second-gen runtime.
+        return os.Getenv("GAE_ENV") == "standard"
+}
+
+// IsFlex is the implementation of the wrapper function of the same name in
+// ../appengine.go. See that file for commentary.
+func IsFlex() bool {
+        return appengineFlex
+}
+
+// IsAppEngine is the implementation of the wrapper function of the same name in
+// ../appengine.go. See that file for commentary.
+func IsAppEngine() bool {
+        return IsStandard() || IsFlex()
+}
diff --git a/vendor/google.golang.org/appengine/internal/identity_classic.go b/vendor/google.golang.org/appengine/internal/identity_classic.go
new file mode 100644
index 0000000..4e979f4
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/identity_classic.go
@@ -0,0 +1,61 @@
+// Copyright 2015 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build appengine
+
+package internal
+
+import (
+        "appengine"
+
+        netcontext "golang.org/x/net/context"
+)
+
+func init() {
+        appengineStandard = true
+}
+
+func DefaultVersionHostname(ctx netcontext.Context) string {
+        c := fromContext(ctx)
+        if c == nil {
+                panic(errNotAppEngineContext)
+        }
+        return appengine.DefaultVersionHostname(c)
+}
+
+func Datacenter(_ netcontext.Context) string { return appengine.Datacenter() }
+func ServerSoftware() string                 { return appengine.ServerSoftware() }
+func InstanceID() string                     { return appengine.InstanceID() }
+func IsDevAppServer() bool                   { return appengine.IsDevAppServer() }
+
+func RequestID(ctx netcontext.Context) string {
+        c := fromContext(ctx)
+        if c == nil {
+                panic(errNotAppEngineContext)
+        }
+        return appengine.RequestID(c)
+}
+
+func ModuleName(ctx netcontext.Context) string {
+        c := fromContext(ctx)
+        if c == nil {
+                panic(errNotAppEngineContext)
+        }
+        return appengine.ModuleName(c)
+}
+func VersionID(ctx netcontext.Context) string {
+        c := fromContext(ctx)
+        if c == nil {
+                panic(errNotAppEngineContext)
+        }
+        return appengine.VersionID(c)
+}
+
+func fullyQualifiedAppID(ctx netcontext.Context) string {
+        c := fromContext(ctx)
+        if c == nil {
+                panic(errNotAppEngineContext)
+        }
+        return c.FullyQualifiedAppID()
+}
diff --git a/vendor/google.golang.org/appengine/internal/identity_flex.go b/vendor/google.golang.org/appengine/internal/identity_flex.go
new file mode 100644
index 0000000..d5e2e7b
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/identity_flex.go
@@ -0,0 +1,11 @@
+// Copyright 2018 Google LLC. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build appenginevm
+
+package internal
+
+func init() {
+        appengineFlex = true
+}
diff --git a/vendor/google.golang.org/appengine/internal/identity_vm.go b/vendor/google.golang.org/appengine/internal/identity_vm.go
new file mode 100644
index 0000000..5d80672
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/identity_vm.go
@@ -0,0 +1,134 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build !appengine
+
+package internal
+
+import (
+        "log"
+        "net/http"
+        "os"
+        "strings"
+
+        netcontext "golang.org/x/net/context"
+)
+
+// These functions are implementations of the wrapper functions
+// in ../appengine/identity.go. See that file for commentary.
+
+const (
+        hDefaultVersionHostname = "X-AppEngine-Default-Version-Hostname"
+        hRequestLogId           = "X-AppEngine-Request-Log-Id"
+        hDatacenter             = "X-AppEngine-Datacenter"
+)
+
+func ctxHeaders(ctx netcontext.Context) http.Header {
+        c := fromContext(ctx)
+        if c == nil {
+                return nil
+        }
+        return c.Request().Header
+}
+
+func DefaultVersionHostname(ctx netcontext.Context) string {
+        return ctxHeaders(ctx).Get(hDefaultVersionHostname)
+}
+
+func RequestID(ctx netcontext.Context) string {
+        return ctxHeaders(ctx).Get(hRequestLogId)
+}
+
+func Datacenter(ctx netcontext.Context) string {
+        if dc := ctxHeaders(ctx).Get(hDatacenter); dc != "" {
+                return dc
+        }
+        // If the header isn't set, read zone from the metadata service.
+        // It has the format projects/[NUMERIC_PROJECT_ID]/zones/[ZONE]
+        zone, err := getMetadata("instance/zone")
+        if err != nil {
+                log.Printf("Datacenter: %v", err)
+                return ""
+        }
+        parts := strings.Split(string(zone), "/")
+        if len(parts) == 0 {
+                return ""
+        }
+        return parts[len(parts)-1]
+}
+
+func ServerSoftware() string {
+        // TODO(dsymonds): Remove fallback when we've verified this.
+        if s := os.Getenv("SERVER_SOFTWARE"); s != "" {
+                return s
+        }
+        if s := os.Getenv("GAE_ENV"); s != "" {
+                return s
+        }
+        return "Google App Engine/1.x.x"
+}
+
+// TODO(dsymonds): Remove the metadata fetches.
+
+func ModuleName(_ netcontext.Context) string {
+        if s := os.Getenv("GAE_MODULE_NAME"); s != "" {
+                return s
+        }
+        if s := os.Getenv("GAE_SERVICE"); s != "" {
+                return s
+        }
+        return string(mustGetMetadata("instance/attributes/gae_backend_name"))
+}
+
+func VersionID(_ netcontext.Context) string {
+        if s1, s2 := os.Getenv("GAE_MODULE_VERSION"), os.Getenv("GAE_MINOR_VERSION"); s1 != "" && s2 != "" {
+                return s1 + "." + s2
+        }
+        if s1, s2 := os.Getenv("GAE_VERSION"), os.Getenv("GAE_DEPLOYMENT_ID"); s1 != "" && s2 != "" {
+                return s1 + "." + s2
+        }
+        return string(mustGetMetadata("instance/attributes/gae_backend_version")) + "." + string(mustGetMetadata("instance/attributes/gae_backend_minor_version"))
+}
+
+func InstanceID() string {
+        if s := os.Getenv("GAE_MODULE_INSTANCE"); s != "" {
+                return s
+        }
+        if s := os.Getenv("GAE_INSTANCE"); s != "" {
+                return s
+        }
+        return string(mustGetMetadata("instance/attributes/gae_backend_instance"))
+}
+
+func partitionlessAppID() string {
+        // gae_project has everything except the partition prefix.
+        if appID := os.Getenv("GAE_LONG_APP_ID"); appID != "" {
+                return appID
+        }
+        if project := os.Getenv("GOOGLE_CLOUD_PROJECT"); project != "" {
+                return project
+        }
+        return string(mustGetMetadata("instance/attributes/gae_project"))
+}
+
+func fullyQualifiedAppID(_ netcontext.Context) string {
+        if s := os.Getenv("GAE_APPLICATION"); s != "" {
+                return s
+        }
+        appID := partitionlessAppID()
+
+        part := os.Getenv("GAE_PARTITION")
+        if part == "" {
+                part = string(mustGetMetadata("instance/attributes/gae_partition"))
+        }
+
+        if part != "" {
+                appID = part + "~" + appID
+        }
+        return appID
+}
+
+func IsDevAppServer() bool {
+        return os.Getenv("RUN_WITH_DEVAPPSERVER") != ""
+}
diff --git a/vendor/google.golang.org/appengine/internal/internal.go b/vendor/google.golang.org/appengine/internal/internal.go
new file mode 100644
index 0000000..051ea39
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/internal.go
@@ -0,0 +1,110 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// Package internal provides support for package appengine.
+//
+// Programs should not use this package directly. Its API is not stable.
+// Use packages appengine and appengine/* instead.
+package internal
+
+import (
+        "fmt"
+
+        "github.com/golang/protobuf/proto"
+
+        remotepb "google.golang.org/appengine/internal/remote_api"
+)
+
+// errorCodeMaps is a map of service name to the error code map for the service.
+var errorCodeMaps = make(map[string]map[int32]string)
+
+// RegisterErrorCodeMap is called from API implementations to register their
+// error code map. This should only be called from init functions.
+func RegisterErrorCodeMap(service string, m map[int32]string) {
+        errorCodeMaps[service] = m
+}
+
+type timeoutCodeKey struct {
+        service string
+        code    int32
+}
+
+// timeoutCodes is the set of service+code pairs that represent timeouts.
+var timeoutCodes = make(map[timeoutCodeKey]bool)
+
+func RegisterTimeoutErrorCode(service string, code int32) {
+        timeoutCodes[timeoutCodeKey{service, code}] = true
+}
+
+// APIError is the type returned by appengine.Context's Call method
+// when an API call fails in an API-specific way. This may be, for instance,
+// a taskqueue API call failing with TaskQueueServiceError::UNKNOWN_QUEUE.
+type APIError struct {
+        Service string
+        Detail  string
+        Code    int32 // API-specific error code
+}
+
+func (e *APIError) Error() string {
+        if e.Code == 0 {
+                if e.Detail == "" {
+                        return "APIError <empty>"
+                }
+                return e.Detail
+        }
+        s := fmt.Sprintf("API error %d", e.Code)
+        if m, ok := errorCodeMaps[e.Service]; ok {
+                s += " (" + e.Service + ": " + m[e.Code] + ")"
+        } else {
+                // Shouldn't happen, but provide a bit more detail if it does.
+                s = e.Service + " " + s
+        }
+        if e.Detail != "" {
+                s += ": " + e.Detail
+        }
+        return s
+}
+
+func (e *APIError) IsTimeout() bool {
+        return timeoutCodes[timeoutCodeKey{e.Service, e.Code}]
+}
+
+// CallError is the type returned by appengine.Context's Call method when an
+// API call fails in a generic way, such as RpcError::CAPABILITY_DISABLED.
+type CallError struct {
+        Detail string
+        Code   int32
+        // TODO: Remove this if we get a distinguishable error code.
+        Timeout bool
+}
+
+func (e *CallError) Error() string {
+        var msg string
+        switch remotepb.RpcError_ErrorCode(e.Code) {
+        case remotepb.RpcError_UNKNOWN:
+                return e.Detail
+        case remotepb.RpcError_OVER_QUOTA:
+                msg = "Over quota"
+        case remotepb.RpcError_CAPABILITY_DISABLED:
+                msg = "Capability disabled"
+        case remotepb.RpcError_CANCELLED:
+                msg = "Canceled"
+        default:
+                msg = fmt.Sprintf("Call error %d", e.Code)
+        }
+        s := msg + ": " + e.Detail
+        if e.Timeout {
+                s += " (timeout)"
+        }
+        return s
+}
+
+func (e *CallError) IsTimeout() bool {
+        return e.Timeout
+}
+
+// NamespaceMods is a map from API service to a function that will mutate an RPC request to attach a namespace.
+// The function should be prepared to be called on the same message more than once; it should only modify the
+// RPC request the first time.
+var NamespaceMods = make(map[string]func(m proto.Message, namespace string))
diff --git a/vendor/google.golang.org/appengine/internal/log/log_service.pb.go b/vendor/google.golang.org/appengine/internal/log/log_service.pb.go
new file mode 100644
index 0000000..8545ac4
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/log/log_service.pb.go
@@ -0,0 +1,1313 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google.golang.org/appengine/internal/log/log_service.proto
+
+package log
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// 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
+
+type LogServiceError_ErrorCode int32
+
+const (
+        LogServiceError_OK              LogServiceError_ErrorCode = 0
+        LogServiceError_INVALID_REQUEST LogServiceError_ErrorCode = 1
+        LogServiceError_STORAGE_ERROR   LogServiceError_ErrorCode = 2
+)
+
+var LogServiceError_ErrorCode_name = map[int32]string{
+        0: "OK",
+        1: "INVALID_REQUEST",
+        2: "STORAGE_ERROR",
+}
+var LogServiceError_ErrorCode_value = map[string]int32{
+        "OK":              0,
+        "INVALID_REQUEST": 1,
+        "STORAGE_ERROR":   2,
+}
+
+func (x LogServiceError_ErrorCode) Enum() *LogServiceError_ErrorCode {
+        p := new(LogServiceError_ErrorCode)
+        *p = x
+        return p
+}
+func (x LogServiceError_ErrorCode) String() string {
+        return proto.EnumName(LogServiceError_ErrorCode_name, int32(x))
+}
+func (x *LogServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(LogServiceError_ErrorCode_value, data, "LogServiceError_ErrorCode")
+        if err != nil {
+                return err
+        }
+        *x = LogServiceError_ErrorCode(value)
+        return nil
+}
+func (LogServiceError_ErrorCode) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{0, 0}
+}
+
+type LogServiceError struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *LogServiceError) Reset()         { *m = LogServiceError{} }
+func (m *LogServiceError) String() string { return proto.CompactTextString(m) }
+func (*LogServiceError) ProtoMessage()    {}
+func (*LogServiceError) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{0}
+}
+func (m *LogServiceError) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_LogServiceError.Unmarshal(m, b)
+}
+func (m *LogServiceError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_LogServiceError.Marshal(b, m, deterministic)
+}
+func (dst *LogServiceError) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_LogServiceError.Merge(dst, src)
+}
+func (m *LogServiceError) XXX_Size() int {
+        return xxx_messageInfo_LogServiceError.Size(m)
+}
+func (m *LogServiceError) XXX_DiscardUnknown() {
+        xxx_messageInfo_LogServiceError.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LogServiceError proto.InternalMessageInfo
+
+type UserAppLogLine struct {
+        TimestampUsec        *int64   `protobuf:"varint,1,req,name=timestamp_usec,json=timestampUsec" json:"timestamp_usec,omitempty"`
+        Level                *int64   `protobuf:"varint,2,req,name=level" json:"level,omitempty"`
+        Message              *string  `protobuf:"bytes,3,req,name=message" json:"message,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *UserAppLogLine) Reset()         { *m = UserAppLogLine{} }
+func (m *UserAppLogLine) String() string { return proto.CompactTextString(m) }
+func (*UserAppLogLine) ProtoMessage()    {}
+func (*UserAppLogLine) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{1}
+}
+func (m *UserAppLogLine) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_UserAppLogLine.Unmarshal(m, b)
+}
+func (m *UserAppLogLine) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_UserAppLogLine.Marshal(b, m, deterministic)
+}
+func (dst *UserAppLogLine) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_UserAppLogLine.Merge(dst, src)
+}
+func (m *UserAppLogLine) XXX_Size() int {
+        return xxx_messageInfo_UserAppLogLine.Size(m)
+}
+func (m *UserAppLogLine) XXX_DiscardUnknown() {
+        xxx_messageInfo_UserAppLogLine.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UserAppLogLine proto.InternalMessageInfo
+
+func (m *UserAppLogLine) GetTimestampUsec() int64 {
+        if m != nil && m.TimestampUsec != nil {
+                return *m.TimestampUsec
+        }
+        return 0
+}
+
+func (m *UserAppLogLine) GetLevel() int64 {
+        if m != nil && m.Level != nil {
+                return *m.Level
+        }
+        return 0
+}
+
+func (m *UserAppLogLine) GetMessage() string {
+        if m != nil && m.Message != nil {
+                return *m.Message
+        }
+        return ""
+}
+
+type UserAppLogGroup struct {
+        LogLine              []*UserAppLogLine `protobuf:"bytes,2,rep,name=log_line,json=logLine" json:"log_line,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+        XXX_unrecognized     []byte            `json:"-"`
+        XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *UserAppLogGroup) Reset()         { *m = UserAppLogGroup{} }
+func (m *UserAppLogGroup) String() string { return proto.CompactTextString(m) }
+func (*UserAppLogGroup) ProtoMessage()    {}
+func (*UserAppLogGroup) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{2}
+}
+func (m *UserAppLogGroup) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_UserAppLogGroup.Unmarshal(m, b)
+}
+func (m *UserAppLogGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_UserAppLogGroup.Marshal(b, m, deterministic)
+}
+func (dst *UserAppLogGroup) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_UserAppLogGroup.Merge(dst, src)
+}
+func (m *UserAppLogGroup) XXX_Size() int {
+        return xxx_messageInfo_UserAppLogGroup.Size(m)
+}
+func (m *UserAppLogGroup) XXX_DiscardUnknown() {
+        xxx_messageInfo_UserAppLogGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UserAppLogGroup proto.InternalMessageInfo
+
+func (m *UserAppLogGroup) GetLogLine() []*UserAppLogLine {
+        if m != nil {
+                return m.LogLine
+        }
+        return nil
+}
+
+type FlushRequest struct {
+        Logs                 []byte   `protobuf:"bytes,1,opt,name=logs" json:"logs,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *FlushRequest) Reset()         { *m = FlushRequest{} }
+func (m *FlushRequest) String() string { return proto.CompactTextString(m) }
+func (*FlushRequest) ProtoMessage()    {}
+func (*FlushRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{3}
+}
+func (m *FlushRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_FlushRequest.Unmarshal(m, b)
+}
+func (m *FlushRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_FlushRequest.Marshal(b, m, deterministic)
+}
+func (dst *FlushRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_FlushRequest.Merge(dst, src)
+}
+func (m *FlushRequest) XXX_Size() int {
+        return xxx_messageInfo_FlushRequest.Size(m)
+}
+func (m *FlushRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_FlushRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FlushRequest proto.InternalMessageInfo
+
+func (m *FlushRequest) GetLogs() []byte {
+        if m != nil {
+                return m.Logs
+        }
+        return nil
+}
+
+type SetStatusRequest struct {
+        Status               *string  `protobuf:"bytes,1,req,name=status" json:"status,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SetStatusRequest) Reset()         { *m = SetStatusRequest{} }
+func (m *SetStatusRequest) String() string { return proto.CompactTextString(m) }
+func (*SetStatusRequest) ProtoMessage()    {}
+func (*SetStatusRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{4}
+}
+func (m *SetStatusRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_SetStatusRequest.Unmarshal(m, b)
+}
+func (m *SetStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_SetStatusRequest.Marshal(b, m, deterministic)
+}
+func (dst *SetStatusRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_SetStatusRequest.Merge(dst, src)
+}
+func (m *SetStatusRequest) XXX_Size() int {
+        return xxx_messageInfo_SetStatusRequest.Size(m)
+}
+func (m *SetStatusRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_SetStatusRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SetStatusRequest proto.InternalMessageInfo
+
+func (m *SetStatusRequest) GetStatus() string {
+        if m != nil && m.Status != nil {
+                return *m.Status
+        }
+        return ""
+}
+
+type LogOffset struct {
+        RequestId            []byte   `protobuf:"bytes,1,opt,name=request_id,json=requestId" json:"request_id,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *LogOffset) Reset()         { *m = LogOffset{} }
+func (m *LogOffset) String() string { return proto.CompactTextString(m) }
+func (*LogOffset) ProtoMessage()    {}
+func (*LogOffset) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{5}
+}
+func (m *LogOffset) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_LogOffset.Unmarshal(m, b)
+}
+func (m *LogOffset) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_LogOffset.Marshal(b, m, deterministic)
+}
+func (dst *LogOffset) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_LogOffset.Merge(dst, src)
+}
+func (m *LogOffset) XXX_Size() int {
+        return xxx_messageInfo_LogOffset.Size(m)
+}
+func (m *LogOffset) XXX_DiscardUnknown() {
+        xxx_messageInfo_LogOffset.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LogOffset proto.InternalMessageInfo
+
+func (m *LogOffset) GetRequestId() []byte {
+        if m != nil {
+                return m.RequestId
+        }
+        return nil
+}
+
+type LogLine struct {
+        Time                 *int64   `protobuf:"varint,1,req,name=time" json:"time,omitempty"`
+        Level                *int32   `protobuf:"varint,2,req,name=level" json:"level,omitempty"`
+        LogMessage           *string  `protobuf:"bytes,3,req,name=log_message,json=logMessage" json:"log_message,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *LogLine) Reset()         { *m = LogLine{} }
+func (m *LogLine) String() string { return proto.CompactTextString(m) }
+func (*LogLine) ProtoMessage()    {}
+func (*LogLine) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{6}
+}
+func (m *LogLine) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_LogLine.Unmarshal(m, b)
+}
+func (m *LogLine) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_LogLine.Marshal(b, m, deterministic)
+}
+func (dst *LogLine) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_LogLine.Merge(dst, src)
+}
+func (m *LogLine) XXX_Size() int {
+        return xxx_messageInfo_LogLine.Size(m)
+}
+func (m *LogLine) XXX_DiscardUnknown() {
+        xxx_messageInfo_LogLine.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LogLine proto.InternalMessageInfo
+
+func (m *LogLine) GetTime() int64 {
+        if m != nil && m.Time != nil {
+                return *m.Time
+        }
+        return 0
+}
+
+func (m *LogLine) GetLevel() int32 {
+        if m != nil && m.Level != nil {
+                return *m.Level
+        }
+        return 0
+}
+
+func (m *LogLine) GetLogMessage() string {
+        if m != nil && m.LogMessage != nil {
+                return *m.LogMessage
+        }
+        return ""
+}
+
+type RequestLog struct {
+        AppId                   *string    `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
+        ModuleId                *string    `protobuf:"bytes,37,opt,name=module_id,json=moduleId,def=default" json:"module_id,omitempty"`
+        VersionId               *string    `protobuf:"bytes,2,req,name=version_id,json=versionId" json:"version_id,omitempty"`
+        RequestId               []byte     `protobuf:"bytes,3,req,name=request_id,json=requestId" json:"request_id,omitempty"`
+        Offset                  *LogOffset `protobuf:"bytes,35,opt,name=offset" json:"offset,omitempty"`
+        Ip                      *string    `protobuf:"bytes,4,req,name=ip" json:"ip,omitempty"`
+        Nickname                *string    `protobuf:"bytes,5,opt,name=nickname" json:"nickname,omitempty"`
+        StartTime               *int64     `protobuf:"varint,6,req,name=start_time,json=startTime" json:"start_time,omitempty"`
+        EndTime                 *int64     `protobuf:"varint,7,req,name=end_time,json=endTime" json:"end_time,omitempty"`
+        Latency                 *int64     `protobuf:"varint,8,req,name=latency" json:"latency,omitempty"`
+        Mcycles                 *int64     `protobuf:"varint,9,req,name=mcycles" json:"mcycles,omitempty"`
+        Method                  *string    `protobuf:"bytes,10,req,name=method" json:"method,omitempty"`
+        Resource                *string    `protobuf:"bytes,11,req,name=resource" json:"resource,omitempty"`
+        HttpVersion             *string    `protobuf:"bytes,12,req,name=http_version,json=httpVersion" json:"http_version,omitempty"`
+        Status                  *int32     `protobuf:"varint,13,req,name=status" json:"status,omitempty"`
+        ResponseSize            *int64     `protobuf:"varint,14,req,name=response_size,json=responseSize" json:"response_size,omitempty"`
+        Referrer                *string    `protobuf:"bytes,15,opt,name=referrer" json:"referrer,omitempty"`
+        UserAgent               *string    `protobuf:"bytes,16,opt,name=user_agent,json=userAgent" json:"user_agent,omitempty"`
+        UrlMapEntry             *string    `protobuf:"bytes,17,req,name=url_map_entry,json=urlMapEntry" json:"url_map_entry,omitempty"`
+        Combined                *string    `protobuf:"bytes,18,req,name=combined" json:"combined,omitempty"`
+        ApiMcycles              *int64     `protobuf:"varint,19,opt,name=api_mcycles,json=apiMcycles" json:"api_mcycles,omitempty"`
+        Host                    *string    `protobuf:"bytes,20,opt,name=host" json:"host,omitempty"`
+        Cost                    *float64   `protobuf:"fixed64,21,opt,name=cost" json:"cost,omitempty"`
+        TaskQueueName           *string    `protobuf:"bytes,22,opt,name=task_queue_name,json=taskQueueName" json:"task_queue_name,omitempty"`
+        TaskName                *string    `protobuf:"bytes,23,opt,name=task_name,json=taskName" json:"task_name,omitempty"`
+        WasLoadingRequest       *bool      `protobuf:"varint,24,opt,name=was_loading_request,json=wasLoadingRequest" json:"was_loading_request,omitempty"`
+        PendingTime             *int64     `protobuf:"varint,25,opt,name=pending_time,json=pendingTime" json:"pending_time,omitempty"`
+        ReplicaIndex            *int32     `protobuf:"varint,26,opt,name=replica_index,json=replicaIndex,def=-1" json:"replica_index,omitempty"`
+        Finished                *bool      `protobuf:"varint,27,opt,name=finished,def=1" json:"finished,omitempty"`
+        CloneKey                []byte     `protobuf:"bytes,28,opt,name=clone_key,json=cloneKey" json:"clone_key,omitempty"`
+        Line                    []*LogLine `protobuf:"bytes,29,rep,name=line" json:"line,omitempty"`
+        LinesIncomplete         *bool      `protobuf:"varint,36,opt,name=lines_incomplete,json=linesIncomplete" json:"lines_incomplete,omitempty"`
+        AppEngineRelease        []byte     `protobuf:"bytes,38,opt,name=app_engine_release,json=appEngineRelease" json:"app_engine_release,omitempty"`
+        ExitReason              *int32     `protobuf:"varint,30,opt,name=exit_reason,json=exitReason" json:"exit_reason,omitempty"`
+        WasThrottledForTime     *bool      `protobuf:"varint,31,opt,name=was_throttled_for_time,json=wasThrottledForTime" json:"was_throttled_for_time,omitempty"`
+        WasThrottledForRequests *bool      `protobuf:"varint,32,opt,name=was_throttled_for_requests,json=wasThrottledForRequests" json:"was_throttled_for_requests,omitempty"`
+        ThrottledTime           *int64     `protobuf:"varint,33,opt,name=throttled_time,json=throttledTime" json:"throttled_time,omitempty"`
+        ServerName              []byte     `protobuf:"bytes,34,opt,name=server_name,json=serverName" json:"server_name,omitempty"`
+        XXX_NoUnkeyedLiteral    struct{}   `json:"-"`
+        XXX_unrecognized        []byte     `json:"-"`
+        XXX_sizecache           int32      `json:"-"`
+}
+
+func (m *RequestLog) Reset()         { *m = RequestLog{} }
+func (m *RequestLog) String() string { return proto.CompactTextString(m) }
+func (*RequestLog) ProtoMessage()    {}
+func (*RequestLog) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{7}
+}
+func (m *RequestLog) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_RequestLog.Unmarshal(m, b)
+}
+func (m *RequestLog) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_RequestLog.Marshal(b, m, deterministic)
+}
+func (dst *RequestLog) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_RequestLog.Merge(dst, src)
+}
+func (m *RequestLog) XXX_Size() int {
+        return xxx_messageInfo_RequestLog.Size(m)
+}
+func (m *RequestLog) XXX_DiscardUnknown() {
+        xxx_messageInfo_RequestLog.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RequestLog proto.InternalMessageInfo
+
+const Default_RequestLog_ModuleId string = "default"
+const Default_RequestLog_ReplicaIndex int32 = -1
+const Default_RequestLog_Finished bool = true
+
+func (m *RequestLog) GetAppId() string {
+        if m != nil && m.AppId != nil {
+                return *m.AppId
+        }
+        return ""
+}
+
+func (m *RequestLog) GetModuleId() string {
+        if m != nil && m.ModuleId != nil {
+                return *m.ModuleId
+        }
+        return Default_RequestLog_ModuleId
+}
+
+func (m *RequestLog) GetVersionId() string {
+        if m != nil && m.VersionId != nil {
+                return *m.VersionId
+        }
+        return ""
+}
+
+func (m *RequestLog) GetRequestId() []byte {
+        if m != nil {
+                return m.RequestId
+        }
+        return nil
+}
+
+func (m *RequestLog) GetOffset() *LogOffset {
+        if m != nil {
+                return m.Offset
+        }
+        return nil
+}
+
+func (m *RequestLog) GetIp() string {
+        if m != nil && m.Ip != nil {
+                return *m.Ip
+        }
+        return ""
+}
+
+func (m *RequestLog) GetNickname() string {
+        if m != nil && m.Nickname != nil {
+                return *m.Nickname
+        }
+        return ""
+}
+
+func (m *RequestLog) GetStartTime() int64 {
+        if m != nil && m.StartTime != nil {
+                return *m.StartTime
+        }
+        return 0
+}
+
+func (m *RequestLog) GetEndTime() int64 {
+        if m != nil && m.EndTime != nil {
+                return *m.EndTime
+        }
+        return 0
+}
+
+func (m *RequestLog) GetLatency() int64 {
+        if m != nil && m.Latency != nil {
+                return *m.Latency
+        }
+        return 0
+}
+
+func (m *RequestLog) GetMcycles() int64 {
+        if m != nil && m.Mcycles != nil {
+                return *m.Mcycles
+        }
+        return 0
+}
+
+func (m *RequestLog) GetMethod() string {
+        if m != nil && m.Method != nil {
+                return *m.Method
+        }
+        return ""
+}
+
+func (m *RequestLog) GetResource() string {
+        if m != nil && m.Resource != nil {
+                return *m.Resource
+        }
+        return ""
+}
+
+func (m *RequestLog) GetHttpVersion() string {
+        if m != nil && m.HttpVersion != nil {
+                return *m.HttpVersion
+        }
+        return ""
+}
+
+func (m *RequestLog) GetStatus() int32 {
+        if m != nil && m.Status != nil {
+                return *m.Status
+        }
+        return 0
+}
+
+func (m *RequestLog) GetResponseSize() int64 {
+        if m != nil && m.ResponseSize != nil {
+                return *m.ResponseSize
+        }
+        return 0
+}
+
+func (m *RequestLog) GetReferrer() string {
+        if m != nil && m.Referrer != nil {
+                return *m.Referrer
+        }
+        return ""
+}
+
+func (m *RequestLog) GetUserAgent() string {
+        if m != nil && m.UserAgent != nil {
+                return *m.UserAgent
+        }
+        return ""
+}
+
+func (m *RequestLog) GetUrlMapEntry() string {
+        if m != nil && m.UrlMapEntry != nil {
+                return *m.UrlMapEntry
+        }
+        return ""
+}
+
+func (m *RequestLog) GetCombined() string {
+        if m != nil && m.Combined != nil {
+                return *m.Combined
+        }
+        return ""
+}
+
+func (m *RequestLog) GetApiMcycles() int64 {
+        if m != nil && m.ApiMcycles != nil {
+                return *m.ApiMcycles
+        }
+        return 0
+}
+
+func (m *RequestLog) GetHost() string {
+        if m != nil && m.Host != nil {
+                return *m.Host
+        }
+        return ""
+}
+
+func (m *RequestLog) GetCost() float64 {
+        if m != nil && m.Cost != nil {
+                return *m.Cost
+        }
+        return 0
+}
+
+func (m *RequestLog) GetTaskQueueName() string {
+        if m != nil && m.TaskQueueName != nil {
+                return *m.TaskQueueName
+        }
+        return ""
+}
+
+func (m *RequestLog) GetTaskName() string {
+        if m != nil && m.TaskName != nil {
+                return *m.TaskName
+        }
+        return ""
+}
+
+func (m *RequestLog) GetWasLoadingRequest() bool {
+        if m != nil && m.WasLoadingRequest != nil {
+                return *m.WasLoadingRequest
+        }
+        return false
+}
+
+func (m *RequestLog) GetPendingTime() int64 {
+        if m != nil && m.PendingTime != nil {
+                return *m.PendingTime
+        }
+        return 0
+}
+
+func (m *RequestLog) GetReplicaIndex() int32 {
+        if m != nil && m.ReplicaIndex != nil {
+                return *m.ReplicaIndex
+        }
+        return Default_RequestLog_ReplicaIndex
+}
+
+func (m *RequestLog) GetFinished() bool {
+        if m != nil && m.Finished != nil {
+                return *m.Finished
+        }
+        return Default_RequestLog_Finished
+}
+
+func (m *RequestLog) GetCloneKey() []byte {
+        if m != nil {
+                return m.CloneKey
+        }
+        return nil
+}
+
+func (m *RequestLog) GetLine() []*LogLine {
+        if m != nil {
+                return m.Line
+        }
+        return nil
+}
+
+func (m *RequestLog) GetLinesIncomplete() bool {
+        if m != nil && m.LinesIncomplete != nil {
+                return *m.LinesIncomplete
+        }
+        return false
+}
+
+func (m *RequestLog) GetAppEngineRelease() []byte {
+        if m != nil {
+                return m.AppEngineRelease
+        }
+        return nil
+}
+
+func (m *RequestLog) GetExitReason() int32 {
+        if m != nil && m.ExitReason != nil {
+                return *m.ExitReason
+        }
+        return 0
+}
+
+func (m *RequestLog) GetWasThrottledForTime() bool {
+        if m != nil && m.WasThrottledForTime != nil {
+                return *m.WasThrottledForTime
+        }
+        return false
+}
+
+func (m *RequestLog) GetWasThrottledForRequests() bool {
+        if m != nil && m.WasThrottledForRequests != nil {
+                return *m.WasThrottledForRequests
+        }
+        return false
+}
+
+func (m *RequestLog) GetThrottledTime() int64 {
+        if m != nil && m.ThrottledTime != nil {
+                return *m.ThrottledTime
+        }
+        return 0
+}
+
+func (m *RequestLog) GetServerName() []byte {
+        if m != nil {
+                return m.ServerName
+        }
+        return nil
+}
+
+type LogModuleVersion struct {
+        ModuleId             *string  `protobuf:"bytes,1,opt,name=module_id,json=moduleId,def=default" json:"module_id,omitempty"`
+        VersionId            *string  `protobuf:"bytes,2,opt,name=version_id,json=versionId" json:"version_id,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *LogModuleVersion) Reset()         { *m = LogModuleVersion{} }
+func (m *LogModuleVersion) String() string { return proto.CompactTextString(m) }
+func (*LogModuleVersion) ProtoMessage()    {}
+func (*LogModuleVersion) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{8}
+}
+func (m *LogModuleVersion) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_LogModuleVersion.Unmarshal(m, b)
+}
+func (m *LogModuleVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_LogModuleVersion.Marshal(b, m, deterministic)
+}
+func (dst *LogModuleVersion) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_LogModuleVersion.Merge(dst, src)
+}
+func (m *LogModuleVersion) XXX_Size() int {
+        return xxx_messageInfo_LogModuleVersion.Size(m)
+}
+func (m *LogModuleVersion) XXX_DiscardUnknown() {
+        xxx_messageInfo_LogModuleVersion.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LogModuleVersion proto.InternalMessageInfo
+
+const Default_LogModuleVersion_ModuleId string = "default"
+
+func (m *LogModuleVersion) GetModuleId() string {
+        if m != nil && m.ModuleId != nil {
+                return *m.ModuleId
+        }
+        return Default_LogModuleVersion_ModuleId
+}
+
+func (m *LogModuleVersion) GetVersionId() string {
+        if m != nil && m.VersionId != nil {
+                return *m.VersionId
+        }
+        return ""
+}
+
+type LogReadRequest struct {
+        AppId                *string             `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
+        VersionId            []string            `protobuf:"bytes,2,rep,name=version_id,json=versionId" json:"version_id,omitempty"`
+        ModuleVersion        []*LogModuleVersion `protobuf:"bytes,19,rep,name=module_version,json=moduleVersion" json:"module_version,omitempty"`
+        StartTime            *int64              `protobuf:"varint,3,opt,name=start_time,json=startTime" json:"start_time,omitempty"`
+        EndTime              *int64              `protobuf:"varint,4,opt,name=end_time,json=endTime" json:"end_time,omitempty"`
+        Offset               *LogOffset          `protobuf:"bytes,5,opt,name=offset" json:"offset,omitempty"`
+        RequestId            [][]byte            `protobuf:"bytes,6,rep,name=request_id,json=requestId" json:"request_id,omitempty"`
+        MinimumLogLevel      *int32              `protobuf:"varint,7,opt,name=minimum_log_level,json=minimumLogLevel" json:"minimum_log_level,omitempty"`
+        IncludeIncomplete    *bool               `protobuf:"varint,8,opt,name=include_incomplete,json=includeIncomplete" json:"include_incomplete,omitempty"`
+        Count                *int64              `protobuf:"varint,9,opt,name=count" json:"count,omitempty"`
+        CombinedLogRegex     *string             `protobuf:"bytes,14,opt,name=combined_log_regex,json=combinedLogRegex" json:"combined_log_regex,omitempty"`
+        HostRegex            *string             `protobuf:"bytes,15,opt,name=host_regex,json=hostRegex" json:"host_regex,omitempty"`
+        ReplicaIndex         *int32              `protobuf:"varint,16,opt,name=replica_index,json=replicaIndex" json:"replica_index,omitempty"`
+        IncludeAppLogs       *bool               `protobuf:"varint,10,opt,name=include_app_logs,json=includeAppLogs" json:"include_app_logs,omitempty"`
+        AppLogsPerRequest    *int32              `protobuf:"varint,17,opt,name=app_logs_per_request,json=appLogsPerRequest" json:"app_logs_per_request,omitempty"`
+        IncludeHost          *bool               `protobuf:"varint,11,opt,name=include_host,json=includeHost" json:"include_host,omitempty"`
+        IncludeAll           *bool               `protobuf:"varint,12,opt,name=include_all,json=includeAll" json:"include_all,omitempty"`
+        CacheIterator        *bool               `protobuf:"varint,13,opt,name=cache_iterator,json=cacheIterator" json:"cache_iterator,omitempty"`
+        NumShards            *int32              `protobuf:"varint,18,opt,name=num_shards,json=numShards" json:"num_shards,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}            `json:"-"`
+        XXX_unrecognized     []byte              `json:"-"`
+        XXX_sizecache        int32               `json:"-"`
+}
+
+func (m *LogReadRequest) Reset()         { *m = LogReadRequest{} }
+func (m *LogReadRequest) String() string { return proto.CompactTextString(m) }
+func (*LogReadRequest) ProtoMessage()    {}
+func (*LogReadRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{9}
+}
+func (m *LogReadRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_LogReadRequest.Unmarshal(m, b)
+}
+func (m *LogReadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_LogReadRequest.Marshal(b, m, deterministic)
+}
+func (dst *LogReadRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_LogReadRequest.Merge(dst, src)
+}
+func (m *LogReadRequest) XXX_Size() int {
+        return xxx_messageInfo_LogReadRequest.Size(m)
+}
+func (m *LogReadRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_LogReadRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LogReadRequest proto.InternalMessageInfo
+
+func (m *LogReadRequest) GetAppId() string {
+        if m != nil && m.AppId != nil {
+                return *m.AppId
+        }
+        return ""
+}
+
+func (m *LogReadRequest) GetVersionId() []string {
+        if m != nil {
+                return m.VersionId
+        }
+        return nil
+}
+
+func (m *LogReadRequest) GetModuleVersion() []*LogModuleVersion {
+        if m != nil {
+                return m.ModuleVersion
+        }
+        return nil
+}
+
+func (m *LogReadRequest) GetStartTime() int64 {
+        if m != nil && m.StartTime != nil {
+                return *m.StartTime
+        }
+        return 0
+}
+
+func (m *LogReadRequest) GetEndTime() int64 {
+        if m != nil && m.EndTime != nil {
+                return *m.EndTime
+        }
+        return 0
+}
+
+func (m *LogReadRequest) GetOffset() *LogOffset {
+        if m != nil {
+                return m.Offset
+        }
+        return nil
+}
+
+func (m *LogReadRequest) GetRequestId() [][]byte {
+        if m != nil {
+                return m.RequestId
+        }
+        return nil
+}
+
+func (m *LogReadRequest) GetMinimumLogLevel() int32 {
+        if m != nil && m.MinimumLogLevel != nil {
+                return *m.MinimumLogLevel
+        }
+        return 0
+}
+
+func (m *LogReadRequest) GetIncludeIncomplete() bool {
+        if m != nil && m.IncludeIncomplete != nil {
+                return *m.IncludeIncomplete
+        }
+        return false
+}
+
+func (m *LogReadRequest) GetCount() int64 {
+        if m != nil && m.Count != nil {
+                return *m.Count
+        }
+        return 0
+}
+
+func (m *LogReadRequest) GetCombinedLogRegex() string {
+        if m != nil && m.CombinedLogRegex != nil {
+                return *m.CombinedLogRegex
+        }
+        return ""
+}
+
+func (m *LogReadRequest) GetHostRegex() string {
+        if m != nil && m.HostRegex != nil {
+                return *m.HostRegex
+        }
+        return ""
+}
+
+func (m *LogReadRequest) GetReplicaIndex() int32 {
+        if m != nil && m.ReplicaIndex != nil {
+                return *m.ReplicaIndex
+        }
+        return 0
+}
+
+func (m *LogReadRequest) GetIncludeAppLogs() bool {
+        if m != nil && m.IncludeAppLogs != nil {
+                return *m.IncludeAppLogs
+        }
+        return false
+}
+
+func (m *LogReadRequest) GetAppLogsPerRequest() int32 {
+        if m != nil && m.AppLogsPerRequest != nil {
+                return *m.AppLogsPerRequest
+        }
+        return 0
+}
+
+func (m *LogReadRequest) GetIncludeHost() bool {
+        if m != nil && m.IncludeHost != nil {
+                return *m.IncludeHost
+        }
+        return false
+}
+
+func (m *LogReadRequest) GetIncludeAll() bool {
+        if m != nil && m.IncludeAll != nil {
+                return *m.IncludeAll
+        }
+        return false
+}
+
+func (m *LogReadRequest) GetCacheIterator() bool {
+        if m != nil && m.CacheIterator != nil {
+                return *m.CacheIterator
+        }
+        return false
+}
+
+func (m *LogReadRequest) GetNumShards() int32 {
+        if m != nil && m.NumShards != nil {
+                return *m.NumShards
+        }
+        return 0
+}
+
+type LogReadResponse struct {
+        Log                  []*RequestLog `protobuf:"bytes,1,rep,name=log" json:"log,omitempty"`
+        Offset               *LogOffset    `protobuf:"bytes,2,opt,name=offset" json:"offset,omitempty"`
+        LastEndTime          *int64        `protobuf:"varint,3,opt,name=last_end_time,json=lastEndTime" json:"last_end_time,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}      `json:"-"`
+        XXX_unrecognized     []byte        `json:"-"`
+        XXX_sizecache        int32         `json:"-"`
+}
+
+func (m *LogReadResponse) Reset()         { *m = LogReadResponse{} }
+func (m *LogReadResponse) String() string { return proto.CompactTextString(m) }
+func (*LogReadResponse) ProtoMessage()    {}
+func (*LogReadResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{10}
+}
+func (m *LogReadResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_LogReadResponse.Unmarshal(m, b)
+}
+func (m *LogReadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_LogReadResponse.Marshal(b, m, deterministic)
+}
+func (dst *LogReadResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_LogReadResponse.Merge(dst, src)
+}
+func (m *LogReadResponse) XXX_Size() int {
+        return xxx_messageInfo_LogReadResponse.Size(m)
+}
+func (m *LogReadResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_LogReadResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LogReadResponse proto.InternalMessageInfo
+
+func (m *LogReadResponse) GetLog() []*RequestLog {
+        if m != nil {
+                return m.Log
+        }
+        return nil
+}
+
+func (m *LogReadResponse) GetOffset() *LogOffset {
+        if m != nil {
+                return m.Offset
+        }
+        return nil
+}
+
+func (m *LogReadResponse) GetLastEndTime() int64 {
+        if m != nil && m.LastEndTime != nil {
+                return *m.LastEndTime
+        }
+        return 0
+}
+
+type LogUsageRecord struct {
+        VersionId            *string  `protobuf:"bytes,1,opt,name=version_id,json=versionId" json:"version_id,omitempty"`
+        StartTime            *int32   `protobuf:"varint,2,opt,name=start_time,json=startTime" json:"start_time,omitempty"`
+        EndTime              *int32   `protobuf:"varint,3,opt,name=end_time,json=endTime" json:"end_time,omitempty"`
+        Count                *int64   `protobuf:"varint,4,opt,name=count" json:"count,omitempty"`
+        TotalSize            *int64   `protobuf:"varint,5,opt,name=total_size,json=totalSize" json:"total_size,omitempty"`
+        Records              *int32   `protobuf:"varint,6,opt,name=records" json:"records,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *LogUsageRecord) Reset()         { *m = LogUsageRecord{} }
+func (m *LogUsageRecord) String() string { return proto.CompactTextString(m) }
+func (*LogUsageRecord) ProtoMessage()    {}
+func (*LogUsageRecord) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{11}
+}
+func (m *LogUsageRecord) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_LogUsageRecord.Unmarshal(m, b)
+}
+func (m *LogUsageRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_LogUsageRecord.Marshal(b, m, deterministic)
+}
+func (dst *LogUsageRecord) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_LogUsageRecord.Merge(dst, src)
+}
+func (m *LogUsageRecord) XXX_Size() int {
+        return xxx_messageInfo_LogUsageRecord.Size(m)
+}
+func (m *LogUsageRecord) XXX_DiscardUnknown() {
+        xxx_messageInfo_LogUsageRecord.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LogUsageRecord proto.InternalMessageInfo
+
+func (m *LogUsageRecord) GetVersionId() string {
+        if m != nil && m.VersionId != nil {
+                return *m.VersionId
+        }
+        return ""
+}
+
+func (m *LogUsageRecord) GetStartTime() int32 {
+        if m != nil && m.StartTime != nil {
+                return *m.StartTime
+        }
+        return 0
+}
+
+func (m *LogUsageRecord) GetEndTime() int32 {
+        if m != nil && m.EndTime != nil {
+                return *m.EndTime
+        }
+        return 0
+}
+
+func (m *LogUsageRecord) GetCount() int64 {
+        if m != nil && m.Count != nil {
+                return *m.Count
+        }
+        return 0
+}
+
+func (m *LogUsageRecord) GetTotalSize() int64 {
+        if m != nil && m.TotalSize != nil {
+                return *m.TotalSize
+        }
+        return 0
+}
+
+func (m *LogUsageRecord) GetRecords() int32 {
+        if m != nil && m.Records != nil {
+                return *m.Records
+        }
+        return 0
+}
+
+type LogUsageRequest struct {
+        AppId                *string  `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
+        VersionId            []string `protobuf:"bytes,2,rep,name=version_id,json=versionId" json:"version_id,omitempty"`
+        StartTime            *int32   `protobuf:"varint,3,opt,name=start_time,json=startTime" json:"start_time,omitempty"`
+        EndTime              *int32   `protobuf:"varint,4,opt,name=end_time,json=endTime" json:"end_time,omitempty"`
+        ResolutionHours      *uint32  `protobuf:"varint,5,opt,name=resolution_hours,json=resolutionHours,def=1" json:"resolution_hours,omitempty"`
+        CombineVersions      *bool    `protobuf:"varint,6,opt,name=combine_versions,json=combineVersions" json:"combine_versions,omitempty"`
+        UsageVersion         *int32   `protobuf:"varint,7,opt,name=usage_version,json=usageVersion" json:"usage_version,omitempty"`
+        VersionsOnly         *bool    `protobuf:"varint,8,opt,name=versions_only,json=versionsOnly" json:"versions_only,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *LogUsageRequest) Reset()         { *m = LogUsageRequest{} }
+func (m *LogUsageRequest) String() string { return proto.CompactTextString(m) }
+func (*LogUsageRequest) ProtoMessage()    {}
+func (*LogUsageRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{12}
+}
+func (m *LogUsageRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_LogUsageRequest.Unmarshal(m, b)
+}
+func (m *LogUsageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_LogUsageRequest.Marshal(b, m, deterministic)
+}
+func (dst *LogUsageRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_LogUsageRequest.Merge(dst, src)
+}
+func (m *LogUsageRequest) XXX_Size() int {
+        return xxx_messageInfo_LogUsageRequest.Size(m)
+}
+func (m *LogUsageRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_LogUsageRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LogUsageRequest proto.InternalMessageInfo
+
+const Default_LogUsageRequest_ResolutionHours uint32 = 1
+
+func (m *LogUsageRequest) GetAppId() string {
+        if m != nil && m.AppId != nil {
+                return *m.AppId
+        }
+        return ""
+}
+
+func (m *LogUsageRequest) GetVersionId() []string {
+        if m != nil {
+                return m.VersionId
+        }
+        return nil
+}
+
+func (m *LogUsageRequest) GetStartTime() int32 {
+        if m != nil && m.StartTime != nil {
+                return *m.StartTime
+        }
+        return 0
+}
+
+func (m *LogUsageRequest) GetEndTime() int32 {
+        if m != nil && m.EndTime != nil {
+                return *m.EndTime
+        }
+        return 0
+}
+
+func (m *LogUsageRequest) GetResolutionHours() uint32 {
+        if m != nil && m.ResolutionHours != nil {
+                return *m.ResolutionHours
+        }
+        return Default_LogUsageRequest_ResolutionHours
+}
+
+func (m *LogUsageRequest) GetCombineVersions() bool {
+        if m != nil && m.CombineVersions != nil {
+                return *m.CombineVersions
+        }
+        return false
+}
+
+func (m *LogUsageRequest) GetUsageVersion() int32 {
+        if m != nil && m.UsageVersion != nil {
+                return *m.UsageVersion
+        }
+        return 0
+}
+
+func (m *LogUsageRequest) GetVersionsOnly() bool {
+        if m != nil && m.VersionsOnly != nil {
+                return *m.VersionsOnly
+        }
+        return false
+}
+
+type LogUsageResponse struct {
+        Usage                []*LogUsageRecord `protobuf:"bytes,1,rep,name=usage" json:"usage,omitempty"`
+        Summary              *LogUsageRecord   `protobuf:"bytes,2,opt,name=summary" json:"summary,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+        XXX_unrecognized     []byte            `json:"-"`
+        XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *LogUsageResponse) Reset()         { *m = LogUsageResponse{} }
+func (m *LogUsageResponse) String() string { return proto.CompactTextString(m) }
+func (*LogUsageResponse) ProtoMessage()    {}
+func (*LogUsageResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{13}
+}
+func (m *LogUsageResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_LogUsageResponse.Unmarshal(m, b)
+}
+func (m *LogUsageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_LogUsageResponse.Marshal(b, m, deterministic)
+}
+func (dst *LogUsageResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_LogUsageResponse.Merge(dst, src)
+}
+func (m *LogUsageResponse) XXX_Size() int {
+        return xxx_messageInfo_LogUsageResponse.Size(m)
+}
+func (m *LogUsageResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_LogUsageResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LogUsageResponse proto.InternalMessageInfo
+
+func (m *LogUsageResponse) GetUsage() []*LogUsageRecord {
+        if m != nil {
+                return m.Usage
+        }
+        return nil
+}
+
+func (m *LogUsageResponse) GetSummary() *LogUsageRecord {
+        if m != nil {
+                return m.Summary
+        }
+        return nil
+}
+
+func init() {
+        proto.RegisterType((*LogServiceError)(nil), "appengine.LogServiceError")
+        proto.RegisterType((*UserAppLogLine)(nil), "appengine.UserAppLogLine")
+        proto.RegisterType((*UserAppLogGroup)(nil), "appengine.UserAppLogGroup")
+        proto.RegisterType((*FlushRequest)(nil), "appengine.FlushRequest")
+        proto.RegisterType((*SetStatusRequest)(nil), "appengine.SetStatusRequest")
+        proto.RegisterType((*LogOffset)(nil), "appengine.LogOffset")
+        proto.RegisterType((*LogLine)(nil), "appengine.LogLine")
+        proto.RegisterType((*RequestLog)(nil), "appengine.RequestLog")
+        proto.RegisterType((*LogModuleVersion)(nil), "appengine.LogModuleVersion")
+        proto.RegisterType((*LogReadRequest)(nil), "appengine.LogReadRequest")
+        proto.RegisterType((*LogReadResponse)(nil), "appengine.LogReadResponse")
+        proto.RegisterType((*LogUsageRecord)(nil), "appengine.LogUsageRecord")
+        proto.RegisterType((*LogUsageRequest)(nil), "appengine.LogUsageRequest")
+        proto.RegisterType((*LogUsageResponse)(nil), "appengine.LogUsageResponse")
+}
+
+func init() {
+        proto.RegisterFile("google.golang.org/appengine/internal/log/log_service.proto", fileDescriptor_log_service_f054fd4b5012319d)
+}
+
+var fileDescriptor_log_service_f054fd4b5012319d = []byte{
+        // 1553 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xdd, 0x72, 0xdb, 0xc6,
+        0x15, 0x2e, 0x48, 0x51, 0x24, 0x0f, 0x49, 0x91, 0x5a, 0xcb, 0xce, 0xda, 0xae, 0x6b, 0x1a, 0x4e,
+        0x1c, 0xd6, 0x93, 0x48, 0x93, 0xa4, 0x57, 0xca, 0x95, 0xd3, 0x2a, 0x8e, 0x26, 0xb4, 0xd5, 0x40,
+        0x72, 0x3a, 0xd3, 0x1b, 0x0c, 0x0a, 0x1c, 0x81, 0x18, 0x2f, 0xb1, 0xc8, 0xee, 0xc2, 0x91, 0x72,
+        0xdb, 0xdb, 0x3e, 0x46, 0x1f, 0xa2, 0xaf, 0xd2, 0xb7, 0xe9, 0xec, 0xd9, 0x05, 0x44, 0x2a, 0x4d,
+        0xc6, 0x33, 0xb9, 0xe0, 0x10, 0xfb, 0x9d, 0x83, 0xdd, 0xf3, 0xf3, 0x9d, 0x6f, 0x01, 0xc7, 0xb9,
+        0x94, 0xb9, 0xc0, 0xc3, 0x5c, 0x8a, 0xa4, 0xcc, 0x0f, 0xa5, 0xca, 0x8f, 0x92, 0xaa, 0xc2, 0x32,
+        0x2f, 0x4a, 0x3c, 0x2a, 0x4a, 0x83, 0xaa, 0x4c, 0xc4, 0x91, 0x90, 0xb9, 0xfd, 0xc5, 0x1a, 0xd5,
+        0xbb, 0x22, 0xc5, 0xc3, 0x4a, 0x49, 0x23, 0xd9, 0xb0, 0xf5, 0x0c, 0x5f, 0xc3, 0x74, 0x29, 0xf3,
+        0x73, 0x67, 0x3e, 0x51, 0x4a, 0xaa, 0xf0, 0x4b, 0x18, 0xd2, 0xc3, 0x9f, 0x65, 0x86, 0x6c, 0x17,
+        0x3a, 0x67, 0xdf, 0xce, 0x7e, 0xc7, 0xee, 0xc0, 0xf4, 0xf4, 0xf5, 0xf7, 0x2f, 0x96, 0xa7, 0x7f,
+        0x89, 0xa3, 0x93, 0xef, 0xde, 0x9c, 0x9c, 0x5f, 0xcc, 0x02, 0xb6, 0x0f, 0x93, 0xf3, 0x8b, 0xb3,
+        0xe8, 0xc5, 0xcb, 0x93, 0xf8, 0x24, 0x8a, 0xce, 0xa2, 0x59, 0x27, 0xcc, 0x61, 0xef, 0x8d, 0x46,
+        0xf5, 0xa2, 0xaa, 0x96, 0x32, 0x5f, 0x16, 0x25, 0xb2, 0x8f, 0x60, 0xcf, 0x14, 0x6b, 0xd4, 0x26,
+        0x59, 0x57, 0x71, 0xad, 0x31, 0xe5, 0xc1, 0xbc, 0xb3, 0xe8, 0x46, 0x93, 0x16, 0x7d, 0xa3, 0x31,
+        0x65, 0x07, 0xd0, 0x13, 0xf8, 0x0e, 0x05, 0xef, 0x90, 0xd5, 0x2d, 0x18, 0x87, 0xfe, 0x1a, 0xb5,
+        0x4e, 0x72, 0xe4, 0xdd, 0x79, 0x67, 0x31, 0x8c, 0x9a, 0x65, 0xf8, 0x12, 0xa6, 0x37, 0x07, 0xbd,
+        0x54, 0xb2, 0xae, 0xd8, 0x9f, 0x60, 0x60, 0x73, 0x15, 0x45, 0x89, 0xbc, 0x33, 0xef, 0x2e, 0x46,
+        0x9f, 0xdf, 0x3f, 0x6c, 0x33, 0x3d, 0xdc, 0x0e, 0x2b, 0xea, 0x0b, 0xf7, 0x10, 0x86, 0x30, 0xfe,
+        0x5a, 0xd4, 0x7a, 0x15, 0xe1, 0x0f, 0x35, 0x6a, 0xc3, 0x18, 0xec, 0x08, 0x99, 0x6b, 0x1e, 0xcc,
+        0x83, 0xc5, 0x38, 0xa2, 0xe7, 0xf0, 0x39, 0xcc, 0xce, 0xd1, 0x9c, 0x9b, 0xc4, 0xd4, 0xba, 0xf1,
+        0xbb, 0x07, 0xbb, 0x9a, 0x00, 0xca, 0x67, 0x18, 0xf9, 0x55, 0xf8, 0x1c, 0x86, 0x4b, 0x99, 0x9f,
+        0x5d, 0x5e, 0x6a, 0x34, 0xec, 0x11, 0x80, 0x72, 0xfe, 0x71, 0x91, 0xf9, 0x2d, 0x87, 0x1e, 0x39,
+        0xcd, 0xc2, 0x0b, 0xe8, 0x37, 0x65, 0x62, 0xb0, 0x63, 0x0b, 0xe2, 0x8b, 0x43, 0xcf, 0xdb, 0x35,
+        0xe9, 0x35, 0x35, 0x79, 0x0c, 0x23, 0x9b, 0xe6, 0x76, 0x5d, 0x40, 0xc8, 0xfc, 0x95, 0x2f, 0xcd,
+        0x3f, 0x01, 0xc0, 0x47, 0xb9, 0x94, 0x39, 0xbb, 0x0b, 0xbb, 0x49, 0x55, 0xb9, 0xf3, 0xad, 0x6b,
+        0x2f, 0xa9, 0xaa, 0xd3, 0x8c, 0x7d, 0x08, 0xc3, 0xb5, 0xcc, 0x6a, 0x81, 0xd6, 0xf2, 0xd1, 0x3c,
+        0x58, 0x0c, 0x8f, 0xfb, 0x19, 0x5e, 0x26, 0xb5, 0x30, 0xd1, 0xc0, 0x59, 0x4e, 0x33, 0x9b, 0xc0,
+        0x3b, 0x54, 0xba, 0x90, 0xa5, 0x75, 0xeb, 0xd0, 0x06, 0x43, 0x8f, 0x38, 0xf3, 0x46, 0x7e, 0x36,
+        0x94, 0xcd, 0xfc, 0xd8, 0x27, 0xb0, 0x2b, 0xa9, 0x10, 0xfc, 0xe9, 0x3c, 0x58, 0x8c, 0x3e, 0x3f,
+        0xd8, 0xe8, 0x47, 0x5b, 0xa4, 0xc8, 0xfb, 0xb0, 0x3d, 0xe8, 0x14, 0x15, 0xdf, 0xa1, 0x33, 0x3a,
+        0x45, 0xc5, 0x1e, 0xc0, 0xa0, 0x2c, 0xd2, 0xb7, 0x65, 0xb2, 0x46, 0xde, 0xb3, 0x01, 0x46, 0xed,
+        0xda, 0x1e, 0xac, 0x4d, 0xa2, 0x4c, 0x4c, 0x45, 0xdb, 0xa5, 0xa2, 0x0d, 0x09, 0xb9, 0xb0, 0x95,
+        0xbb, 0x0f, 0x03, 0x2c, 0x33, 0x67, 0xec, 0x93, 0xb1, 0x8f, 0x65, 0x46, 0x26, 0x0e, 0x7d, 0x91,
+        0x18, 0x2c, 0xd3, 0x6b, 0x3e, 0x70, 0x16, 0xbf, 0x24, 0xb2, 0xa5, 0xd7, 0xa9, 0x40, 0xcd, 0x87,
+        0xce, 0xe2, 0x97, 0xb6, 0xd7, 0x6b, 0x34, 0x2b, 0x99, 0x71, 0x70, 0xbd, 0x76, 0x2b, 0x1b, 0xa1,
+        0x42, 0x2d, 0x6b, 0x95, 0x22, 0x1f, 0x91, 0xa5, 0x5d, 0xb3, 0x27, 0x30, 0x5e, 0x19, 0x53, 0xc5,
+        0xbe, 0x58, 0x7c, 0x4c, 0xf6, 0x91, 0xc5, 0xbe, 0x77, 0xd0, 0x06, 0x85, 0x26, 0xd4, 0x60, 0xbf,
+        0x62, 0x4f, 0x61, 0xa2, 0x50, 0x57, 0xb2, 0xd4, 0x18, 0xeb, 0xe2, 0x27, 0xe4, 0x7b, 0x14, 0xce,
+        0xb8, 0x01, 0xcf, 0x8b, 0x9f, 0xd0, 0x9d, 0x7d, 0x89, 0x4a, 0xa1, 0xe2, 0x53, 0x57, 0x9d, 0x66,
+        0x6d, 0xab, 0x53, 0x6b, 0x54, 0x71, 0x92, 0x63, 0x69, 0xf8, 0x8c, 0xac, 0x43, 0x8b, 0xbc, 0xb0,
+        0x00, 0x0b, 0x61, 0x52, 0x2b, 0x11, 0xaf, 0x93, 0x2a, 0xc6, 0xd2, 0xa8, 0x6b, 0xbe, 0xef, 0x62,
+        0xab, 0x95, 0x78, 0x95, 0x54, 0x27, 0x16, 0xb2, 0xdb, 0xa7, 0x72, 0xfd, 0x8f, 0xa2, 0xc4, 0x8c,
+        0x33, 0x97, 0x5a, 0xb3, 0xb6, 0x0c, 0x4c, 0xaa, 0x22, 0x6e, 0x8a, 0x75, 0x67, 0x1e, 0x2c, 0xba,
+        0x11, 0x24, 0x55, 0xf1, 0xca, 0xd7, 0x8b, 0xc1, 0xce, 0x4a, 0x6a, 0xc3, 0x0f, 0xe8, 0x64, 0x7a,
+        0xb6, 0x58, 0x6a, 0xb1, 0xbb, 0xf3, 0x60, 0x11, 0x44, 0xf4, 0xcc, 0x9e, 0xc1, 0xd4, 0x24, 0xfa,
+        0x6d, 0xfc, 0x43, 0x8d, 0x35, 0xc6, 0xd4, 0xe8, 0x7b, 0xf4, 0xca, 0xc4, 0xc2, 0xdf, 0x59, 0xf4,
+        0xb5, 0xed, 0xf6, 0x43, 0x18, 0x92, 0x1f, 0x79, 0x7c, 0xe0, 0x92, 0xb5, 0x00, 0x19, 0x0f, 0xe1,
+        0xce, 0x8f, 0x89, 0x8e, 0x85, 0x4c, 0xb2, 0xa2, 0xcc, 0x63, 0xcf, 0x3e, 0xce, 0xe7, 0xc1, 0x62,
+        0x10, 0xed, 0xff, 0x98, 0xe8, 0xa5, 0xb3, 0x34, 0x83, 0xfb, 0x04, 0xc6, 0x15, 0x96, 0xe4, 0x4b,
+        0xfc, 0xb8, 0x4f, 0xe1, 0x8f, 0x3c, 0x46, 0x1c, 0xf9, 0xd8, 0x36, 0xa0, 0x12, 0x45, 0x9a, 0xc4,
+        0x45, 0x99, 0xe1, 0x15, 0x7f, 0x30, 0x0f, 0x16, 0xbd, 0xe3, 0xce, 0xa7, 0x9f, 0xd9, 0x26, 0x90,
+        0xe1, 0xd4, 0xe2, 0x6c, 0x0e, 0x83, 0xcb, 0xa2, 0x2c, 0xf4, 0x0a, 0x33, 0xfe, 0xd0, 0x1e, 0x78,
+        0xbc, 0x63, 0x54, 0x8d, 0x51, 0x8b, 0xda, 0xd0, 0x53, 0x21, 0x4b, 0x8c, 0xdf, 0xe2, 0x35, 0xff,
+        0x3d, 0x09, 0xc0, 0x80, 0x80, 0x6f, 0xf1, 0x9a, 0x3d, 0x83, 0x1d, 0x52, 0xab, 0x47, 0xa4, 0x56,
+        0x6c, 0x7b, 0x3a, 0x48, 0xa6, 0xc8, 0xce, 0xfe, 0x08, 0x33, 0xfb, 0xaf, 0xe3, 0xa2, 0x4c, 0xe5,
+        0xba, 0x12, 0x68, 0x90, 0x7f, 0x48, 0xf9, 0x4d, 0x09, 0x3f, 0x6d, 0x61, 0xf6, 0x09, 0x30, 0x3b,
+        0xed, 0x6e, 0x9b, 0x58, 0xa1, 0xc0, 0x44, 0x23, 0x7f, 0x46, 0x07, 0xcf, 0x92, 0xaa, 0x3a, 0x21,
+        0x43, 0xe4, 0x70, 0xdb, 0x49, 0xbc, 0x2a, 0x4c, 0xac, 0x30, 0xd1, 0xb2, 0xe4, 0x7f, 0xb0, 0x69,
+        0x46, 0x60, 0xa1, 0x88, 0x10, 0xf6, 0x05, 0xdc, 0xb3, 0xc5, 0x35, 0x2b, 0x25, 0x8d, 0x11, 0x98,
+        0xc5, 0x97, 0x52, 0xb9, 0xb2, 0x3d, 0xa6, 0xf3, 0x6d, 0xe9, 0x2f, 0x1a, 0xe3, 0xd7, 0x52, 0x51,
+        0xf9, 0xbe, 0x84, 0x07, 0x3f, 0x7f, 0xc9, 0xf7, 0x45, 0xf3, 0x39, 0xbd, 0xf8, 0xc1, 0xad, 0x17,
+        0x7d, 0x77, 0x34, 0xdd, 0x17, 0xed, 0x8b, 0x74, 0xd2, 0x13, 0x6a, 0xd0, 0xa4, 0x45, 0xe9, 0x8c,
+        0xc7, 0x30, 0xb2, 0x97, 0x1a, 0x2a, 0x47, 0x8a, 0x90, 0x12, 0x04, 0x07, 0x59, 0x5a, 0x84, 0x7f,
+        0x83, 0xd9, 0x52, 0xe6, 0xaf, 0x48, 0xc8, 0x9a, 0x81, 0xdb, 0xd2, 0xbc, 0xe0, 0x7d, 0x35, 0x2f,
+        0xd8, 0xd2, 0xbc, 0xf0, 0xbf, 0x3d, 0xd8, 0x5b, 0xca, 0x3c, 0xc2, 0x24, 0x6b, 0x28, 0xf5, 0x0b,
+        0x12, 0x7b, 0x7b, 0xa3, 0xee, 0xb6, 0x78, 0x7e, 0x05, 0x7b, 0x3e, 0x9a, 0x46, 0x23, 0xee, 0x10,
+        0x0f, 0x1e, 0x6e, 0xf3, 0x60, 0x2b, 0x85, 0x68, 0xb2, 0xde, 0xca, 0x68, 0x5b, 0x07, 0xbb, 0x54,
+        0xa9, 0x5f, 0xd0, 0xc1, 0x1d, 0x32, 0xb6, 0x3a, 0x78, 0xa3, 0xcd, 0xbd, 0xf7, 0xd0, 0xe6, 0x6d,
+        0xa1, 0xdf, 0x9d, 0x77, 0xb7, 0x85, 0xfe, 0x39, 0xec, 0xaf, 0x8b, 0xb2, 0x58, 0xd7, 0xeb, 0x98,
+        0xae, 0x60, 0xba, 0xb5, 0xfa, 0xc4, 0xa6, 0xa9, 0x37, 0x58, 0x46, 0xd3, 0xfd, 0xf5, 0x29, 0xb0,
+        0xa2, 0x4c, 0x45, 0x9d, 0xe1, 0x26, 0x9d, 0x07, 0x6e, 0x5c, 0xbd, 0x65, 0x83, 0xd0, 0x07, 0xd0,
+        0x4b, 0x65, 0x5d, 0x1a, 0x3e, 0xa4, 0xf8, 0xdd, 0xc2, 0xd2, 0xbc, 0x91, 0x23, 0x3a, 0x51, 0x61,
+        0x8e, 0x57, 0x7c, 0x8f, 0x7a, 0x35, 0x6b, 0x2c, 0xd4, 0xa5, 0x1c, 0xaf, 0x6c, 0xf4, 0x56, 0x83,
+        0xbc, 0x97, 0x53, 0xcb, 0xa1, 0x45, 0x9c, 0xf9, 0xe9, 0xed, 0x71, 0x9f, 0x51, 0xe4, 0xdb, 0xa3,
+        0xbe, 0x80, 0x59, 0x13, 0xb6, 0xed, 0x35, 0x7d, 0x23, 0x00, 0x05, 0xbd, 0xe7, 0x71, 0xf7, 0x75,
+        0xa1, 0xd9, 0x11, 0x1c, 0x34, 0x1e, 0x71, 0x85, 0x2d, 0xf3, 0xf9, 0x3e, 0xed, 0xba, 0x9f, 0x38,
+        0xb7, 0xbf, 0xa2, 0xda, 0x50, 0xa4, 0x66, 0x6b, 0x92, 0xcd, 0x11, 0x6d, 0x3b, 0xf2, 0xd8, 0x37,
+        0x56, 0x29, 0x1f, 0xc3, 0xa8, 0x3d, 0x5d, 0x08, 0x3e, 0x26, 0x0f, 0x68, 0x0e, 0x16, 0xc2, 0x8e,
+        0x4d, 0x9a, 0xa4, 0x2b, 0x8c, 0x0b, 0x83, 0x2a, 0x31, 0x52, 0xf1, 0x09, 0xf9, 0x4c, 0x08, 0x3d,
+        0xf5, 0xa0, 0xad, 0x44, 0x59, 0xaf, 0x63, 0xbd, 0x4a, 0x54, 0xa6, 0x39, 0xa3, 0x88, 0x86, 0x65,
+        0xbd, 0x3e, 0x27, 0x20, 0xfc, 0x57, 0x40, 0xdf, 0x83, 0x8e, 0xdb, 0xee, 0xb2, 0x61, 0x1f, 0x43,
+        0x57, 0xc8, 0x9c, 0x07, 0xc4, 0xcd, 0xbb, 0x1b, 0x2c, 0xb9, 0xf9, 0xc6, 0x88, 0xac, 0xc7, 0x06,
+        0xa3, 0x3a, 0xef, 0xc1, 0xa8, 0x10, 0x26, 0x22, 0xd1, 0x26, 0x6e, 0xf9, 0xe9, 0xc8, 0x3b, 0xb2,
+        0xe0, 0x89, 0xe3, 0x68, 0xf8, 0x9f, 0x80, 0x46, 0xed, 0x8d, 0xfd, 0xac, 0x89, 0x30, 0x95, 0xea,
+        0xf6, 0x4c, 0x05, 0xb7, 0x86, 0xf3, 0xd6, 0x3c, 0x74, 0x5c, 0x7e, 0xff, 0x7f, 0x1e, 0xba, 0x64,
+        0x6c, 0xe7, 0xa1, 0xe5, 0xd9, 0xce, 0x26, 0xcf, 0x1e, 0x01, 0x18, 0x69, 0x12, 0xe1, 0xee, 0xe1,
+        0x9e, 0x9b, 0x2f, 0x42, 0xe8, 0x12, 0xe6, 0xd0, 0x57, 0x14, 0x97, 0xe6, 0xbb, 0x6e, 0x3b, 0xbf,
+        0x0c, 0xff, 0xdd, 0xa1, 0x4a, 0xfa, 0xd0, 0x7f, 0x8b, 0x4c, 0xfc, 0x7c, 0xc4, 0x7b, 0xbf, 0x36,
+        0xe2, 0xbd, 0xcd, 0x11, 0x9f, 0xd9, 0xcf, 0x11, 0x51, 0x1b, 0xbb, 0xf7, 0x4a, 0xd6, 0x4a, 0x53,
+        0x0a, 0x93, 0xe3, 0xe0, 0xb3, 0x68, 0x7a, 0x63, 0xfa, 0xc6, 0x5a, 0xec, 0x25, 0xe3, 0x07, 0xa7,
+        0xd1, 0x23, 0x97, 0xd4, 0x20, 0x9a, 0x7a, 0xdc, 0x8b, 0x0e, 0x7d, 0xa0, 0xd4, 0x36, 0xb1, 0x56,
+        0xb8, 0xdc, 0xa8, 0x8f, 0x09, 0x6c, 0xa4, 0xe9, 0x29, 0x4c, 0x9a, 0x7d, 0x62, 0x59, 0x8a, 0x6b,
+        0x3f, 0xe2, 0xe3, 0x06, 0x3c, 0x2b, 0xc5, 0x75, 0x78, 0x45, 0x2a, 0xed, 0xab, 0xe4, 0x09, 0x77,
+        0x04, 0x3d, 0xda, 0xc8, 0x53, 0xee, 0xfe, 0x36, 0x8d, 0x36, 0xc8, 0x10, 0x39, 0x3f, 0xf6, 0x05,
+        0xf4, 0x75, 0xbd, 0x5e, 0x27, 0xea, 0xda, 0x33, 0xef, 0x57, 0x5e, 0x69, 0x3c, 0xbf, 0xea, 0xfd,
+        0xdd, 0x92, 0xf6, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x70, 0xd9, 0xa0, 0xf8, 0x48, 0x0d, 0x00,
+        0x00,
+}
diff --git a/vendor/google.golang.org/appengine/internal/log/log_service.proto b/vendor/google.golang.org/appengine/internal/log/log_service.proto
new file mode 100644
index 0000000..8981dc4
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/log/log_service.proto
@@ -0,0 +1,150 @@
+syntax = "proto2";
+option go_package = "log";
+
+package appengine;
+
+message LogServiceError {
+  enum ErrorCode {
+    OK  = 0;
+    INVALID_REQUEST = 1;
+    STORAGE_ERROR = 2;
+  }
+}
+
+message UserAppLogLine {
+  required int64 timestamp_usec = 1;
+  required int64 level = 2;
+  required string message = 3;
+}
+
+message UserAppLogGroup {
+  repeated UserAppLogLine log_line = 2;
+}
+
+message FlushRequest {
+  optional bytes logs = 1;
+}
+
+message SetStatusRequest {
+  required string status = 1;
+}
+
+
+message LogOffset {
+  optional bytes request_id = 1;
+}
+
+message LogLine {
+  required int64 time = 1;
+  required int32 level = 2;
+  required string log_message = 3;
+}
+
+message RequestLog {
+  required string app_id = 1;
+  optional string module_id = 37 [default="default"];
+  required string version_id = 2;
+  required bytes request_id = 3;
+  optional LogOffset offset = 35;
+  required string ip = 4;
+  optional string nickname = 5;
+  required int64 start_time = 6;
+  required int64 end_time = 7;
+  required int64 latency = 8;
+  required int64 mcycles = 9;
+  required string method = 10;
+  required string resource = 11;
+  required string http_version = 12;
+  required int32 status = 13;
+  required int64 response_size = 14;
+  optional string referrer = 15;
+  optional string user_agent = 16;
+  required string url_map_entry = 17;
+  required string combined = 18;
+  optional int64 api_mcycles = 19;
+  optional string host = 20;
+  optional double cost = 21;
+
+  optional string task_queue_name = 22;
+  optional string task_name = 23;
+
+  optional bool was_loading_request = 24;
+  optional int64 pending_time = 25;
+  optional int32 replica_index = 26 [default = -1];
+  optional bool finished = 27 [default = true];
+  optional bytes clone_key = 28;
+
+  repeated LogLine line = 29;
+
+  optional bool lines_incomplete = 36;
+  optional bytes app_engine_release = 38;
+
+  optional int32 exit_reason = 30;
+  optional bool was_throttled_for_time = 31;
+  optional bool was_throttled_for_requests = 32;
+  optional int64 throttled_time = 33;
+
+  optional bytes server_name = 34;
+}
+
+message LogModuleVersion {
+  optional string module_id = 1 [default="default"];
+  optional string version_id = 2;
+}
+
+message LogReadRequest {
+  required string app_id = 1;
+  repeated string version_id = 2;
+  repeated LogModuleVersion module_version = 19;
+
+  optional int64 start_time = 3;
+  optional int64 end_time = 4;
+  optional LogOffset offset = 5;
+  repeated bytes request_id = 6;
+
+  optional int32 minimum_log_level = 7;
+  optional bool include_incomplete = 8;
+  optional int64 count = 9;
+
+  optional string combined_log_regex = 14;
+  optional string host_regex = 15;
+  optional int32 replica_index = 16;
+
+  optional bool include_app_logs = 10;
+  optional int32 app_logs_per_request = 17;
+  optional bool include_host = 11;
+  optional bool include_all = 12;
+  optional bool cache_iterator = 13;
+  optional int32 num_shards = 18;
+}
+
+message LogReadResponse {
+  repeated RequestLog log = 1;
+  optional LogOffset offset = 2;
+  optional int64 last_end_time = 3;
+}
+
+message LogUsageRecord {
+  optional string version_id = 1;
+  optional int32 start_time = 2;
+  optional int32 end_time = 3;
+  optional int64 count = 4;
+  optional int64 total_size = 5;
+  optional int32 records = 6;
+}
+
+message LogUsageRequest {
+  required string app_id = 1;
+  repeated string version_id = 2;
+  optional int32 start_time = 3;
+  optional int32 end_time = 4;
+  optional uint32 resolution_hours = 5 [default = 1];
+  optional bool combine_versions = 6;
+  optional int32 usage_version = 7;
+  optional bool versions_only = 8;
+}
+
+message LogUsageResponse {
+  repeated LogUsageRecord usage = 1;
+  optional LogUsageRecord summary = 2;
+}
diff --git a/vendor/google.golang.org/appengine/internal/main.go b/vendor/google.golang.org/appengine/internal/main.go
new file mode 100644
index 0000000..1e76531
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/main.go
@@ -0,0 +1,16 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build appengine
+
+package internal
+
+import (
+        "appengine_internal"
+)
+
+func Main() {
+        MainPath = ""
+        appengine_internal.Main()
+}
diff --git a/vendor/google.golang.org/appengine/internal/main_common.go b/vendor/google.golang.org/appengine/internal/main_common.go
new file mode 100644
index 0000000..357dce4
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/main_common.go
@@ -0,0 +1,7 @@
+package internal
+
+// MainPath stores the file path of the main package. On App Engine Standard
+// using Go version 1.9 and below, this will be unset. On App Engine Flex and
+// App Engine Standard second-gen (Go 1.11 and above), this will be the
+// filepath to package main.
+var MainPath string
diff --git a/vendor/google.golang.org/appengine/internal/main_vm.go b/vendor/google.golang.org/appengine/internal/main_vm.go
new file mode 100644
index 0000000..ddb79a3
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/main_vm.go
@@ -0,0 +1,69 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build !appengine
+
+package internal
+
+import (
+        "io"
+        "log"
+        "net/http"
+        "net/url"
+        "os"
+        "path/filepath"
+        "runtime"
+)
+
+func Main() {
+        MainPath = filepath.Dir(findMainPath())
+        installHealthChecker(http.DefaultServeMux)
+
+        port := "8080"
+        if s := os.Getenv("PORT"); s != "" {
+                port = s
+        }
+
+        host := ""
+        if IsDevAppServer() {
+                host = "127.0.0.1"
+        }
+        if err := http.ListenAndServe(host+":"+port, http.HandlerFunc(handleHTTP)); err != nil {
+                log.Fatalf("http.ListenAndServe: %v", err)
+        }
+}
+
+// Find the path to package main by looking at the root Caller.
+func findMainPath() string {
+        pc := make([]uintptr, 100)
+        n := runtime.Callers(2, pc)
+        frames := runtime.CallersFrames(pc[:n])
+        for {
+                frame, more := frames.Next()
+                // Tests won't have package main, instead they have testing.tRunner
+                if frame.Function == "main.main" || frame.Function == "testing.tRunner" {
+                        return frame.File
+                }
+                if !more {
+                        break
+                }
+        }
+        return ""
+}
+
+func installHealthChecker(mux *http.ServeMux) {
+        // If no health check handler has been installed by this point, add a trivial one.
+        const healthPath = "/_ah/health"
+        hreq := &http.Request{
+                Method: "GET",
+                URL: &url.URL{
+                        Path: healthPath,
+                },
+        }
+        if _, pat := mux.Handler(hreq); pat != healthPath {
+                mux.HandleFunc(healthPath, func(w http.ResponseWriter, r *http.Request) {
+                        io.WriteString(w, "ok")
+                })
+        }
+}
diff --git a/vendor/google.golang.org/appengine/internal/metadata.go b/vendor/google.golang.org/appengine/internal/metadata.go
new file mode 100644
index 0000000..c4ba63b
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/metadata.go
@@ -0,0 +1,60 @@
+// Copyright 2014 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package internal
+
+// This file has code for accessing metadata.
+//
+// References:
+//      https://cloud.google.com/compute/docs/metadata
+
+import (
+        "fmt"
+        "io/ioutil"
+        "net/http"
+        "net/url"
+)
+
+const (
+        metadataHost = "metadata"
+        metadataPath = "/computeMetadata/v1/"
+)
+
+var (
+        metadataRequestHeaders = http.Header{
+                "Metadata-Flavor": []string{"Google"},
+        }
+)
+
+// TODO(dsymonds): Do we need to support default values, like Python?
+func mustGetMetadata(key string) []byte {
+        b, err := getMetadata(key)
+        if err != nil {
+                panic(fmt.Sprintf("Metadata fetch failed for '%s': %v", key, err))
+        }
+        return b
+}
+
+func getMetadata(key string) ([]byte, error) {
+        // TODO(dsymonds): May need to use url.Parse to support keys with query args.
+        req := &http.Request{
+                Method: "GET",
+                URL: &url.URL{
+                        Scheme: "http",
+                        Host:   metadataHost,
+                        Path:   metadataPath + key,
+                },
+                Header: metadataRequestHeaders,
+                Host:   metadataHost,
+        }
+        resp, err := http.DefaultClient.Do(req)
+        if err != nil {
+                return nil, err
+        }
+        defer resp.Body.Close()
+        if resp.StatusCode != 200 {
+                return nil, fmt.Errorf("metadata server returned HTTP %d", resp.StatusCode)
+        }
+        return ioutil.ReadAll(resp.Body)
+}
diff --git a/vendor/google.golang.org/appengine/internal/modules/modules_service.pb.go b/vendor/google.golang.org/appengine/internal/modules/modules_service.pb.go
new file mode 100644
index 0000000..ddfc0c0
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/modules/modules_service.pb.go
@@ -0,0 +1,786 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google.golang.org/appengine/internal/modules/modules_service.proto
+
+package modules
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// 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
+
+type ModulesServiceError_ErrorCode int32
+
+const (
+        ModulesServiceError_OK                ModulesServiceError_ErrorCode = 0
+        ModulesServiceError_INVALID_MODULE    ModulesServiceError_ErrorCode = 1
+        ModulesServiceError_INVALID_VERSION   ModulesServiceError_ErrorCode = 2
+        ModulesServiceError_INVALID_INSTANCES ModulesServiceError_ErrorCode = 3
+        ModulesServiceError_TRANSIENT_ERROR   ModulesServiceError_ErrorCode = 4
+        ModulesServiceError_UNEXPECTED_STATE  ModulesServiceError_ErrorCode = 5
+)
+
+var ModulesServiceError_ErrorCode_name = map[int32]string{
+        0: "OK",
+        1: "INVALID_MODULE",
+        2: "INVALID_VERSION",
+        3: "INVALID_INSTANCES",
+        4: "TRANSIENT_ERROR",
+        5: "UNEXPECTED_STATE",
+}
+var ModulesServiceError_ErrorCode_value = map[string]int32{
+        "OK":                0,
+        "INVALID_MODULE":    1,
+        "INVALID_VERSION":   2,
+        "INVALID_INSTANCES": 3,
+        "TRANSIENT_ERROR":   4,
+        "UNEXPECTED_STATE":  5,
+}
+
+func (x ModulesServiceError_ErrorCode) Enum() *ModulesServiceError_ErrorCode {
+        p := new(ModulesServiceError_ErrorCode)
+        *p = x
+        return p
+}
+func (x ModulesServiceError_ErrorCode) String() string {
+        return proto.EnumName(ModulesServiceError_ErrorCode_name, int32(x))
+}
+func (x *ModulesServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(ModulesServiceError_ErrorCode_value, data, "ModulesServiceError_ErrorCode")
+        if err != nil {
+                return err
+        }
+        *x = ModulesServiceError_ErrorCode(value)
+        return nil
+}
+func (ModulesServiceError_ErrorCode) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{0, 0}
+}
+
+type ModulesServiceError struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ModulesServiceError) Reset()         { *m = ModulesServiceError{} }
+func (m *ModulesServiceError) String() string { return proto.CompactTextString(m) }
+func (*ModulesServiceError) ProtoMessage()    {}
+func (*ModulesServiceError) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{0}
+}
+func (m *ModulesServiceError) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_ModulesServiceError.Unmarshal(m, b)
+}
+func (m *ModulesServiceError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_ModulesServiceError.Marshal(b, m, deterministic)
+}
+func (dst *ModulesServiceError) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_ModulesServiceError.Merge(dst, src)
+}
+func (m *ModulesServiceError) XXX_Size() int {
+        return xxx_messageInfo_ModulesServiceError.Size(m)
+}
+func (m *ModulesServiceError) XXX_DiscardUnknown() {
+        xxx_messageInfo_ModulesServiceError.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ModulesServiceError proto.InternalMessageInfo
+
+type GetModulesRequest struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetModulesRequest) Reset()         { *m = GetModulesRequest{} }
+func (m *GetModulesRequest) String() string { return proto.CompactTextString(m) }
+func (*GetModulesRequest) ProtoMessage()    {}
+func (*GetModulesRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{1}
+}
+func (m *GetModulesRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetModulesRequest.Unmarshal(m, b)
+}
+func (m *GetModulesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetModulesRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetModulesRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetModulesRequest.Merge(dst, src)
+}
+func (m *GetModulesRequest) XXX_Size() int {
+        return xxx_messageInfo_GetModulesRequest.Size(m)
+}
+func (m *GetModulesRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetModulesRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetModulesRequest proto.InternalMessageInfo
+
+type GetModulesResponse struct {
+        Module               []string `protobuf:"bytes,1,rep,name=module" json:"module,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetModulesResponse) Reset()         { *m = GetModulesResponse{} }
+func (m *GetModulesResponse) String() string { return proto.CompactTextString(m) }
+func (*GetModulesResponse) ProtoMessage()    {}
+func (*GetModulesResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{2}
+}
+func (m *GetModulesResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetModulesResponse.Unmarshal(m, b)
+}
+func (m *GetModulesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetModulesResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetModulesResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetModulesResponse.Merge(dst, src)
+}
+func (m *GetModulesResponse) XXX_Size() int {
+        return xxx_messageInfo_GetModulesResponse.Size(m)
+}
+func (m *GetModulesResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetModulesResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetModulesResponse proto.InternalMessageInfo
+
+func (m *GetModulesResponse) GetModule() []string {
+        if m != nil {
+                return m.Module
+        }
+        return nil
+}
+
+type GetVersionsRequest struct {
+        Module               *string  `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetVersionsRequest) Reset()         { *m = GetVersionsRequest{} }
+func (m *GetVersionsRequest) String() string { return proto.CompactTextString(m) }
+func (*GetVersionsRequest) ProtoMessage()    {}
+func (*GetVersionsRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{3}
+}
+func (m *GetVersionsRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetVersionsRequest.Unmarshal(m, b)
+}
+func (m *GetVersionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetVersionsRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetVersionsRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetVersionsRequest.Merge(dst, src)
+}
+func (m *GetVersionsRequest) XXX_Size() int {
+        return xxx_messageInfo_GetVersionsRequest.Size(m)
+}
+func (m *GetVersionsRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetVersionsRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetVersionsRequest proto.InternalMessageInfo
+
+func (m *GetVersionsRequest) GetModule() string {
+        if m != nil && m.Module != nil {
+                return *m.Module
+        }
+        return ""
+}
+
+type GetVersionsResponse struct {
+        Version              []string `protobuf:"bytes,1,rep,name=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetVersionsResponse) Reset()         { *m = GetVersionsResponse{} }
+func (m *GetVersionsResponse) String() string { return proto.CompactTextString(m) }
+func (*GetVersionsResponse) ProtoMessage()    {}
+func (*GetVersionsResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{4}
+}
+func (m *GetVersionsResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetVersionsResponse.Unmarshal(m, b)
+}
+func (m *GetVersionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetVersionsResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetVersionsResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetVersionsResponse.Merge(dst, src)
+}
+func (m *GetVersionsResponse) XXX_Size() int {
+        return xxx_messageInfo_GetVersionsResponse.Size(m)
+}
+func (m *GetVersionsResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetVersionsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetVersionsResponse proto.InternalMessageInfo
+
+func (m *GetVersionsResponse) GetVersion() []string {
+        if m != nil {
+                return m.Version
+        }
+        return nil
+}
+
+type GetDefaultVersionRequest struct {
+        Module               *string  `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetDefaultVersionRequest) Reset()         { *m = GetDefaultVersionRequest{} }
+func (m *GetDefaultVersionRequest) String() string { return proto.CompactTextString(m) }
+func (*GetDefaultVersionRequest) ProtoMessage()    {}
+func (*GetDefaultVersionRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{5}
+}
+func (m *GetDefaultVersionRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetDefaultVersionRequest.Unmarshal(m, b)
+}
+func (m *GetDefaultVersionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetDefaultVersionRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetDefaultVersionRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetDefaultVersionRequest.Merge(dst, src)
+}
+func (m *GetDefaultVersionRequest) XXX_Size() int {
+        return xxx_messageInfo_GetDefaultVersionRequest.Size(m)
+}
+func (m *GetDefaultVersionRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetDefaultVersionRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetDefaultVersionRequest proto.InternalMessageInfo
+
+func (m *GetDefaultVersionRequest) GetModule() string {
+        if m != nil && m.Module != nil {
+                return *m.Module
+        }
+        return ""
+}
+
+type GetDefaultVersionResponse struct {
+        Version              *string  `protobuf:"bytes,1,req,name=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetDefaultVersionResponse) Reset()         { *m = GetDefaultVersionResponse{} }
+func (m *GetDefaultVersionResponse) String() string { return proto.CompactTextString(m) }
+func (*GetDefaultVersionResponse) ProtoMessage()    {}
+func (*GetDefaultVersionResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{6}
+}
+func (m *GetDefaultVersionResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetDefaultVersionResponse.Unmarshal(m, b)
+}
+func (m *GetDefaultVersionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetDefaultVersionResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetDefaultVersionResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetDefaultVersionResponse.Merge(dst, src)
+}
+func (m *GetDefaultVersionResponse) XXX_Size() int {
+        return xxx_messageInfo_GetDefaultVersionResponse.Size(m)
+}
+func (m *GetDefaultVersionResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetDefaultVersionResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetDefaultVersionResponse proto.InternalMessageInfo
+
+func (m *GetDefaultVersionResponse) GetVersion() string {
+        if m != nil && m.Version != nil {
+                return *m.Version
+        }
+        return ""
+}
+
+type GetNumInstancesRequest struct {
+        Module               *string  `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
+        Version              *string  `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetNumInstancesRequest) Reset()         { *m = GetNumInstancesRequest{} }
+func (m *GetNumInstancesRequest) String() string { return proto.CompactTextString(m) }
+func (*GetNumInstancesRequest) ProtoMessage()    {}
+func (*GetNumInstancesRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{7}
+}
+func (m *GetNumInstancesRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetNumInstancesRequest.Unmarshal(m, b)
+}
+func (m *GetNumInstancesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetNumInstancesRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetNumInstancesRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetNumInstancesRequest.Merge(dst, src)
+}
+func (m *GetNumInstancesRequest) XXX_Size() int {
+        return xxx_messageInfo_GetNumInstancesRequest.Size(m)
+}
+func (m *GetNumInstancesRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetNumInstancesRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetNumInstancesRequest proto.InternalMessageInfo
+
+func (m *GetNumInstancesRequest) GetModule() string {
+        if m != nil && m.Module != nil {
+                return *m.Module
+        }
+        return ""
+}
+
+func (m *GetNumInstancesRequest) GetVersion() string {
+        if m != nil && m.Version != nil {
+                return *m.Version
+        }
+        return ""
+}
+
+type GetNumInstancesResponse struct {
+        Instances            *int64   `protobuf:"varint,1,req,name=instances" json:"instances,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetNumInstancesResponse) Reset()         { *m = GetNumInstancesResponse{} }
+func (m *GetNumInstancesResponse) String() string { return proto.CompactTextString(m) }
+func (*GetNumInstancesResponse) ProtoMessage()    {}
+func (*GetNumInstancesResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{8}
+}
+func (m *GetNumInstancesResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetNumInstancesResponse.Unmarshal(m, b)
+}
+func (m *GetNumInstancesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetNumInstancesResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetNumInstancesResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetNumInstancesResponse.Merge(dst, src)
+}
+func (m *GetNumInstancesResponse) XXX_Size() int {
+        return xxx_messageInfo_GetNumInstancesResponse.Size(m)
+}
+func (m *GetNumInstancesResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetNumInstancesResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetNumInstancesResponse proto.InternalMessageInfo
+
+func (m *GetNumInstancesResponse) GetInstances() int64 {
+        if m != nil && m.Instances != nil {
+                return *m.Instances
+        }
+        return 0
+}
+
+type SetNumInstancesRequest struct {
+        Module               *string  `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
+        Version              *string  `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
+        Instances            *int64   `protobuf:"varint,3,req,name=instances" json:"instances,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SetNumInstancesRequest) Reset()         { *m = SetNumInstancesRequest{} }
+func (m *SetNumInstancesRequest) String() string { return proto.CompactTextString(m) }
+func (*SetNumInstancesRequest) ProtoMessage()    {}
+func (*SetNumInstancesRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{9}
+}
+func (m *SetNumInstancesRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_SetNumInstancesRequest.Unmarshal(m, b)
+}
+func (m *SetNumInstancesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_SetNumInstancesRequest.Marshal(b, m, deterministic)
+}
+func (dst *SetNumInstancesRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_SetNumInstancesRequest.Merge(dst, src)
+}
+func (m *SetNumInstancesRequest) XXX_Size() int {
+        return xxx_messageInfo_SetNumInstancesRequest.Size(m)
+}
+func (m *SetNumInstancesRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_SetNumInstancesRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SetNumInstancesRequest proto.InternalMessageInfo
+
+func (m *SetNumInstancesRequest) GetModule() string {
+        if m != nil && m.Module != nil {
+                return *m.Module
+        }
+        return ""
+}
+
+func (m *SetNumInstancesRequest) GetVersion() string {
+        if m != nil && m.Version != nil {
+                return *m.Version
+        }
+        return ""
+}
+
+func (m *SetNumInstancesRequest) GetInstances() int64 {
+        if m != nil && m.Instances != nil {
+                return *m.Instances
+        }
+        return 0
+}
+
+type SetNumInstancesResponse struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SetNumInstancesResponse) Reset()         { *m = SetNumInstancesResponse{} }
+func (m *SetNumInstancesResponse) String() string { return proto.CompactTextString(m) }
+func (*SetNumInstancesResponse) ProtoMessage()    {}
+func (*SetNumInstancesResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{10}
+}
+func (m *SetNumInstancesResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_SetNumInstancesResponse.Unmarshal(m, b)
+}
+func (m *SetNumInstancesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_SetNumInstancesResponse.Marshal(b, m, deterministic)
+}
+func (dst *SetNumInstancesResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_SetNumInstancesResponse.Merge(dst, src)
+}
+func (m *SetNumInstancesResponse) XXX_Size() int {
+        return xxx_messageInfo_SetNumInstancesResponse.Size(m)
+}
+func (m *SetNumInstancesResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_SetNumInstancesResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SetNumInstancesResponse proto.InternalMessageInfo
+
+type StartModuleRequest struct {
+        Module               *string  `protobuf:"bytes,1,req,name=module" json:"module,omitempty"`
+        Version              *string  `protobuf:"bytes,2,req,name=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *StartModuleRequest) Reset()         { *m = StartModuleRequest{} }
+func (m *StartModuleRequest) String() string { return proto.CompactTextString(m) }
+func (*StartModuleRequest) ProtoMessage()    {}
+func (*StartModuleRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{11}
+}
+func (m *StartModuleRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_StartModuleRequest.Unmarshal(m, b)
+}
+func (m *StartModuleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_StartModuleRequest.Marshal(b, m, deterministic)
+}
+func (dst *StartModuleRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_StartModuleRequest.Merge(dst, src)
+}
+func (m *StartModuleRequest) XXX_Size() int {
+        return xxx_messageInfo_StartModuleRequest.Size(m)
+}
+func (m *StartModuleRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_StartModuleRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StartModuleRequest proto.InternalMessageInfo
+
+func (m *StartModuleRequest) GetModule() string {
+        if m != nil && m.Module != nil {
+                return *m.Module
+        }
+        return ""
+}
+
+func (m *StartModuleRequest) GetVersion() string {
+        if m != nil && m.Version != nil {
+                return *m.Version
+        }
+        return ""
+}
+
+type StartModuleResponse struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *StartModuleResponse) Reset()         { *m = StartModuleResponse{} }
+func (m *StartModuleResponse) String() string { return proto.CompactTextString(m) }
+func (*StartModuleResponse) ProtoMessage()    {}
+func (*StartModuleResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{12}
+}
+func (m *StartModuleResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_StartModuleResponse.Unmarshal(m, b)
+}
+func (m *StartModuleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_StartModuleResponse.Marshal(b, m, deterministic)
+}
+func (dst *StartModuleResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_StartModuleResponse.Merge(dst, src)
+}
+func (m *StartModuleResponse) XXX_Size() int {
+        return xxx_messageInfo_StartModuleResponse.Size(m)
+}
+func (m *StartModuleResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_StartModuleResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StartModuleResponse proto.InternalMessageInfo
+
+type StopModuleRequest struct {
+        Module               *string  `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
+        Version              *string  `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *StopModuleRequest) Reset()         { *m = StopModuleRequest{} }
+func (m *StopModuleRequest) String() string { return proto.CompactTextString(m) }
+func (*StopModuleRequest) ProtoMessage()    {}
+func (*StopModuleRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{13}
+}
+func (m *StopModuleRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_StopModuleRequest.Unmarshal(m, b)
+}
+func (m *StopModuleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_StopModuleRequest.Marshal(b, m, deterministic)
+}
+func (dst *StopModuleRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_StopModuleRequest.Merge(dst, src)
+}
+func (m *StopModuleRequest) XXX_Size() int {
+        return xxx_messageInfo_StopModuleRequest.Size(m)
+}
+func (m *StopModuleRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_StopModuleRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StopModuleRequest proto.InternalMessageInfo
+
+func (m *StopModuleRequest) GetModule() string {
+        if m != nil && m.Module != nil {
+                return *m.Module
+        }
+        return ""
+}
+
+func (m *StopModuleRequest) GetVersion() string {
+        if m != nil && m.Version != nil {
+                return *m.Version
+        }
+        return ""
+}
+
+type StopModuleResponse struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *StopModuleResponse) Reset()         { *m = StopModuleResponse{} }
+func (m *StopModuleResponse) String() string { return proto.CompactTextString(m) }
+func (*StopModuleResponse) ProtoMessage()    {}
+func (*StopModuleResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{14}
+}
+func (m *StopModuleResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_StopModuleResponse.Unmarshal(m, b)
+}
+func (m *StopModuleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_StopModuleResponse.Marshal(b, m, deterministic)
+}
+func (dst *StopModuleResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_StopModuleResponse.Merge(dst, src)
+}
+func (m *StopModuleResponse) XXX_Size() int {
+        return xxx_messageInfo_StopModuleResponse.Size(m)
+}
+func (m *StopModuleResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_StopModuleResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StopModuleResponse proto.InternalMessageInfo
+
+type GetHostnameRequest struct {
+        Module               *string  `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
+        Version              *string  `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
+        Instance             *string  `protobuf:"bytes,3,opt,name=instance" json:"instance,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetHostnameRequest) Reset()         { *m = GetHostnameRequest{} }
+func (m *GetHostnameRequest) String() string { return proto.CompactTextString(m) }
+func (*GetHostnameRequest) ProtoMessage()    {}
+func (*GetHostnameRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{15}
+}
+func (m *GetHostnameRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetHostnameRequest.Unmarshal(m, b)
+}
+func (m *GetHostnameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetHostnameRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetHostnameRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetHostnameRequest.Merge(dst, src)
+}
+func (m *GetHostnameRequest) XXX_Size() int {
+        return xxx_messageInfo_GetHostnameRequest.Size(m)
+}
+func (m *GetHostnameRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetHostnameRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetHostnameRequest proto.InternalMessageInfo
+
+func (m *GetHostnameRequest) GetModule() string {
+        if m != nil && m.Module != nil {
+                return *m.Module
+        }
+        return ""
+}
+
+func (m *GetHostnameRequest) GetVersion() string {
+        if m != nil && m.Version != nil {
+                return *m.Version
+        }
+        return ""
+}
+
+func (m *GetHostnameRequest) GetInstance() string {
+        if m != nil && m.Instance != nil {
+                return *m.Instance
+        }
+        return ""
+}
+
+type GetHostnameResponse struct {
+        Hostname             *string  `protobuf:"bytes,1,req,name=hostname" json:"hostname,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetHostnameResponse) Reset()         { *m = GetHostnameResponse{} }
+func (m *GetHostnameResponse) String() string { return proto.CompactTextString(m) }
+func (*GetHostnameResponse) ProtoMessage()    {}
+func (*GetHostnameResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{16}
+}
+func (m *GetHostnameResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetHostnameResponse.Unmarshal(m, b)
+}
+func (m *GetHostnameResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetHostnameResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetHostnameResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetHostnameResponse.Merge(dst, src)
+}
+func (m *GetHostnameResponse) XXX_Size() int {
+        return xxx_messageInfo_GetHostnameResponse.Size(m)
+}
+func (m *GetHostnameResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetHostnameResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetHostnameResponse proto.InternalMessageInfo
+
+func (m *GetHostnameResponse) GetHostname() string {
+        if m != nil && m.Hostname != nil {
+                return *m.Hostname
+        }
+        return ""
+}
+
+func init() {
+        proto.RegisterType((*ModulesServiceError)(nil), "appengine.ModulesServiceError")
+        proto.RegisterType((*GetModulesRequest)(nil), "appengine.GetModulesRequest")
+        proto.RegisterType((*GetModulesResponse)(nil), "appengine.GetModulesResponse")
+        proto.RegisterType((*GetVersionsRequest)(nil), "appengine.GetVersionsRequest")
+        proto.RegisterType((*GetVersionsResponse)(nil), "appengine.GetVersionsResponse")
+        proto.RegisterType((*GetDefaultVersionRequest)(nil), "appengine.GetDefaultVersionRequest")
+        proto.RegisterType((*GetDefaultVersionResponse)(nil), "appengine.GetDefaultVersionResponse")
+        proto.RegisterType((*GetNumInstancesRequest)(nil), "appengine.GetNumInstancesRequest")
+        proto.RegisterType((*GetNumInstancesResponse)(nil), "appengine.GetNumInstancesResponse")
+        proto.RegisterType((*SetNumInstancesRequest)(nil), "appengine.SetNumInstancesRequest")
+        proto.RegisterType((*SetNumInstancesResponse)(nil), "appengine.SetNumInstancesResponse")
+        proto.RegisterType((*StartModuleRequest)(nil), "appengine.StartModuleRequest")
+        proto.RegisterType((*StartModuleResponse)(nil), "appengine.StartModuleResponse")
+        proto.RegisterType((*StopModuleRequest)(nil), "appengine.StopModuleRequest")
+        proto.RegisterType((*StopModuleResponse)(nil), "appengine.StopModuleResponse")
+        proto.RegisterType((*GetHostnameRequest)(nil), "appengine.GetHostnameRequest")
+        proto.RegisterType((*GetHostnameResponse)(nil), "appengine.GetHostnameResponse")
+}
+
+func init() {
+        proto.RegisterFile("google.golang.org/appengine/internal/modules/modules_service.proto", fileDescriptor_modules_service_9cd3bffe4e91c59a)
+}
+
+var fileDescriptor_modules_service_9cd3bffe4e91c59a = []byte{
+        // 457 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0xc1, 0x6f, 0xd3, 0x30,
+        0x14, 0xc6, 0x69, 0x02, 0xdb, 0xf2, 0x0e, 0x90, 0x3a, 0x5b, 0xd7, 0x4d, 0x1c, 0x50, 0x4e, 0x1c,
+        0x50, 0x2b, 0x90, 0x10, 0xe7, 0xae, 0x35, 0x25, 0xb0, 0xa5, 0x28, 0xce, 0x2a, 0xc4, 0xa5, 0x0a,
+        0xdb, 0x23, 0x8b, 0x94, 0xda, 0xc1, 0x76, 0x77, 0xe4, 0xbf, 0xe0, 0xff, 0x45, 0x4b, 0xed, 0xb6,
+        0x81, 0x4e, 0x45, 0x68, 0xa7, 0xe4, 0x7d, 0xfe, 0xfc, 0x7b, 0x9f, 0x5f, 0xac, 0xc0, 0x59, 0x2e,
+        0x44, 0x5e, 0x62, 0x2f, 0x17, 0x65, 0xc6, 0xf3, 0x9e, 0x90, 0x79, 0x3f, 0xab, 0x2a, 0xe4, 0x79,
+        0xc1, 0xb1, 0x5f, 0x70, 0x8d, 0x92, 0x67, 0x65, 0x7f, 0x2e, 0xae, 0x17, 0x25, 0x2a, 0xfb, 0x9c,
+        0x29, 0x94, 0xb7, 0xc5, 0x15, 0xf6, 0x2a, 0x29, 0xb4, 0x20, 0xde, 0x6a, 0x47, 0xf8, 0xab, 0x05,
+        0xc1, 0xc5, 0xd2, 0xc4, 0x96, 0x1e, 0x2a, 0xa5, 0x90, 0xe1, 0x4f, 0xf0, 0xea, 0x97, 0xa1, 0xb8,
+        0x46, 0xb2, 0x07, 0xce, 0xe4, 0x93, 0xff, 0x88, 0x10, 0x78, 0x1a, 0xc5, 0xd3, 0xc1, 0x79, 0x34,
+        0x9a, 0x5d, 0x4c, 0x46, 0x97, 0xe7, 0xd4, 0x6f, 0x91, 0x00, 0x9e, 0x59, 0x6d, 0x4a, 0x13, 0x16,
+        0x4d, 0x62, 0xdf, 0x21, 0x47, 0xd0, 0xb6, 0x62, 0x14, 0xb3, 0x74, 0x10, 0x0f, 0x29, 0xf3, 0xdd,
+        0x3b, 0x6f, 0x9a, 0x0c, 0x62, 0x16, 0xd1, 0x38, 0x9d, 0xd1, 0x24, 0x99, 0x24, 0xfe, 0x63, 0x72,
+        0x08, 0xfe, 0x65, 0x4c, 0xbf, 0x7c, 0xa6, 0xc3, 0x94, 0x8e, 0x66, 0x2c, 0x1d, 0xa4, 0xd4, 0x7f,
+        0x12, 0x06, 0xd0, 0x1e, 0xa3, 0x36, 0xc9, 0x12, 0xfc, 0xb1, 0x40, 0xa5, 0xc3, 0x57, 0x40, 0x36,
+        0x45, 0x55, 0x09, 0xae, 0x90, 0x74, 0x60, 0x6f, 0x79, 0xcc, 0x6e, 0xeb, 0x85, 0xfb, 0xd2, 0x4b,
+        0x4c, 0x65, 0xdc, 0x53, 0x94, 0xaa, 0x10, 0xdc, 0x32, 0x1a, 0xee, 0xd6, 0x86, 0xbb, 0x0f, 0x41,
+        0xc3, 0x6d, 0xe0, 0x5d, 0xd8, 0xbf, 0x5d, 0x6a, 0x86, 0x6e, 0xcb, 0xf0, 0x0d, 0x74, 0xc7, 0xa8,
+        0x47, 0xf8, 0x3d, 0x5b, 0x94, 0x76, 0xdf, 0xae, 0x26, 0x6f, 0xe1, 0x64, 0xcb, 0x9e, 0x6d, 0xad,
+        0x9c, 0xcd, 0x56, 0x1f, 0xa1, 0x33, 0x46, 0x1d, 0x2f, 0xe6, 0x11, 0x57, 0x3a, 0xe3, 0x57, 0xb8,
+        0xeb, 0x34, 0x9b, 0x2c, 0xa7, 0x5e, 0x58, 0xb1, 0xde, 0xc1, 0xf1, 0x5f, 0x2c, 0x13, 0xe0, 0x39,
+        0x78, 0x85, 0x15, 0xeb, 0x08, 0x6e, 0xb2, 0x16, 0xc2, 0x1b, 0xe8, 0xb0, 0x07, 0x0a, 0xd1, 0xec,
+        0xe4, 0xfe, 0xd9, 0xe9, 0x04, 0x8e, 0xd9, 0xf6, 0x88, 0xe1, 0x7b, 0x20, 0x4c, 0x67, 0xd2, 0xdc,
+        0x81, 0x6d, 0x01, 0x9c, 0xfb, 0x02, 0x34, 0x26, 0x7a, 0x04, 0x41, 0x83, 0x63, 0xf0, 0x14, 0xda,
+        0x4c, 0x8b, 0xea, 0x7e, 0xfa, 0xbf, 0xcd, 0xf8, 0xf0, 0x2e, 0xe5, 0x1a, 0x63, 0xe0, 0xdf, 0xea,
+        0xfb, 0xf8, 0x41, 0x28, 0xcd, 0xb3, 0xf9, 0xff, 0xd3, 0xc9, 0x29, 0x1c, 0xd8, 0x59, 0x75, 0xdd,
+        0x7a, 0x69, 0x55, 0x87, 0xaf, 0xeb, 0x5b, 0xbc, 0xee, 0x61, 0xbe, 0xec, 0x29, 0x1c, 0xdc, 0x18,
+        0xcd, 0x8c, 0x68, 0x55, 0x9f, 0x79, 0x5f, 0xf7, 0xcd, 0x5f, 0xe2, 0x77, 0x00, 0x00, 0x00, 0xff,
+        0xff, 0x6e, 0xbc, 0xe0, 0x61, 0x5c, 0x04, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/appengine/internal/modules/modules_service.proto b/vendor/google.golang.org/appengine/internal/modules/modules_service.proto
new file mode 100644
index 0000000..d29f006
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/modules/modules_service.proto
@@ -0,0 +1,80 @@
+syntax = "proto2";
+option go_package = "modules";
+
+package appengine;
+
+message ModulesServiceError {
+  enum ErrorCode {
+    OK  = 0;
+    INVALID_MODULE = 1;
+    INVALID_VERSION = 2;
+    INVALID_INSTANCES = 3;
+    TRANSIENT_ERROR = 4;
+    UNEXPECTED_STATE = 5;
+  }
+}
+
+message GetModulesRequest {
+}
+
+message GetModulesResponse {
+  repeated string module = 1;
+}
+
+message GetVersionsRequest {
+  optional string module = 1;
+}
+
+message GetVersionsResponse {
+  repeated string version = 1;
+}
+
+message GetDefaultVersionRequest {
+  optional string module = 1;
+}
+
+message GetDefaultVersionResponse {
+  required string version = 1;
+}
+
+message GetNumInstancesRequest {
+  optional string module = 1;
+  optional string version = 2;
+}
+
+message GetNumInstancesResponse {
+  required int64 instances = 1;
+}
+
+message SetNumInstancesRequest {
+  optional string module = 1;
+  optional string version = 2;
+  required int64 instances = 3;
+}
+
+message SetNumInstancesResponse {}
+
+message StartModuleRequest {
+  required string module = 1;
+  required string version = 2;
+}
+
+message StartModuleResponse {}
+
+message StopModuleRequest {
+  optional string module = 1;
+  optional string version = 2;
+}
+
+message StopModuleResponse {}
+
+message GetHostnameRequest {
+  optional string module = 1;
+  optional string version = 2;
+  optional string instance = 3;
+}
+
+message GetHostnameResponse {
+  required string hostname = 1;
+}
+
diff --git a/vendor/google.golang.org/appengine/internal/net.go b/vendor/google.golang.org/appengine/internal/net.go
new file mode 100644
index 0000000..3b94cf0
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/net.go
@@ -0,0 +1,56 @@
+// Copyright 2014 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package internal
+
+// This file implements a network dialer that limits the number of concurrent connections.
+// It is only used for API calls.
+
+import (
+        "log"
+        "net"
+        "runtime"
+        "sync"
+        "time"
+)
+
+var limitSem = make(chan int, 100) // TODO(dsymonds): Use environment variable.
+
+func limitRelease() {
+        // non-blocking
+        select {
+        case <-limitSem:
+        default:
+                // This should not normally happen.
+                log.Print("appengine: unbalanced limitSem release!")
+        }
+}
+
+func limitDial(network, addr string) (net.Conn, error) {
+        limitSem <- 1
+
+        // Dial with a timeout in case the API host is MIA.
+        // The connection should normally be very fast.
+        conn, err := net.DialTimeout(network, addr, 500*time.Millisecond)
+        if err != nil {
+                limitRelease()
+                return nil, err
+        }
+        lc := &limitConn{Conn: conn}
+        runtime.SetFinalizer(lc, (*limitConn).Close) // shouldn't usually be required
+        return lc, nil
+}
+
+type limitConn struct {
+        close sync.Once
+        net.Conn
+}
+
+func (lc *limitConn) Close() error {
+        defer lc.close.Do(func() {
+                limitRelease()
+                runtime.SetFinalizer(lc, nil)
+        })
+        return lc.Conn.Close()
+}
diff --git a/vendor/google.golang.org/appengine/internal/regen.sh b/vendor/google.golang.org/appengine/internal/regen.sh
new file mode 100644
index 0000000..2fdb546
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/regen.sh
@@ -0,0 +1,40 @@
+#!/bin/bash -e
+#
+# This script rebuilds the generated code for the protocol buffers.
+# To run this you will need protoc and goprotobuf installed;
+# see https://github.com/golang/protobuf for instructions.
+
+PKG=google.golang.org/appengine
+
+function die() {
+        echo 1>&2 $*
+        exit 1
+}
+
+# Sanity check that the right tools are accessible.
+for tool in go protoc protoc-gen-go; do
+        q=$(which $tool) || die "didn't find $tool"
+        echo 1>&2 "$tool: $q"
+done
+
+echo -n 1>&2 "finding package dir... "
+pkgdir=$(go list -f '{{.Dir}}' $PKG)
+echo 1>&2 $pkgdir
+base=$(echo $pkgdir | sed "s,/$PKG\$,,")
+echo 1>&2 "base: $base"
+cd $base
+
+# Run protoc once per package.
+for dir in $(find $PKG/internal -name '*.proto' | xargs dirname | sort | uniq); do
+        echo 1>&2 "* $dir"
+        protoc --go_out=. $dir/*.proto
+done
+
+for f in $(find $PKG/internal -name '*.pb.go'); do
+  # Remove proto.RegisterEnum calls.
+  # These cause duplicate registration panics when these packages
+  # are used on classic App Engine. proto.RegisterEnum only affects
+  # parsing the text format; we don't care about that.
+  # https://code.google.com/p/googleappengine/issues/detail?id=11670#c17
+  sed -i '/proto.RegisterEnum/d' $f
+done
diff --git a/vendor/google.golang.org/appengine/internal/remote_api/remote_api.pb.go b/vendor/google.golang.org/appengine/internal/remote_api/remote_api.pb.go
new file mode 100644
index 0000000..8d782a3
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/remote_api/remote_api.pb.go
@@ -0,0 +1,361 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google.golang.org/appengine/internal/remote_api/remote_api.proto
+
+package remote_api
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// 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
+
+type RpcError_ErrorCode int32
+
+const (
+        RpcError_UNKNOWN             RpcError_ErrorCode = 0
+        RpcError_CALL_NOT_FOUND      RpcError_ErrorCode = 1
+        RpcError_PARSE_ERROR         RpcError_ErrorCode = 2
+        RpcError_SECURITY_VIOLATION  RpcError_ErrorCode = 3
+        RpcError_OVER_QUOTA          RpcError_ErrorCode = 4
+        RpcError_REQUEST_TOO_LARGE   RpcError_ErrorCode = 5
+        RpcError_CAPABILITY_DISABLED RpcError_ErrorCode = 6
+        RpcError_FEATURE_DISABLED    RpcError_ErrorCode = 7
+        RpcError_BAD_REQUEST         RpcError_ErrorCode = 8
+        RpcError_RESPONSE_TOO_LARGE  RpcError_ErrorCode = 9
+        RpcError_CANCELLED           RpcError_ErrorCode = 10
+        RpcError_REPLAY_ERROR        RpcError_ErrorCode = 11
+        RpcError_DEADLINE_EXCEEDED   RpcError_ErrorCode = 12
+)
+
+var RpcError_ErrorCode_name = map[int32]string{
+        0:  "UNKNOWN",
+        1:  "CALL_NOT_FOUND",
+        2:  "PARSE_ERROR",
+        3:  "SECURITY_VIOLATION",
+        4:  "OVER_QUOTA",
+        5:  "REQUEST_TOO_LARGE",
+        6:  "CAPABILITY_DISABLED",
+        7:  "FEATURE_DISABLED",
+        8:  "BAD_REQUEST",
+        9:  "RESPONSE_TOO_LARGE",
+        10: "CANCELLED",
+        11: "REPLAY_ERROR",
+        12: "DEADLINE_EXCEEDED",
+}
+var RpcError_ErrorCode_value = map[string]int32{
+        "UNKNOWN":             0,
+        "CALL_NOT_FOUND":      1,
+        "PARSE_ERROR":         2,
+        "SECURITY_VIOLATION":  3,
+        "OVER_QUOTA":          4,
+        "REQUEST_TOO_LARGE":   5,
+        "CAPABILITY_DISABLED": 6,
+        "FEATURE_DISABLED":    7,
+        "BAD_REQUEST":         8,
+        "RESPONSE_TOO_LARGE":  9,
+        "CANCELLED":           10,
+        "REPLAY_ERROR":        11,
+        "DEADLINE_EXCEEDED":   12,
+}
+
+func (x RpcError_ErrorCode) Enum() *RpcError_ErrorCode {
+        p := new(RpcError_ErrorCode)
+        *p = x
+        return p
+}
+func (x RpcError_ErrorCode) String() string {
+        return proto.EnumName(RpcError_ErrorCode_name, int32(x))
+}
+func (x *RpcError_ErrorCode) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(RpcError_ErrorCode_value, data, "RpcError_ErrorCode")
+        if err != nil {
+                return err
+        }
+        *x = RpcError_ErrorCode(value)
+        return nil
+}
+func (RpcError_ErrorCode) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_remote_api_1978114ec33a273d, []int{2, 0}
+}
+
+type Request struct {
+        ServiceName          *string  `protobuf:"bytes,2,req,name=service_name,json=serviceName" json:"service_name,omitempty"`
+        Method               *string  `protobuf:"bytes,3,req,name=method" json:"method,omitempty"`
+        Request              []byte   `protobuf:"bytes,4,req,name=request" json:"request,omitempty"`
+        RequestId            *string  `protobuf:"bytes,5,opt,name=request_id,json=requestId" json:"request_id,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Request) Reset()         { *m = Request{} }
+func (m *Request) String() string { return proto.CompactTextString(m) }
+func (*Request) ProtoMessage()    {}
+func (*Request) Descriptor() ([]byte, []int) {
+        return fileDescriptor_remote_api_1978114ec33a273d, []int{0}
+}
+func (m *Request) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Request.Unmarshal(m, b)
+}
+func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Request.Marshal(b, m, deterministic)
+}
+func (dst *Request) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Request.Merge(dst, src)
+}
+func (m *Request) XXX_Size() int {
+        return xxx_messageInfo_Request.Size(m)
+}
+func (m *Request) XXX_DiscardUnknown() {
+        xxx_messageInfo_Request.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Request proto.InternalMessageInfo
+
+func (m *Request) GetServiceName() string {
+        if m != nil && m.ServiceName != nil {
+                return *m.ServiceName
+        }
+        return ""
+}
+
+func (m *Request) GetMethod() string {
+        if m != nil && m.Method != nil {
+                return *m.Method
+        }
+        return ""
+}
+
+func (m *Request) GetRequest() []byte {
+        if m != nil {
+                return m.Request
+        }
+        return nil
+}
+
+func (m *Request) GetRequestId() string {
+        if m != nil && m.RequestId != nil {
+                return *m.RequestId
+        }
+        return ""
+}
+
+type ApplicationError struct {
+        Code                 *int32   `protobuf:"varint,1,req,name=code" json:"code,omitempty"`
+        Detail               *string  `protobuf:"bytes,2,req,name=detail" json:"detail,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ApplicationError) Reset()         { *m = ApplicationError{} }
+func (m *ApplicationError) String() string { return proto.CompactTextString(m) }
+func (*ApplicationError) ProtoMessage()    {}
+func (*ApplicationError) Descriptor() ([]byte, []int) {
+        return fileDescriptor_remote_api_1978114ec33a273d, []int{1}
+}
+func (m *ApplicationError) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_ApplicationError.Unmarshal(m, b)
+}
+func (m *ApplicationError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_ApplicationError.Marshal(b, m, deterministic)
+}
+func (dst *ApplicationError) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_ApplicationError.Merge(dst, src)
+}
+func (m *ApplicationError) XXX_Size() int {
+        return xxx_messageInfo_ApplicationError.Size(m)
+}
+func (m *ApplicationError) XXX_DiscardUnknown() {
+        xxx_messageInfo_ApplicationError.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ApplicationError proto.InternalMessageInfo
+
+func (m *ApplicationError) GetCode() int32 {
+        if m != nil && m.Code != nil {
+                return *m.Code
+        }
+        return 0
+}
+
+func (m *ApplicationError) GetDetail() string {
+        if m != nil && m.Detail != nil {
+                return *m.Detail
+        }
+        return ""
+}
+
+type RpcError struct {
+        Code                 *int32   `protobuf:"varint,1,req,name=code" json:"code,omitempty"`
+        Detail               *string  `protobuf:"bytes,2,opt,name=detail" json:"detail,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *RpcError) Reset()         { *m = RpcError{} }
+func (m *RpcError) String() string { return proto.CompactTextString(m) }
+func (*RpcError) ProtoMessage()    {}
+func (*RpcError) Descriptor() ([]byte, []int) {
+        return fileDescriptor_remote_api_1978114ec33a273d, []int{2}
+}
+func (m *RpcError) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_RpcError.Unmarshal(m, b)
+}
+func (m *RpcError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_RpcError.Marshal(b, m, deterministic)
+}
+func (dst *RpcError) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_RpcError.Merge(dst, src)
+}
+func (m *RpcError) XXX_Size() int {
+        return xxx_messageInfo_RpcError.Size(m)
+}
+func (m *RpcError) XXX_DiscardUnknown() {
+        xxx_messageInfo_RpcError.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RpcError proto.InternalMessageInfo
+
+func (m *RpcError) GetCode() int32 {
+        if m != nil && m.Code != nil {
+                return *m.Code
+        }
+        return 0
+}
+
+func (m *RpcError) GetDetail() string {
+        if m != nil && m.Detail != nil {
+                return *m.Detail
+        }
+        return ""
+}
+
+type Response struct {
+        Response             []byte            `protobuf:"bytes,1,opt,name=response" json:"response,omitempty"`
+        Exception            []byte            `protobuf:"bytes,2,opt,name=exception" json:"exception,omitempty"`
+        ApplicationError     *ApplicationError `protobuf:"bytes,3,opt,name=application_error,json=applicationError" json:"application_error,omitempty"`
+        JavaException        []byte            `protobuf:"bytes,4,opt,name=java_exception,json=javaException" json:"java_exception,omitempty"`
+        RpcError             *RpcError         `protobuf:"bytes,5,opt,name=rpc_error,json=rpcError" json:"rpc_error,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+        XXX_unrecognized     []byte            `json:"-"`
+        XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *Response) Reset()         { *m = Response{} }
+func (m *Response) String() string { return proto.CompactTextString(m) }
+func (*Response) ProtoMessage()    {}
+func (*Response) Descriptor() ([]byte, []int) {
+        return fileDescriptor_remote_api_1978114ec33a273d, []int{3}
+}
+func (m *Response) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Response.Unmarshal(m, b)
+}
+func (m *Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Response.Marshal(b, m, deterministic)
+}
+func (dst *Response) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Response.Merge(dst, src)
+}
+func (m *Response) XXX_Size() int {
+        return xxx_messageInfo_Response.Size(m)
+}
+func (m *Response) XXX_DiscardUnknown() {
+        xxx_messageInfo_Response.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Response proto.InternalMessageInfo
+
+func (m *Response) GetResponse() []byte {
+        if m != nil {
+                return m.Response
+        }
+        return nil
+}
+
+func (m *Response) GetException() []byte {
+        if m != nil {
+                return m.Exception
+        }
+        return nil
+}
+
+func (m *Response) GetApplicationError() *ApplicationError {
+        if m != nil {
+                return m.ApplicationError
+        }
+        return nil
+}
+
+func (m *Response) GetJavaException() []byte {
+        if m != nil {
+                return m.JavaException
+        }
+        return nil
+}
+
+func (m *Response) GetRpcError() *RpcError {
+        if m != nil {
+                return m.RpcError
+        }
+        return nil
+}
+
+func init() {
+        proto.RegisterType((*Request)(nil), "remote_api.Request")
+        proto.RegisterType((*ApplicationError)(nil), "remote_api.ApplicationError")
+        proto.RegisterType((*RpcError)(nil), "remote_api.RpcError")
+        proto.RegisterType((*Response)(nil), "remote_api.Response")
+}
+
+func init() {
+        proto.RegisterFile("google.golang.org/appengine/internal/remote_api/remote_api.proto", fileDescriptor_remote_api_1978114ec33a273d)
+}
+
+var fileDescriptor_remote_api_1978114ec33a273d = []byte{
+        // 531 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0x51, 0x6e, 0xd3, 0x40,
+        0x10, 0x86, 0xb1, 0x9b, 0x34, 0xf1, 0xc4, 0x2d, 0xdb, 0xa5, 0x14, 0x0b, 0x15, 0x29, 0x44, 0x42,
+        0xca, 0x53, 0x2a, 0x38, 0x00, 0x62, 0x63, 0x6f, 0x91, 0x85, 0x65, 0xa7, 0x6b, 0xbb, 0x50, 0x5e,
+        0x56, 0x2b, 0x67, 0x65, 0x8c, 0x12, 0xaf, 0xd9, 0x98, 0x8a, 0x17, 0x6e, 0xc0, 0xb5, 0x38, 0x0c,
+        0xb7, 0x40, 0x36, 0x6e, 0x63, 0xf5, 0x89, 0xb7, 0x7f, 0x7e, 0x7b, 0xe6, 0x1b, 0xcd, 0xcc, 0xc2,
+        0xbb, 0x5c, 0xa9, 0x7c, 0x23, 0x17, 0xb9, 0xda, 0x88, 0x32, 0x5f, 0x28, 0x9d, 0x5f, 0x88, 0xaa,
+        0x92, 0x65, 0x5e, 0x94, 0xf2, 0xa2, 0x28, 0x6b, 0xa9, 0x4b, 0xb1, 0xb9, 0xd0, 0x72, 0xab, 0x6a,
+        0xc9, 0x45, 0x55, 0xf4, 0xe4, 0xa2, 0xd2, 0xaa, 0x56, 0x18, 0xf6, 0xce, 0xec, 0x27, 0x8c, 0x98,
+        0xfc, 0xf6, 0x5d, 0xee, 0x6a, 0xfc, 0x12, 0xec, 0x9d, 0xd4, 0xb7, 0x45, 0x26, 0x79, 0x29, 0xb6,
+        0xd2, 0x31, 0xa7, 0xe6, 0xdc, 0x62, 0x93, 0xce, 0x0b, 0xc5, 0x56, 0xe2, 0x33, 0x38, 0xdc, 0xca,
+        0xfa, 0x8b, 0x5a, 0x3b, 0x07, 0xed, 0xc7, 0x2e, 0xc2, 0x0e, 0x8c, 0xf4, 0xbf, 0x2a, 0xce, 0x60,
+        0x6a, 0xce, 0x6d, 0x76, 0x17, 0xe2, 0x17, 0x00, 0x9d, 0xe4, 0xc5, 0xda, 0x19, 0x4e, 0x8d, 0xb9,
+        0xc5, 0xac, 0xce, 0xf1, 0xd7, 0xb3, 0xb7, 0x80, 0x48, 0x55, 0x6d, 0x8a, 0x4c, 0xd4, 0x85, 0x2a,
+        0xa9, 0xd6, 0x4a, 0x63, 0x0c, 0x83, 0x4c, 0xad, 0xa5, 0x63, 0x4c, 0xcd, 0xf9, 0x90, 0xb5, 0xba,
+        0x01, 0xaf, 0x65, 0x2d, 0x8a, 0x4d, 0xd7, 0x55, 0x17, 0xcd, 0x7e, 0x9b, 0x30, 0x66, 0x55, 0xf6,
+        0x7f, 0x89, 0x46, 0x2f, 0xf1, 0x97, 0x09, 0x56, 0x9b, 0xe5, 0x36, 0x7f, 0x4d, 0x60, 0x94, 0x86,
+        0x1f, 0xc2, 0xe8, 0x63, 0x88, 0x1e, 0x61, 0x0c, 0xc7, 0x2e, 0x09, 0x02, 0x1e, 0x46, 0x09, 0xbf,
+        0x8c, 0xd2, 0xd0, 0x43, 0x06, 0x7e, 0x0c, 0x93, 0x15, 0x61, 0x31, 0xe5, 0x94, 0xb1, 0x88, 0x21,
+        0x13, 0x9f, 0x01, 0x8e, 0xa9, 0x9b, 0x32, 0x3f, 0xb9, 0xe1, 0xd7, 0x7e, 0x14, 0x90, 0xc4, 0x8f,
+        0x42, 0x74, 0x80, 0x8f, 0x01, 0xa2, 0x6b, 0xca, 0xf8, 0x55, 0x1a, 0x25, 0x04, 0x0d, 0xf0, 0x53,
+        0x38, 0x61, 0xf4, 0x2a, 0xa5, 0x71, 0xc2, 0x93, 0x28, 0xe2, 0x01, 0x61, 0xef, 0x29, 0x1a, 0xe2,
+        0x67, 0xf0, 0xc4, 0x25, 0x2b, 0xb2, 0xf4, 0x83, 0xa6, 0x80, 0xe7, 0xc7, 0x64, 0x19, 0x50, 0x0f,
+        0x1d, 0xe2, 0x53, 0x40, 0x97, 0x94, 0x24, 0x29, 0xa3, 0x7b, 0x77, 0xd4, 0xe0, 0x97, 0xc4, 0xe3,
+        0x5d, 0x25, 0x34, 0x6e, 0xf0, 0x8c, 0xc6, 0xab, 0x28, 0x8c, 0x69, 0xaf, 0xae, 0x85, 0x8f, 0xc0,
+        0x72, 0x49, 0xe8, 0xd2, 0xa0, 0xc9, 0x03, 0x8c, 0xc0, 0x66, 0x74, 0x15, 0x90, 0x9b, 0xae, 0xef,
+        0x49, 0xd3, 0x8f, 0x47, 0x89, 0x17, 0xf8, 0x21, 0xe5, 0xf4, 0x93, 0x4b, 0xa9, 0x47, 0x3d, 0x64,
+        0xcf, 0xfe, 0x18, 0x30, 0x66, 0x72, 0x57, 0xa9, 0x72, 0x27, 0xf1, 0x73, 0x18, 0xeb, 0x4e, 0x3b,
+        0xc6, 0xd4, 0x98, 0xdb, 0xec, 0x3e, 0xc6, 0xe7, 0x60, 0xc9, 0x1f, 0x99, 0xac, 0x9a, 0x75, 0xb5,
+        0x23, 0xb5, 0xd9, 0xde, 0xc0, 0x3e, 0x9c, 0x88, 0xfd, 0x3a, 0xb9, 0x6c, 0x06, 0xec, 0x1c, 0x4c,
+        0x8d, 0xf9, 0xe4, 0xcd, 0xf9, 0xa2, 0x77, 0x87, 0x0f, 0x77, 0xce, 0x90, 0x78, 0x78, 0x05, 0xaf,
+        0xe0, 0xf8, 0xab, 0xb8, 0x15, 0x7c, 0x4f, 0x1b, 0xb4, 0xb4, 0xa3, 0xc6, 0xa5, 0xf7, 0xc4, 0xd7,
+        0x60, 0xe9, 0x2a, 0xeb, 0x48, 0xc3, 0x96, 0x74, 0xda, 0x27, 0xdd, 0x1d, 0x07, 0x1b, 0xeb, 0x4e,
+        0x2d, 0xed, 0xcf, 0xbd, 0x07, 0xf0, 0x37, 0x00, 0x00, 0xff, 0xff, 0x38, 0xd1, 0x0f, 0x22, 0x4f,
+        0x03, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/appengine/internal/remote_api/remote_api.proto b/vendor/google.golang.org/appengine/internal/remote_api/remote_api.proto
new file mode 100644
index 0000000..f21763a
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/remote_api/remote_api.proto
@@ -0,0 +1,44 @@
+syntax = "proto2";
+option go_package = "remote_api";
+
+package remote_api;
+
+message Request {
+  required string service_name = 2;
+  required string method = 3;
+  required bytes request = 4;
+  optional string request_id = 5;
+}
+
+message ApplicationError {
+  required int32 code = 1;
+  required string detail = 2;
+}
+
+message RpcError {
+  enum ErrorCode {
+    UNKNOWN = 0;
+    CALL_NOT_FOUND = 1;
+    PARSE_ERROR = 2;
+    SECURITY_VIOLATION = 3;
+    OVER_QUOTA = 4;
+    REQUEST_TOO_LARGE = 5;
+    CAPABILITY_DISABLED = 6;
+    FEATURE_DISABLED = 7;
+    BAD_REQUEST = 8;
+    RESPONSE_TOO_LARGE = 9;
+    CANCELLED = 10;
+    REPLAY_ERROR = 11;
+    DEADLINE_EXCEEDED = 12;
+  }
+  required int32 code = 1;
+  optional string detail = 2;
+}
+
+message Response {
+  optional bytes response = 1;
+  optional bytes exception = 2;
+  optional ApplicationError application_error = 3;
+  optional bytes java_exception = 4;
+  optional RpcError rpc_error = 5;
+}
diff --git a/vendor/google.golang.org/appengine/internal/transaction.go b/vendor/google.golang.org/appengine/internal/transaction.go
new file mode 100644
index 0000000..9006ae6
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/transaction.go
@@ -0,0 +1,115 @@
+// Copyright 2014 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package internal
+
+// This file implements hooks for applying datastore transactions.
+
+import (
+        "errors"
+        "reflect"
+
+        "github.com/golang/protobuf/proto"
+        netcontext "golang.org/x/net/context"
+
+        basepb "google.golang.org/appengine/internal/base"
+        pb "google.golang.org/appengine/internal/datastore"
+)
+
+var transactionSetters = make(map[reflect.Type]reflect.Value)
+
+// RegisterTransactionSetter registers a function that sets transaction information
+// in a protocol buffer message. f should be a function with two arguments,
+// the first being a protocol buffer type, and the second being *datastore.Transaction.
+func RegisterTransactionSetter(f interface{}) {
+        v := reflect.ValueOf(f)
+        transactionSetters[v.Type().In(0)] = v
+}
+
+// applyTransaction applies the transaction t to message pb
+// by using the relevant setter passed to RegisterTransactionSetter.
+func applyTransaction(pb proto.Message, t *pb.Transaction) {
+        v := reflect.ValueOf(pb)
+        if f, ok := transactionSetters[v.Type()]; ok {
+                f.Call([]reflect.Value{v, reflect.ValueOf(t)})
+        }
+}
+
+var transactionKey = "used for *Transaction"
+
+func transactionFromContext(ctx netcontext.Context) *transaction {
+        t, _ := ctx.Value(&transactionKey).(*transaction)
+        return t
+}
+
+func withTransaction(ctx netcontext.Context, t *transaction) netcontext.Context {
+        return netcontext.WithValue(ctx, &transactionKey, t)
+}
+
+type transaction struct {
+        transaction pb.Transaction
+        finished    bool
+}
+
+var ErrConcurrentTransaction = errors.New("internal: concurrent transaction")
+
+func RunTransactionOnce(c netcontext.Context, f func(netcontext.Context) error, xg bool, readOnly bool, previousTransaction *pb.Transaction) (*pb.Transaction, error) {
+        if transactionFromContext(c) != nil {
+                return nil, errors.New("nested transactions are not supported")
+        }
+
+        // Begin the transaction.
+        t := &transaction{}
+        req := &pb.BeginTransactionRequest{
+                App: proto.String(FullyQualifiedAppID(c)),
+        }
+        if xg {
+                req.AllowMultipleEg = proto.Bool(true)
+        }
+        if previousTransaction != nil {
+                req.PreviousTransaction = previousTransaction
+        }
+        if readOnly {
+                req.Mode = pb.BeginTransactionRequest_READ_ONLY.Enum()
+        } else {
+                req.Mode = pb.BeginTransactionRequest_READ_WRITE.Enum()
+        }
+        if err := Call(c, "datastore_v3", "BeginTransaction", req, &t.transaction); err != nil {
+                return nil, err
+        }
+
+        // Call f, rolling back the transaction if f returns a non-nil error, or panics.
+        // The panic is not recovered.
+        defer func() {
+                if t.finished {
+                        return
+                }
+                t.finished = true
+                // Ignore the error return value, since we are already returning a non-nil
+                // error (or we're panicking).
+                Call(c, "datastore_v3", "Rollback", &t.transaction, &basepb.VoidProto{})
+        }()
+        if err := f(withTransaction(c, t)); err != nil {
+                return &t.transaction, err
+        }
+        t.finished = true
+
+        // Commit the transaction.
+        res := &pb.CommitResponse{}
+        err := Call(c, "datastore_v3", "Commit", &t.transaction, res)
+        if ae, ok := err.(*APIError); ok {
+                /* TODO: restore this conditional
+                if appengine.IsDevAppServer() {
+                */
+                // The Python Dev AppServer raises an ApplicationError with error code 2 (which is
+                // Error.CONCURRENT_TRANSACTION) and message "Concurrency exception.".
+                if ae.Code == int32(pb.Error_BAD_REQUEST) && ae.Detail == "ApplicationError: 2 Concurrency exception." {
+                        return &t.transaction, ErrConcurrentTransaction
+                }
+                if ae.Code == int32(pb.Error_CONCURRENT_TRANSACTION) {
+                        return &t.transaction, ErrConcurrentTransaction
+                }
+        }
+        return &t.transaction, err
+}
diff --git a/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.pb.go b/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.pb.go
new file mode 100644
index 0000000..5f72775
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.pb.go
@@ -0,0 +1,527 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto
+
+package urlfetch
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// 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
+
+type URLFetchServiceError_ErrorCode int32
+
+const (
+        URLFetchServiceError_OK                       URLFetchServiceError_ErrorCode = 0
+        URLFetchServiceError_INVALID_URL              URLFetchServiceError_ErrorCode = 1
+        URLFetchServiceError_FETCH_ERROR              URLFetchServiceError_ErrorCode = 2
+        URLFetchServiceError_UNSPECIFIED_ERROR        URLFetchServiceError_ErrorCode = 3
+        URLFetchServiceError_RESPONSE_TOO_LARGE       URLFetchServiceError_ErrorCode = 4
+        URLFetchServiceError_DEADLINE_EXCEEDED        URLFetchServiceError_ErrorCode = 5
+        URLFetchServiceError_SSL_CERTIFICATE_ERROR    URLFetchServiceError_ErrorCode = 6
+        URLFetchServiceError_DNS_ERROR                URLFetchServiceError_ErrorCode = 7
+        URLFetchServiceError_CLOSED                   URLFetchServiceError_ErrorCode = 8
+        URLFetchServiceError_INTERNAL_TRANSIENT_ERROR URLFetchServiceError_ErrorCode = 9
+        URLFetchServiceError_TOO_MANY_REDIRECTS       URLFetchServiceError_ErrorCode = 10
+        URLFetchServiceError_MALFORMED_REPLY          URLFetchServiceError_ErrorCode = 11
+        URLFetchServiceError_CONNECTION_ERROR         URLFetchServiceError_ErrorCode = 12
+)
+
+var URLFetchServiceError_ErrorCode_name = map[int32]string{
+        0:  "OK",
+        1:  "INVALID_URL",
+        2:  "FETCH_ERROR",
+        3:  "UNSPECIFIED_ERROR",
+        4:  "RESPONSE_TOO_LARGE",
+        5:  "DEADLINE_EXCEEDED",
+        6:  "SSL_CERTIFICATE_ERROR",
+        7:  "DNS_ERROR",
+        8:  "CLOSED",
+        9:  "INTERNAL_TRANSIENT_ERROR",
+        10: "TOO_MANY_REDIRECTS",
+        11: "MALFORMED_REPLY",
+        12: "CONNECTION_ERROR",
+}
+var URLFetchServiceError_ErrorCode_value = map[string]int32{
+        "OK":                       0,
+        "INVALID_URL":              1,
+        "FETCH_ERROR":              2,
+        "UNSPECIFIED_ERROR":        3,
+        "RESPONSE_TOO_LARGE":       4,
+        "DEADLINE_EXCEEDED":        5,
+        "SSL_CERTIFICATE_ERROR":    6,
+        "DNS_ERROR":                7,
+        "CLOSED":                   8,
+        "INTERNAL_TRANSIENT_ERROR": 9,
+        "TOO_MANY_REDIRECTS":       10,
+        "MALFORMED_REPLY":          11,
+        "CONNECTION_ERROR":         12,
+}
+
+func (x URLFetchServiceError_ErrorCode) Enum() *URLFetchServiceError_ErrorCode {
+        p := new(URLFetchServiceError_ErrorCode)
+        *p = x
+        return p
+}
+func (x URLFetchServiceError_ErrorCode) String() string {
+        return proto.EnumName(URLFetchServiceError_ErrorCode_name, int32(x))
+}
+func (x *URLFetchServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(URLFetchServiceError_ErrorCode_value, data, "URLFetchServiceError_ErrorCode")
+        if err != nil {
+                return err
+        }
+        *x = URLFetchServiceError_ErrorCode(value)
+        return nil
+}
+func (URLFetchServiceError_ErrorCode) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{0, 0}
+}
+
+type URLFetchRequest_RequestMethod int32
+
+const (
+        URLFetchRequest_GET    URLFetchRequest_RequestMethod = 1
+        URLFetchRequest_POST   URLFetchRequest_RequestMethod = 2
+        URLFetchRequest_HEAD   URLFetchRequest_RequestMethod = 3
+        URLFetchRequest_PUT    URLFetchRequest_RequestMethod = 4
+        URLFetchRequest_DELETE URLFetchRequest_RequestMethod = 5
+        URLFetchRequest_PATCH  URLFetchRequest_RequestMethod = 6
+)
+
+var URLFetchRequest_RequestMethod_name = map[int32]string{
+        1: "GET",
+        2: "POST",
+        3: "HEAD",
+        4: "PUT",
+        5: "DELETE",
+        6: "PATCH",
+}
+var URLFetchRequest_RequestMethod_value = map[string]int32{
+        "GET":    1,
+        "POST":   2,
+        "HEAD":   3,
+        "PUT":    4,
+        "DELETE": 5,
+        "PATCH":  6,
+}
+
+func (x URLFetchRequest_RequestMethod) Enum() *URLFetchRequest_RequestMethod {
+        p := new(URLFetchRequest_RequestMethod)
+        *p = x
+        return p
+}
+func (x URLFetchRequest_RequestMethod) String() string {
+        return proto.EnumName(URLFetchRequest_RequestMethod_name, int32(x))
+}
+func (x *URLFetchRequest_RequestMethod) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(URLFetchRequest_RequestMethod_value, data, "URLFetchRequest_RequestMethod")
+        if err != nil {
+                return err
+        }
+        *x = URLFetchRequest_RequestMethod(value)
+        return nil
+}
+func (URLFetchRequest_RequestMethod) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{1, 0}
+}
+
+type URLFetchServiceError struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *URLFetchServiceError) Reset()         { *m = URLFetchServiceError{} }
+func (m *URLFetchServiceError) String() string { return proto.CompactTextString(m) }
+func (*URLFetchServiceError) ProtoMessage()    {}
+func (*URLFetchServiceError) Descriptor() ([]byte, []int) {
+        return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{0}
+}
+func (m *URLFetchServiceError) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_URLFetchServiceError.Unmarshal(m, b)
+}
+func (m *URLFetchServiceError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_URLFetchServiceError.Marshal(b, m, deterministic)
+}
+func (dst *URLFetchServiceError) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_URLFetchServiceError.Merge(dst, src)
+}
+func (m *URLFetchServiceError) XXX_Size() int {
+        return xxx_messageInfo_URLFetchServiceError.Size(m)
+}
+func (m *URLFetchServiceError) XXX_DiscardUnknown() {
+        xxx_messageInfo_URLFetchServiceError.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_URLFetchServiceError proto.InternalMessageInfo
+
+type URLFetchRequest struct {
+        Method                        *URLFetchRequest_RequestMethod `protobuf:"varint,1,req,name=Method,enum=appengine.URLFetchRequest_RequestMethod" json:"Method,omitempty"`
+        Url                           *string                        `protobuf:"bytes,2,req,name=Url" json:"Url,omitempty"`
+        Header                        []*URLFetchRequest_Header      `protobuf:"group,3,rep,name=Header,json=header" json:"header,omitempty"`
+        Payload                       []byte                         `protobuf:"bytes,6,opt,name=Payload" json:"Payload,omitempty"`
+        FollowRedirects               *bool                          `protobuf:"varint,7,opt,name=FollowRedirects,def=1" json:"FollowRedirects,omitempty"`
+        Deadline                      *float64                       `protobuf:"fixed64,8,opt,name=Deadline" json:"Deadline,omitempty"`
+        MustValidateServerCertificate *bool                          `protobuf:"varint,9,opt,name=MustValidateServerCertificate,def=1" json:"MustValidateServerCertificate,omitempty"`
+        XXX_NoUnkeyedLiteral          struct{}                       `json:"-"`
+        XXX_unrecognized              []byte                         `json:"-"`
+        XXX_sizecache                 int32                          `json:"-"`
+}
+
+func (m *URLFetchRequest) Reset()         { *m = URLFetchRequest{} }
+func (m *URLFetchRequest) String() string { return proto.CompactTextString(m) }
+func (*URLFetchRequest) ProtoMessage()    {}
+func (*URLFetchRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{1}
+}
+func (m *URLFetchRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_URLFetchRequest.Unmarshal(m, b)
+}
+func (m *URLFetchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_URLFetchRequest.Marshal(b, m, deterministic)
+}
+func (dst *URLFetchRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_URLFetchRequest.Merge(dst, src)
+}
+func (m *URLFetchRequest) XXX_Size() int {
+        return xxx_messageInfo_URLFetchRequest.Size(m)
+}
+func (m *URLFetchRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_URLFetchRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_URLFetchRequest proto.InternalMessageInfo
+
+const Default_URLFetchRequest_FollowRedirects bool = true
+const Default_URLFetchRequest_MustValidateServerCertificate bool = true
+
+func (m *URLFetchRequest) GetMethod() URLFetchRequest_RequestMethod {
+        if m != nil && m.Method != nil {
+                return *m.Method
+        }
+        return URLFetchRequest_GET
+}
+
+func (m *URLFetchRequest) GetUrl() string {
+        if m != nil && m.Url != nil {
+                return *m.Url
+        }
+        return ""
+}
+
+func (m *URLFetchRequest) GetHeader() []*URLFetchRequest_Header {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *URLFetchRequest) GetPayload() []byte {
+        if m != nil {
+                return m.Payload
+        }
+        return nil
+}
+
+func (m *URLFetchRequest) GetFollowRedirects() bool {
+        if m != nil && m.FollowRedirects != nil {
+                return *m.FollowRedirects
+        }
+        return Default_URLFetchRequest_FollowRedirects
+}
+
+func (m *URLFetchRequest) GetDeadline() float64 {
+        if m != nil && m.Deadline != nil {
+                return *m.Deadline
+        }
+        return 0
+}
+
+func (m *URLFetchRequest) GetMustValidateServerCertificate() bool {
+        if m != nil && m.MustValidateServerCertificate != nil {
+                return *m.MustValidateServerCertificate
+        }
+        return Default_URLFetchRequest_MustValidateServerCertificate
+}
+
+type URLFetchRequest_Header struct {
+        Key                  *string  `protobuf:"bytes,4,req,name=Key" json:"Key,omitempty"`
+        Value                *string  `protobuf:"bytes,5,req,name=Value" json:"Value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *URLFetchRequest_Header) Reset()         { *m = URLFetchRequest_Header{} }
+func (m *URLFetchRequest_Header) String() string { return proto.CompactTextString(m) }
+func (*URLFetchRequest_Header) ProtoMessage()    {}
+func (*URLFetchRequest_Header) Descriptor() ([]byte, []int) {
+        return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{1, 0}
+}
+func (m *URLFetchRequest_Header) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_URLFetchRequest_Header.Unmarshal(m, b)
+}
+func (m *URLFetchRequest_Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_URLFetchRequest_Header.Marshal(b, m, deterministic)
+}
+func (dst *URLFetchRequest_Header) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_URLFetchRequest_Header.Merge(dst, src)
+}
+func (m *URLFetchRequest_Header) XXX_Size() int {
+        return xxx_messageInfo_URLFetchRequest_Header.Size(m)
+}
+func (m *URLFetchRequest_Header) XXX_DiscardUnknown() {
+        xxx_messageInfo_URLFetchRequest_Header.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_URLFetchRequest_Header proto.InternalMessageInfo
+
+func (m *URLFetchRequest_Header) GetKey() string {
+        if m != nil && m.Key != nil {
+                return *m.Key
+        }
+        return ""
+}
+
+func (m *URLFetchRequest_Header) GetValue() string {
+        if m != nil && m.Value != nil {
+                return *m.Value
+        }
+        return ""
+}
+
+type URLFetchResponse struct {
+        Content               []byte                     `protobuf:"bytes,1,opt,name=Content" json:"Content,omitempty"`
+        StatusCode            *int32                     `protobuf:"varint,2,req,name=StatusCode" json:"StatusCode,omitempty"`
+        Header                []*URLFetchResponse_Header `protobuf:"group,3,rep,name=Header,json=header" json:"header,omitempty"`
+        ContentWasTruncated   *bool                      `protobuf:"varint,6,opt,name=ContentWasTruncated,def=0" json:"ContentWasTruncated,omitempty"`
+        ExternalBytesSent     *int64                     `protobuf:"varint,7,opt,name=ExternalBytesSent" json:"ExternalBytesSent,omitempty"`
+        ExternalBytesReceived *int64                     `protobuf:"varint,8,opt,name=ExternalBytesReceived" json:"ExternalBytesReceived,omitempty"`
+        FinalUrl              *string                    `protobuf:"bytes,9,opt,name=FinalUrl" json:"FinalUrl,omitempty"`
+        ApiCpuMilliseconds    *int64                     `protobuf:"varint,10,opt,name=ApiCpuMilliseconds,def=0" json:"ApiCpuMilliseconds,omitempty"`
+        ApiBytesSent          *int64                     `protobuf:"varint,11,opt,name=ApiBytesSent,def=0" json:"ApiBytesSent,omitempty"`
+        ApiBytesReceived      *int64                     `protobuf:"varint,12,opt,name=ApiBytesReceived,def=0" json:"ApiBytesReceived,omitempty"`
+        XXX_NoUnkeyedLiteral  struct{}                   `json:"-"`
+        XXX_unrecognized      []byte                     `json:"-"`
+        XXX_sizecache         int32                      `json:"-"`
+}
+
+func (m *URLFetchResponse) Reset()         { *m = URLFetchResponse{} }
+func (m *URLFetchResponse) String() string { return proto.CompactTextString(m) }
+func (*URLFetchResponse) ProtoMessage()    {}
+func (*URLFetchResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{2}
+}
+func (m *URLFetchResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_URLFetchResponse.Unmarshal(m, b)
+}
+func (m *URLFetchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_URLFetchResponse.Marshal(b, m, deterministic)
+}
+func (dst *URLFetchResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_URLFetchResponse.Merge(dst, src)
+}
+func (m *URLFetchResponse) XXX_Size() int {
+        return xxx_messageInfo_URLFetchResponse.Size(m)
+}
+func (m *URLFetchResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_URLFetchResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_URLFetchResponse proto.InternalMessageInfo
+
+const Default_URLFetchResponse_ContentWasTruncated bool = false
+const Default_URLFetchResponse_ApiCpuMilliseconds int64 = 0
+const Default_URLFetchResponse_ApiBytesSent int64 = 0
+const Default_URLFetchResponse_ApiBytesReceived int64 = 0
+
+func (m *URLFetchResponse) GetContent() []byte {
+        if m != nil {
+                return m.Content
+        }
+        return nil
+}
+
+func (m *URLFetchResponse) GetStatusCode() int32 {
+        if m != nil && m.StatusCode != nil {
+                return *m.StatusCode
+        }
+        return 0
+}
+
+func (m *URLFetchResponse) GetHeader() []*URLFetchResponse_Header {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *URLFetchResponse) GetContentWasTruncated() bool {
+        if m != nil && m.ContentWasTruncated != nil {
+                return *m.ContentWasTruncated
+        }
+        return Default_URLFetchResponse_ContentWasTruncated
+}
+
+func (m *URLFetchResponse) GetExternalBytesSent() int64 {
+        if m != nil && m.ExternalBytesSent != nil {
+                return *m.ExternalBytesSent
+        }
+        return 0
+}
+
+func (m *URLFetchResponse) GetExternalBytesReceived() int64 {
+        if m != nil && m.ExternalBytesReceived != nil {
+                return *m.ExternalBytesReceived
+        }
+        return 0
+}
+
+func (m *URLFetchResponse) GetFinalUrl() string {
+        if m != nil && m.FinalUrl != nil {
+                return *m.FinalUrl
+        }
+        return ""
+}
+
+func (m *URLFetchResponse) GetApiCpuMilliseconds() int64 {
+        if m != nil && m.ApiCpuMilliseconds != nil {
+                return *m.ApiCpuMilliseconds
+        }
+        return Default_URLFetchResponse_ApiCpuMilliseconds
+}
+
+func (m *URLFetchResponse) GetApiBytesSent() int64 {
+        if m != nil && m.ApiBytesSent != nil {
+                return *m.ApiBytesSent
+        }
+        return Default_URLFetchResponse_ApiBytesSent
+}
+
+func (m *URLFetchResponse) GetApiBytesReceived() int64 {
+        if m != nil && m.ApiBytesReceived != nil {
+                return *m.ApiBytesReceived
+        }
+        return Default_URLFetchResponse_ApiBytesReceived
+}
+
+type URLFetchResponse_Header struct {
+        Key                  *string  `protobuf:"bytes,4,req,name=Key" json:"Key,omitempty"`
+        Value                *string  `protobuf:"bytes,5,req,name=Value" json:"Value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *URLFetchResponse_Header) Reset()         { *m = URLFetchResponse_Header{} }
+func (m *URLFetchResponse_Header) String() string { return proto.CompactTextString(m) }
+func (*URLFetchResponse_Header) ProtoMessage()    {}
+func (*URLFetchResponse_Header) Descriptor() ([]byte, []int) {
+        return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{2, 0}
+}
+func (m *URLFetchResponse_Header) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_URLFetchResponse_Header.Unmarshal(m, b)
+}
+func (m *URLFetchResponse_Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_URLFetchResponse_Header.Marshal(b, m, deterministic)
+}
+func (dst *URLFetchResponse_Header) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_URLFetchResponse_Header.Merge(dst, src)
+}
+func (m *URLFetchResponse_Header) XXX_Size() int {
+        return xxx_messageInfo_URLFetchResponse_Header.Size(m)
+}
+func (m *URLFetchResponse_Header) XXX_DiscardUnknown() {
+        xxx_messageInfo_URLFetchResponse_Header.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_URLFetchResponse_Header proto.InternalMessageInfo
+
+func (m *URLFetchResponse_Header) GetKey() string {
+        if m != nil && m.Key != nil {
+                return *m.Key
+        }
+        return ""
+}
+
+func (m *URLFetchResponse_Header) GetValue() string {
+        if m != nil && m.Value != nil {
+                return *m.Value
+        }
+        return ""
+}
+
+func init() {
+        proto.RegisterType((*URLFetchServiceError)(nil), "appengine.URLFetchServiceError")
+        proto.RegisterType((*URLFetchRequest)(nil), "appengine.URLFetchRequest")
+        proto.RegisterType((*URLFetchRequest_Header)(nil), "appengine.URLFetchRequest.Header")
+        proto.RegisterType((*URLFetchResponse)(nil), "appengine.URLFetchResponse")
+        proto.RegisterType((*URLFetchResponse_Header)(nil), "appengine.URLFetchResponse.Header")
+}
+
+func init() {
+        proto.RegisterFile("google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto", fileDescriptor_urlfetch_service_b245a7065f33bced)
+}
+
+var fileDescriptor_urlfetch_service_b245a7065f33bced = []byte{
+        // 770 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xdd, 0x6e, 0xe3, 0x54,
+        0x10, 0xc6, 0x76, 0x7e, 0xa7, 0x5d, 0x7a, 0x76, 0xb6, 0x45, 0x66, 0xb5, 0xa0, 0x10, 0x09, 0x29,
+        0x17, 0x90, 0x2e, 0x2b, 0x24, 0x44, 0xaf, 0x70, 0xed, 0x93, 0xad, 0xa9, 0x63, 0x47, 0xc7, 0x4e,
+        0x61, 0xb9, 0xb1, 0xac, 0x78, 0x9a, 0x5a, 0xb2, 0xec, 0x60, 0x9f, 0x2c, 0xf4, 0x35, 0x78, 0x0d,
+        0xde, 0x87, 0xa7, 0xe1, 0x02, 0x9d, 0xc4, 0xc9, 0x6e, 0xbb, 0xd1, 0x4a, 0x5c, 0x65, 0xe6, 0x9b,
+        0xef, 0xcc, 0x99, 0x7c, 0xdf, 0xf8, 0x80, 0xb3, 0x2c, 0xcb, 0x65, 0x4e, 0xe3, 0x65, 0x99, 0x27,
+        0xc5, 0x72, 0x5c, 0x56, 0xcb, 0xf3, 0x64, 0xb5, 0xa2, 0x62, 0x99, 0x15, 0x74, 0x9e, 0x15, 0x92,
+        0xaa, 0x22, 0xc9, 0xcf, 0xd7, 0x55, 0x7e, 0x4b, 0x72, 0x71, 0xb7, 0x0f, 0xe2, 0x9a, 0xaa, 0xb7,
+        0xd9, 0x82, 0xc6, 0xab, 0xaa, 0x94, 0x25, 0xf6, 0xf7, 0x67, 0x86, 0x7f, 0xeb, 0x70, 0x3a, 0x17,
+        0xde, 0x44, 0xb1, 0xc2, 0x2d, 0x89, 0x57, 0x55, 0x59, 0x0d, 0xff, 0xd2, 0xa1, 0xbf, 0x89, 0xec,
+        0x32, 0x25, 0xec, 0x80, 0x1e, 0x5c, 0xb3, 0x4f, 0xf0, 0x04, 0x8e, 0x5c, 0xff, 0xc6, 0xf2, 0x5c,
+        0x27, 0x9e, 0x0b, 0x8f, 0x69, 0x0a, 0x98, 0xf0, 0xc8, 0xbe, 0x8a, 0xb9, 0x10, 0x81, 0x60, 0x3a,
+        0x9e, 0xc1, 0xd3, 0xb9, 0x1f, 0xce, 0xb8, 0xed, 0x4e, 0x5c, 0xee, 0x34, 0xb0, 0x81, 0x9f, 0x01,
+        0x0a, 0x1e, 0xce, 0x02, 0x3f, 0xe4, 0x71, 0x14, 0x04, 0xb1, 0x67, 0x89, 0xd7, 0x9c, 0xb5, 0x14,
+        0xdd, 0xe1, 0x96, 0xe3, 0xb9, 0x3e, 0x8f, 0xf9, 0xaf, 0x36, 0xe7, 0x0e, 0x77, 0x58, 0x1b, 0x3f,
+        0x87, 0xb3, 0x30, 0xf4, 0x62, 0x9b, 0x8b, 0xc8, 0x9d, 0xb8, 0xb6, 0x15, 0xf1, 0xa6, 0x53, 0x07,
+        0x9f, 0x40, 0xdf, 0xf1, 0xc3, 0x26, 0xed, 0x22, 0x40, 0xc7, 0xf6, 0x82, 0x90, 0x3b, 0xac, 0x87,
+        0x2f, 0xc0, 0x74, 0xfd, 0x88, 0x0b, 0xdf, 0xf2, 0xe2, 0x48, 0x58, 0x7e, 0xe8, 0x72, 0x3f, 0x6a,
+        0x98, 0x7d, 0x35, 0x82, 0xba, 0x79, 0x6a, 0xf9, 0x6f, 0x62, 0xc1, 0x1d, 0x57, 0x70, 0x3b, 0x0a,
+        0x19, 0xe0, 0x33, 0x38, 0x99, 0x5a, 0xde, 0x24, 0x10, 0x53, 0xee, 0xc4, 0x82, 0xcf, 0xbc, 0x37,
+        0xec, 0x08, 0x4f, 0x81, 0xd9, 0x81, 0xef, 0x73, 0x3b, 0x72, 0x03, 0xbf, 0x69, 0x71, 0x3c, 0xfc,
+        0xc7, 0x80, 0x93, 0x9d, 0x5a, 0x82, 0x7e, 0x5f, 0x53, 0x2d, 0xf1, 0x27, 0xe8, 0x4c, 0x49, 0xde,
+        0x95, 0xa9, 0xa9, 0x0d, 0xf4, 0xd1, 0xa7, 0xaf, 0x46, 0xe3, 0xbd, 0xba, 0xe3, 0x47, 0xdc, 0x71,
+        0xf3, 0xbb, 0xe5, 0x8b, 0xe6, 0x1c, 0x32, 0x30, 0xe6, 0x55, 0x6e, 0xea, 0x03, 0x7d, 0xd4, 0x17,
+        0x2a, 0xc4, 0x1f, 0xa1, 0x73, 0x47, 0x49, 0x4a, 0x95, 0x69, 0x0c, 0x8c, 0x11, 0xbc, 0xfa, 0xea,
+        0x23, 0x3d, 0xaf, 0x36, 0x44, 0xd1, 0x1c, 0xc0, 0x17, 0xd0, 0x9d, 0x25, 0xf7, 0x79, 0x99, 0xa4,
+        0x66, 0x67, 0xa0, 0x8d, 0x8e, 0x2f, 0xf5, 0x9e, 0x26, 0x76, 0x10, 0x8e, 0xe1, 0x64, 0x52, 0xe6,
+        0x79, 0xf9, 0x87, 0xa0, 0x34, 0xab, 0x68, 0x21, 0x6b, 0xb3, 0x3b, 0xd0, 0x46, 0xbd, 0x8b, 0x96,
+        0xac, 0xd6, 0x24, 0x1e, 0x17, 0xf1, 0x39, 0xf4, 0x1c, 0x4a, 0xd2, 0x3c, 0x2b, 0xc8, 0xec, 0x0d,
+        0xb4, 0x91, 0x26, 0xf6, 0x39, 0xfe, 0x0c, 0x5f, 0x4c, 0xd7, 0xb5, 0xbc, 0x49, 0xf2, 0x2c, 0x4d,
+        0x24, 0xa9, 0xed, 0xa1, 0xca, 0xa6, 0x4a, 0x66, 0xb7, 0xd9, 0x22, 0x91, 0x64, 0xf6, 0xdf, 0xeb,
+        0xfc, 0x71, 0xea, 0xf3, 0x97, 0xd0, 0xd9, 0xfe, 0x0f, 0x25, 0xc6, 0x35, 0xdd, 0x9b, 0xad, 0xad,
+        0x18, 0xd7, 0x74, 0x8f, 0xa7, 0xd0, 0xbe, 0x49, 0xf2, 0x35, 0x99, 0xed, 0x0d, 0xb6, 0x4d, 0x86,
+        0x1e, 0x3c, 0x79, 0xa0, 0x26, 0x76, 0xc1, 0x78, 0xcd, 0x23, 0xa6, 0x61, 0x0f, 0x5a, 0xb3, 0x20,
+        0x8c, 0x98, 0xae, 0xa2, 0x2b, 0x6e, 0x39, 0xcc, 0x50, 0xc5, 0xd9, 0x3c, 0x62, 0x2d, 0xb5, 0x2e,
+        0x0e, 0xf7, 0x78, 0xc4, 0x59, 0x1b, 0xfb, 0xd0, 0x9e, 0x59, 0x91, 0x7d, 0xc5, 0x3a, 0xc3, 0x7f,
+        0x0d, 0x60, 0xef, 0x84, 0xad, 0x57, 0x65, 0x51, 0x13, 0x9a, 0xd0, 0xb5, 0xcb, 0x42, 0x52, 0x21,
+        0x4d, 0x4d, 0x49, 0x29, 0x76, 0x29, 0x7e, 0x09, 0x10, 0xca, 0x44, 0xae, 0x6b, 0xf5, 0x71, 0x6c,
+        0x8c, 0x6b, 0x8b, 0xf7, 0x10, 0xbc, 0x78, 0xe4, 0xdf, 0xf0, 0xa0, 0x7f, 0xdb, 0x6b, 0x1e, 0x1b,
+        0xf8, 0x03, 0x3c, 0x6b, 0xae, 0xf9, 0x25, 0xa9, 0xa3, 0x6a, 0x5d, 0x28, 0x81, 0xb6, 0x66, 0xf6,
+        0x2e, 0xda, 0xb7, 0x49, 0x5e, 0x93, 0x38, 0xc4, 0xc0, 0x6f, 0xe0, 0x29, 0xff, 0x73, 0xfb, 0x02,
+        0x5c, 0xde, 0x4b, 0xaa, 0x43, 0x35, 0xb8, 0x72, 0xd7, 0x10, 0x1f, 0x16, 0xf0, 0x7b, 0x38, 0x7b,
+        0x00, 0x0a, 0x5a, 0x50, 0xf6, 0x96, 0xd2, 0x8d, 0xcd, 0x86, 0x38, 0x5c, 0x54, 0xfb, 0x30, 0xc9,
+        0x8a, 0x24, 0x57, 0xfb, 0xaa, 0xec, 0xed, 0x8b, 0x7d, 0x8e, 0xdf, 0x01, 0x5a, 0xab, 0xcc, 0x5e,
+        0xad, 0xa7, 0x59, 0x9e, 0x67, 0x35, 0x2d, 0xca, 0x22, 0xad, 0x4d, 0x50, 0xed, 0x2e, 0xb4, 0x97,
+        0xe2, 0x40, 0x11, 0xbf, 0x86, 0x63, 0x6b, 0x95, 0xbd, 0x9b, 0xf6, 0x68, 0x47, 0x7e, 0x00, 0xe3,
+        0xb7, 0xc0, 0x76, 0xf9, 0x7e, 0xcc, 0xe3, 0x1d, 0xf5, 0x83, 0xd2, 0xff, 0x5f, 0xa6, 0x4b, 0xf8,
+        0xad, 0xb7, 0x7b, 0x2a, 0xff, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x1d, 0x9f, 0x6d, 0x24, 0x63, 0x05,
+        0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto b/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto
new file mode 100644
index 0000000..f695edf
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto
@@ -0,0 +1,64 @@
+syntax = "proto2";
+option go_package = "urlfetch";
+
+package appengine;
+
+message URLFetchServiceError {
+  enum ErrorCode {
+    OK = 0;
+    INVALID_URL = 1;
+    FETCH_ERROR = 2;
+    UNSPECIFIED_ERROR = 3;
+    RESPONSE_TOO_LARGE = 4;
+    DEADLINE_EXCEEDED = 5;
+    SSL_CERTIFICATE_ERROR = 6;
+    DNS_ERROR = 7;
+    CLOSED = 8;
+    INTERNAL_TRANSIENT_ERROR = 9;
+    TOO_MANY_REDIRECTS = 10;
+    MALFORMED_REPLY = 11;
+    CONNECTION_ERROR = 12;
+  }
+}
+
+message URLFetchRequest {
+  enum RequestMethod {
+    GET = 1;
+    POST = 2;
+    HEAD = 3;
+    PUT = 4;
+    DELETE = 5;
+    PATCH = 6;
+  }
+  required RequestMethod Method = 1;
+  required string Url = 2;
+  repeated group Header = 3 {
+    required string Key = 4;
+    required string Value = 5;
+  }
+  optional bytes Payload = 6 [ctype=CORD];
+
+  optional bool FollowRedirects = 7 [default=true];
+
+  optional double Deadline = 8;
+
+  optional bool MustValidateServerCertificate = 9 [default=true];
+}
+
+message URLFetchResponse {
+  optional bytes Content = 1;
+  required int32 StatusCode = 2;
+  repeated group Header = 3 {
+    required string Key = 4;
+    required string Value = 5;
+  }
+  optional bool ContentWasTruncated = 6 [default=false];
+  optional int64 ExternalBytesSent = 7;
+  optional int64 ExternalBytesReceived = 8;
+
+  optional string FinalUrl = 9;
+
+  optional int64 ApiCpuMilliseconds = 10 [default=0];
+  optional int64 ApiBytesSent = 11 [default=0];
+  optional int64 ApiBytesReceived = 12 [default=0];
+}
diff --git a/vendor/google.golang.org/appengine/namespace.go b/vendor/google.golang.org/appengine/namespace.go
new file mode 100644
index 0000000..21860ca
--- /dev/null
+++ b/vendor/google.golang.org/appengine/namespace.go
@@ -0,0 +1,25 @@
+// Copyright 2012 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package appengine
+
+import (
+        "fmt"
+        "regexp"
+
+        "golang.org/x/net/context"
+
+        "google.golang.org/appengine/internal"
+)
+
+// Namespace returns a replacement context that operates within the given namespace.
+func Namespace(c context.Context, namespace string) (context.Context, error) {
+        if !validNamespace.MatchString(namespace) {
+                return nil, fmt.Errorf("appengine: namespace %q does not match /%s/", namespace, validNamespace)
+        }
+        return internal.NamespacedContext(c, namespace), nil
+}
+
+// validNamespace matches valid namespace names.
+var validNamespace = regexp.MustCompile(`^[0-9A-Za-z._-]{0,100}$`)
diff --git a/vendor/google.golang.org/appengine/timeout.go b/vendor/google.golang.org/appengine/timeout.go
new file mode 100644
index 0000000..05642a9
--- /dev/null
+++ b/vendor/google.golang.org/appengine/timeout.go
@@ -0,0 +1,20 @@
+// Copyright 2013 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package appengine
+
+import "golang.org/x/net/context"
+
+// IsTimeoutError reports whether err is a timeout error.
+func IsTimeoutError(err error) bool {
+        if err == context.DeadlineExceeded {
+                return true
+        }
+        if t, ok := err.(interface {
+                IsTimeout() bool
+        }); ok {
+                return t.IsTimeout()
+        }
+        return false
+}
diff --git a/vendor/google.golang.org/appengine/travis_install.sh b/vendor/google.golang.org/appengine/travis_install.sh
new file mode 100644
index 0000000..785b62f
--- /dev/null
+++ b/vendor/google.golang.org/appengine/travis_install.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+set -e
+
+if [[ $GO111MODULE == "on" ]]; then
+  go get .
+else
+  go get -u -v $(go list -f '{{join .Imports "\n"}}{{"\n"}}{{join .TestImports "\n"}}' ./... | sort | uniq | grep -v appengine)
+fi
+
+if [[ $GOAPP == "true" ]]; then
+  mkdir /tmp/sdk
+  curl -o /tmp/sdk.zip "https://storage.googleapis.com/appengine-sdks/featured/go_appengine_sdk_linux_amd64-1.9.68.zip"
+  unzip -q /tmp/sdk.zip -d /tmp/sdk
+  # NOTE: Set the following env vars in the test script:
+  # export PATH="$PATH:/tmp/sdk/go_appengine"
+  # export APPENGINE_DEV_APPSERVER=/tmp/sdk/go_appengine/dev_appserver.py
+fi
+
diff --git a/vendor/google.golang.org/appengine/travis_test.sh b/vendor/google.golang.org/appengine/travis_test.sh
new file mode 100644
index 0000000..d4390f0
--- /dev/null
+++ b/vendor/google.golang.org/appengine/travis_test.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+set -e
+
+go version
+go test -v google.golang.org/appengine/...
+go test -v -race google.golang.org/appengine/...
+if [[ $GOAPP == "true" ]]; then
+  export PATH="$PATH:/tmp/sdk/go_appengine"
+  export APPENGINE_DEV_APPSERVER=/tmp/sdk/go_appengine/dev_appserver.py
+  goapp version
+  goapp test -v google.golang.org/appengine/...
+fi
diff --git a/vendor/google.golang.org/appengine/urlfetch/urlfetch.go b/vendor/google.golang.org/appengine/urlfetch/urlfetch.go
new file mode 100644
index 0000000..6ffe1e6
--- /dev/null
+++ b/vendor/google.golang.org/appengine/urlfetch/urlfetch.go
@@ -0,0 +1,210 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// Package urlfetch provides an http.RoundTripper implementation
+// for fetching URLs via App Engine's urlfetch service.
+package urlfetch // import "google.golang.org/appengine/urlfetch"
+
+import (
+        "errors"
+        "fmt"
+        "io"
+        "io/ioutil"
+        "net/http"
+        "net/url"
+        "strconv"
+        "strings"
+        "time"
+
+        "github.com/golang/protobuf/proto"
+        "golang.org/x/net/context"
+
+        "google.golang.org/appengine/internal"
+        pb "google.golang.org/appengine/internal/urlfetch"
+)
+
+// Transport is an implementation of http.RoundTripper for
+// App Engine. Users should generally create an http.Client using
+// this transport and use the Client rather than using this transport
+// directly.
+type Transport struct {
+        Context context.Context
+
+        // Controls whether the application checks the validity of SSL certificates
+        // over HTTPS connections. A value of false (the default) instructs the
+        // application to send a request to the server only if the certificate is
+        // valid and signed by a trusted certificate authority (CA), and also
+        // includes a hostname that matches the certificate. A value of true
+        // instructs the application to perform no certificate validation.
+        AllowInvalidServerCertificate bool
+}
+
+// Verify statically that *Transport implements http.RoundTripper.
+var _ http.RoundTripper = (*Transport)(nil)
+
+// Client returns an *http.Client using a default urlfetch Transport. This
+// client will have the default deadline of 5 seconds, and will check the
+// validity of SSL certificates.
+//
+// Any deadline of the provided context will be used for requests through this client;
+// if the client does not have a deadline then a 5 second default is used.
+func Client(ctx context.Context) *http.Client {
+        return &http.Client{
+                Transport: &Transport{
+                        Context: ctx,
+                },
+        }
+}
+
+type bodyReader struct {
+        content   []byte
+        truncated bool
+        closed    bool
+}
+
+// ErrTruncatedBody is the error returned after the final Read() from a
+// response's Body if the body has been truncated by App Engine's proxy.
+var ErrTruncatedBody = errors.New("urlfetch: truncated body")
+
+func statusCodeToText(code int) string {
+        if t := http.StatusText(code); t != "" {
+                return t
+        }
+        return strconv.Itoa(code)
+}
+
+func (br *bodyReader) Read(p []byte) (n int, err error) {
+        if br.closed {
+                if br.truncated {
+                        return 0, ErrTruncatedBody
+                }
+                return 0, io.EOF
+        }
+        n = copy(p, br.content)
+        if n > 0 {
+                br.content = br.content[n:]
+                return
+        }
+        if br.truncated {
+                br.closed = true
+                return 0, ErrTruncatedBody
+        }
+        return 0, io.EOF
+}
+
+func (br *bodyReader) Close() error {
+        br.closed = true
+        br.content = nil
+        return nil
+}
+
+// A map of the URL Fetch-accepted methods that take a request body.
+var methodAcceptsRequestBody = map[string]bool{
+        "POST":  true,
+        "PUT":   true,
+        "PATCH": true,
+}
+
+// urlString returns a valid string given a URL. This function is necessary because
+// the String method of URL doesn't correctly handle URLs with non-empty Opaque values.
+// See http://code.google.com/p/go/issues/detail?id=4860.
+func urlString(u *url.URL) string {
+        if u.Opaque == "" || strings.HasPrefix(u.Opaque, "//") {
+                return u.String()
+        }
+        aux := *u
+        aux.Opaque = "//" + aux.Host + aux.Opaque
+        return aux.String()
+}
+
+// RoundTrip issues a single HTTP request and returns its response. Per the
+// http.RoundTripper interface, RoundTrip only returns an error if there
+// was an unsupported request or the URL Fetch proxy fails.
+// Note that HTTP response codes such as 5xx, 403, 404, etc are not
+// errors as far as the transport is concerned and will be returned
+// with err set to nil.
+func (t *Transport) RoundTrip(req *http.Request) (res *http.Response, err error) {
+        methNum, ok := pb.URLFetchRequest_RequestMethod_value[req.Method]
+        if !ok {
+                return nil, fmt.Errorf("urlfetch: unsupported HTTP method %q", req.Method)
+        }
+
+        method := pb.URLFetchRequest_RequestMethod(methNum)
+
+        freq := &pb.URLFetchRequest{
+                Method:                        &method,
+                Url:                           proto.String(urlString(req.URL)),
+                FollowRedirects:               proto.Bool(false), // http.Client's responsibility
+                MustValidateServerCertificate: proto.Bool(!t.AllowInvalidServerCertificate),
+        }
+        if deadline, ok := t.Context.Deadline(); ok {
+                freq.Deadline = proto.Float64(deadline.Sub(time.Now()).Seconds())
+        }
+
+        for k, vals := range req.Header {
+                for _, val := range vals {
+                        freq.Header = append(freq.Header, &pb.URLFetchRequest_Header{
+                                Key:   proto.String(k),
+                                Value: proto.String(val),
+                        })
+                }
+        }
+        if methodAcceptsRequestBody[req.Method] && req.Body != nil {
+                // Avoid a []byte copy if req.Body has a Bytes method.
+                switch b := req.Body.(type) {
+                case interface {
+                        Bytes() []byte
+                }:
+                        freq.Payload = b.Bytes()
+                default:
+                        freq.Payload, err = ioutil.ReadAll(req.Body)
+                        if err != nil {
+                                return nil, err
+                        }
+                }
+        }
+
+        fres := &pb.URLFetchResponse{}
+        if err := internal.Call(t.Context, "urlfetch", "Fetch", freq, fres); err != nil {
+                return nil, err
+        }
+
+        res = &http.Response{}
+        res.StatusCode = int(*fres.StatusCode)
+        res.Status = fmt.Sprintf("%d %s", res.StatusCode, statusCodeToText(res.StatusCode))
+        res.Header = make(http.Header)
+        res.Request = req
+
+        // Faked:
+        res.ProtoMajor = 1
+        res.ProtoMinor = 1
+        res.Proto = "HTTP/1.1"
+        res.Close = true
+
+        for _, h := range fres.Header {
+                hkey := http.CanonicalHeaderKey(*h.Key)
+                hval := *h.Value
+                if hkey == "Content-Length" {
+                        // Will get filled in below for all but HEAD requests.
+                        if req.Method == "HEAD" {
+                                res.ContentLength, _ = strconv.ParseInt(hval, 10, 64)
+                        }
+                        continue
+                }
+                res.Header.Add(hkey, hval)
+        }
+
+        if req.Method != "HEAD" {
+                res.ContentLength = int64(len(fres.Content))
+        }
+
+        truncated := fres.GetContentWasTruncated()
+        res.Body = &bodyReader{content: fres.Content, truncated: truncated}
+        return
+}
+
+func init() {
+        internal.RegisterErrorCodeMap("urlfetch", pb.URLFetchServiceError_ErrorCode_name)
+        internal.RegisterTimeoutErrorCode("urlfetch", int32(pb.URLFetchServiceError_DEADLINE_EXCEEDED))
+}