// Code generated by protoc-gen-go. DO NOT EDIT.
// source: test.proto

package tests

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
import v1beta1 "google.golang.org/genproto/googleapis/firestore/v1beta1"

// 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 DocChange_Kind int32

const (
	DocChange_KIND_UNSPECIFIED DocChange_Kind = 0
	DocChange_ADDED            DocChange_Kind = 1
	DocChange_REMOVED          DocChange_Kind = 2
	DocChange_MODIFIED         DocChange_Kind = 3
)

var DocChange_Kind_name = map[int32]string{
	0: "KIND_UNSPECIFIED",
	1: "ADDED",
	2: "REMOVED",
	3: "MODIFIED",
}
var DocChange_Kind_value = map[string]int32{
	"KIND_UNSPECIFIED": 0,
	"ADDED":            1,
	"REMOVED":          2,
	"MODIFIED":         3,
}

func (x DocChange_Kind) String() string {
	return proto.EnumName(DocChange_Kind_name, int32(x))
}
func (DocChange_Kind) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_test_338de568ad9314f7, []int{19, 0}
}

// A collection of tests.
type TestSuite struct {
	Tests                []*Test  `protobuf:"bytes,1,rep,name=tests,proto3" json:"tests,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TestSuite) Reset()         { *m = TestSuite{} }
func (m *TestSuite) String() string { return proto.CompactTextString(m) }
func (*TestSuite) ProtoMessage()    {}
func (*TestSuite) Descriptor() ([]byte, []int) {
	return fileDescriptor_test_338de568ad9314f7, []int{0}
}
func (m *TestSuite) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TestSuite.Unmarshal(m, b)
}
func (m *TestSuite) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TestSuite.Marshal(b, m, deterministic)
}
func (dst *TestSuite) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TestSuite.Merge(dst, src)
}
func (m *TestSuite) XXX_Size() int {
	return xxx_messageInfo_TestSuite.Size(m)
}
func (m *TestSuite) XXX_DiscardUnknown() {
	xxx_messageInfo_TestSuite.DiscardUnknown(m)
}

var xxx_messageInfo_TestSuite proto.InternalMessageInfo

func (m *TestSuite) GetTests() []*Test {
	if m != nil {
		return m.Tests
	}
	return nil
}

// A Test describes a single client method call and its expected result.
type Test struct {
	Description string `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"`
	// Types that are valid to be assigned to Test:
	//	*Test_Get
	//	*Test_Create
	//	*Test_Set
	//	*Test_Update
	//	*Test_UpdatePaths
	//	*Test_Delete
	//	*Test_Query
	//	*Test_Listen
	Test                 isTest_Test `protobuf_oneof:"test"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *Test) Reset()         { *m = Test{} }
func (m *Test) String() string { return proto.CompactTextString(m) }
func (*Test) ProtoMessage()    {}
func (*Test) Descriptor() ([]byte, []int) {
	return fileDescriptor_test_338de568ad9314f7, []int{1}
}
func (m *Test) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Test.Unmarshal(m, b)
}
func (m *Test) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Test.Marshal(b, m, deterministic)
}
func (dst *Test) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Test.Merge(dst, src)
}
func (m *Test) XXX_Size() int {
	return xxx_messageInfo_Test.Size(m)
}
func (m *Test) XXX_DiscardUnknown() {
	xxx_messageInfo_Test.DiscardUnknown(m)
}

var xxx_messageInfo_Test proto.InternalMessageInfo

type isTest_Test interface {
	isTest_Test()
}

type Test_Get struct {
	Get *GetTest `protobuf:"bytes,2,opt,name=get,proto3,oneof"`
}
type Test_Create struct {
	Create *CreateTest `protobuf:"bytes,3,opt,name=create,proto3,oneof"`
}
type Test_Set struct {
	Set *SetTest `protobuf:"bytes,4,opt,name=set,proto3,oneof"`
}
type Test_Update struct {
	Update *UpdateTest `protobuf:"bytes,5,opt,name=update,proto3,oneof"`
}
type Test_UpdatePaths struct {
	UpdatePaths *UpdatePathsTest `protobuf:"bytes,6,opt,name=update_paths,json=updatePaths,proto3,oneof"`
}
type Test_Delete struct {
	Delete *DeleteTest `protobuf:"bytes,7,opt,name=delete,proto3,oneof"`
}
type Test_Query struct {
	Query *QueryTest `protobuf:"bytes,8,opt,name=query,proto3,oneof"`
}
type Test_Listen struct {
	Listen *ListenTest `protobuf:"bytes,9,opt,name=listen,proto3,oneof"`
}

func (*Test_Get) isTest_Test()         {}
func (*Test_Create) isTest_Test()      {}
func (*Test_Set) isTest_Test()         {}
func (*Test_Update) isTest_Test()      {}
func (*Test_UpdatePaths) isTest_Test() {}
func (*Test_Delete) isTest_Test()      {}
func (*Test_Query) isTest_Test()       {}
func (*Test_Listen) isTest_Test()      {}

func (m *Test) GetTest() isTest_Test {
	if m != nil {
		return m.Test
	}
	return nil
}

func (m *Test) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *Test) GetGet() *GetTest {
	if x, ok := m.GetTest().(*Test_Get); ok {
		return x.Get
	}
	return nil
}

func (m *Test) GetCreate() *CreateTest {
	if x, ok := m.GetTest().(*Test_Create); ok {
		return x.Create
	}
	return nil
}

func (m *Test) GetSet() *SetTest {
	if x, ok := m.GetTest().(*Test_Set); ok {
		return x.Set
	}
	return nil
}

func (m *Test) GetUpdate() *UpdateTest {
	if x, ok := m.GetTest().(*Test_Update); ok {
		return x.Update
	}
	return nil
}

func (m *Test) GetUpdatePaths() *UpdatePathsTest {
	if x, ok := m.GetTest().(*Test_UpdatePaths); ok {
		return x.UpdatePaths
	}
	return nil
}

func (m *Test) GetDelete() *DeleteTest {
	if x, ok := m.GetTest().(*Test_Delete); ok {
		return x.Delete
	}
	return nil
}

func (m *Test) GetQuery() *QueryTest {
	if x, ok := m.GetTest().(*Test_Query); ok {
		return x.Query
	}
	return nil
}

func (m *Test) GetListen() *ListenTest {
	if x, ok := m.GetTest().(*Test_Listen); ok {
		return x.Listen
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Test) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Test_OneofMarshaler, _Test_OneofUnmarshaler, _Test_OneofSizer, []interface{}{
		(*Test_Get)(nil),
		(*Test_Create)(nil),
		(*Test_Set)(nil),
		(*Test_Update)(nil),
		(*Test_UpdatePaths)(nil),
		(*Test_Delete)(nil),
		(*Test_Query)(nil),
		(*Test_Listen)(nil),
	}
}

func _Test_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Test)
	// test
	switch x := m.Test.(type) {
	case *Test_Get:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Get); err != nil {
			return err
		}
	case *Test_Create:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Create); err != nil {
			return err
		}
	case *Test_Set:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Set); err != nil {
			return err
		}
	case *Test_Update:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Update); err != nil {
			return err
		}
	case *Test_UpdatePaths:
		b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.UpdatePaths); err != nil {
			return err
		}
	case *Test_Delete:
		b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Delete); err != nil {
			return err
		}
	case *Test_Query:
		b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Query); err != nil {
			return err
		}
	case *Test_Listen:
		b.EncodeVarint(9<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Listen); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Test.Test has unexpected type %T", x)
	}
	return nil
}

func _Test_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Test)
	switch tag {
	case 2: // test.get
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(GetTest)
		err := b.DecodeMessage(msg)
		m.Test = &Test_Get{msg}
		return true, err
	case 3: // test.create
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(CreateTest)
		err := b.DecodeMessage(msg)
		m.Test = &Test_Create{msg}
		return true, err
	case 4: // test.set
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(SetTest)
		err := b.DecodeMessage(msg)
		m.Test = &Test_Set{msg}
		return true, err
	case 5: // test.update
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(UpdateTest)
		err := b.DecodeMessage(msg)
		m.Test = &Test_Update{msg}
		return true, err
	case 6: // test.update_paths
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(UpdatePathsTest)
		err := b.DecodeMessage(msg)
		m.Test = &Test_UpdatePaths{msg}
		return true, err
	case 7: // test.delete
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DeleteTest)
		err := b.DecodeMessage(msg)
		m.Test = &Test_Delete{msg}
		return true, err
	case 8: // test.query
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(QueryTest)
		err := b.DecodeMessage(msg)
		m.Test = &Test_Query{msg}
		return true, err
	case 9: // test.listen
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ListenTest)
		err := b.DecodeMessage(msg)
		m.Test = &Test_Listen{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Test_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Test)
	// test
	switch x := m.Test.(type) {
	case *Test_Get:
		s := proto.Size(x.Get)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Test_Create:
		s := proto.Size(x.Create)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Test_Set:
		s := proto.Size(x.Set)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Test_Update:
		s := proto.Size(x.Update)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Test_UpdatePaths:
		s := proto.Size(x.UpdatePaths)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Test_Delete:
		s := proto.Size(x.Delete)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Test_Query:
		s := proto.Size(x.Query)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Test_Listen:
		s := proto.Size(x.Listen)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// Call to the DocumentRef.Get method.
type GetTest struct {
	// The path of the doc, e.g. "projects/projectID/databases/(default)/documents/C/d"
	DocRefPath string `protobuf:"bytes,1,opt,name=doc_ref_path,json=docRefPath,proto3" json:"doc_ref_path,omitempty"`
	// The request that the call should send to the Firestore service.
	Request              *v1beta1.GetDocumentRequest `protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

func (m *GetTest) Reset()         { *m = GetTest{} }
func (m *GetTest) String() string { return proto.CompactTextString(m) }
func (*GetTest) ProtoMessage()    {}
func (*GetTest) Descriptor() ([]byte, []int) {
	return fileDescriptor_test_338de568ad9314f7, []int{2}
}
func (m *GetTest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetTest.Unmarshal(m, b)
}
func (m *GetTest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetTest.Marshal(b, m, deterministic)
}
func (dst *GetTest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetTest.Merge(dst, src)
}
func (m *GetTest) XXX_Size() int {
	return xxx_messageInfo_GetTest.Size(m)
}
func (m *GetTest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetTest.DiscardUnknown(m)
}

var xxx_messageInfo_GetTest proto.InternalMessageInfo

func (m *GetTest) GetDocRefPath() string {
	if m != nil {
		return m.DocRefPath
	}
	return ""
}

func (m *GetTest) GetRequest() *v1beta1.GetDocumentRequest {
	if m != nil {
		return m.Request
	}
	return nil
}

// Call to DocumentRef.Create.
type CreateTest struct {
	// The path of the doc, e.g. "projects/projectID/databases/(default)/documents/C/d"
	DocRefPath string `protobuf:"bytes,1,opt,name=doc_ref_path,json=docRefPath,proto3" json:"doc_ref_path,omitempty"`
	// The data passed to Create, as JSON. The strings "Delete" and "ServerTimestamp"
	// denote the two special sentinel values. Values that could be interpreted as integers
	// (i.e. digit strings) should be treated as integers.
	JsonData string `protobuf:"bytes,2,opt,name=json_data,json=jsonData,proto3" json:"json_data,omitempty"`
	// The request that the call should generate.
	Request *v1beta1.CommitRequest `protobuf:"bytes,3,opt,name=request,proto3" json:"request,omitempty"`
	// If true, the call should result in an error without generating a request.
	// If this is true, request should not be set.
	IsError              bool     `protobuf:"varint,4,opt,name=is_error,json=isError,proto3" json:"is_error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateTest) Reset()         { *m = CreateTest{} }
func (m *CreateTest) String() string { return proto.CompactTextString(m) }
func (*CreateTest) ProtoMessage()    {}
func (*CreateTest) Descriptor() ([]byte, []int) {
	return fileDescriptor_test_338de568ad9314f7, []int{3}
}
func (m *CreateTest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CreateTest.Unmarshal(m, b)
}
func (m *CreateTest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CreateTest.Marshal(b, m, deterministic)
}
func (dst *CreateTest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateTest.Merge(dst, src)
}
func (m *CreateTest) XXX_Size() int {
	return xxx_messageInfo_CreateTest.Size(m)
}
func (m *CreateTest) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateTest.DiscardUnknown(m)
}

var xxx_messageInfo_CreateTest proto.InternalMessageInfo

func (m *CreateTest) GetDocRefPath() string {
	if m != nil {
		return m.DocRefPath
	}
	return ""
}

func (m *CreateTest) GetJsonData() string {
	if m != nil {
		return m.JsonData
	}
	return ""
}

func (m *CreateTest) GetRequest() *v1beta1.CommitRequest {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *CreateTest) GetIsError() bool {
	if m != nil {
		return m.IsError
	}
	return false
}

// A call to DocumentRef.Set.
type SetTest struct {
	DocRefPath           string                 `protobuf:"bytes,1,opt,name=doc_ref_path,json=docRefPath,proto3" json:"doc_ref_path,omitempty"`
	Option               *SetOption             `protobuf:"bytes,2,opt,name=option,proto3" json:"option,omitempty"`
	JsonData             string                 `protobuf:"bytes,3,opt,name=json_data,json=jsonData,proto3" json:"json_data,omitempty"`
	Request              *v1beta1.CommitRequest `protobuf:"bytes,4,opt,name=request,proto3" json:"request,omitempty"`
	IsError              bool                   `protobuf:"varint,5,opt,name=is_error,json=isError,proto3" json:"is_error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *SetTest) Reset()         { *m = SetTest{} }
func (m *SetTest) String() string { return proto.CompactTextString(m) }
func (*SetTest) ProtoMessage()    {}
func (*SetTest) Descriptor() ([]byte, []int) {
	return fileDescriptor_test_338de568ad9314f7, []int{4}
}
func (m *SetTest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SetTest.Unmarshal(m, b)
}
func (m *SetTest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SetTest.Marshal(b, m, deterministic)
}
func (dst *SetTest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetTest.Merge(dst, src)
}
func (m *SetTest) XXX_Size() int {
	return xxx_messageInfo_SetTest.Size(m)
}
func (m *SetTest) XXX_DiscardUnknown() {
	xxx_messageInfo_SetTest.DiscardUnknown(m)
}

var xxx_messageInfo_SetTest proto.InternalMessageInfo

func (m *SetTest) GetDocRefPath() string {
	if m != nil {
		return m.DocRefPath
	}
	return ""
}

func (m *SetTest) GetOption() *SetOption {
	if m != nil {
		return m.Option
	}
	return nil
}

func (m *SetTest) GetJsonData() string {
	if m != nil {
		return m.JsonData
	}
	return ""
}

func (m *SetTest) GetRequest() *v1beta1.CommitRequest {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *SetTest) GetIsError() bool {
	if m != nil {
		return m.IsError
	}
	return false
}

// A call to the form of DocumentRef.Update that represents the data as a map
// or dictionary.
type UpdateTest struct {
	DocRefPath           string                 `protobuf:"bytes,1,opt,name=doc_ref_path,json=docRefPath,proto3" json:"doc_ref_path,omitempty"`
	Precondition         *v1beta1.Precondition  `protobuf:"bytes,2,opt,name=precondition,proto3" json:"precondition,omitempty"`
	JsonData             string                 `protobuf:"bytes,3,opt,name=json_data,json=jsonData,proto3" json:"json_data,omitempty"`
	Request              *v1beta1.CommitRequest `protobuf:"bytes,4,opt,name=request,proto3" json:"request,omitempty"`
	IsError              bool                   `protobuf:"varint,5,opt,name=is_error,json=isError,proto3" json:"is_error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *UpdateTest) Reset()         { *m = UpdateTest{} }
func (m *UpdateTest) String() string { return proto.CompactTextString(m) }
func (*UpdateTest) ProtoMessage()    {}
func (*UpdateTest) Descriptor() ([]byte, []int) {
	return fileDescriptor_test_338de568ad9314f7, []int{5}
}
func (m *UpdateTest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UpdateTest.Unmarshal(m, b)
}
func (m *UpdateTest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UpdateTest.Marshal(b, m, deterministic)
}
func (dst *UpdateTest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateTest.Merge(dst, src)
}
func (m *UpdateTest) XXX_Size() int {
	return xxx_messageInfo_UpdateTest.Size(m)
}
func (m *UpdateTest) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateTest.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateTest proto.InternalMessageInfo

func (m *UpdateTest) GetDocRefPath() string {
	if m != nil {
		return m.DocRefPath
	}
	return ""
}

func (m *UpdateTest) GetPrecondition() *v1beta1.Precondition {
	if m != nil {
		return m.Precondition
	}
	return nil
}

func (m *UpdateTest) GetJsonData() string {
	if m != nil {
		return m.JsonData
	}
	return ""
}

func (m *UpdateTest) GetRequest() *v1beta1.CommitRequest {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *UpdateTest) GetIsError() bool {
	if m != nil {
		return m.IsError
	}
	return false
}

// A call to the form of DocumentRef.Update that represents the data as a list
// of field paths and their values.
type UpdatePathsTest struct {
	DocRefPath   string                `protobuf:"bytes,1,opt,name=doc_ref_path,json=docRefPath,proto3" json:"doc_ref_path,omitempty"`
	Precondition *v1beta1.Precondition `protobuf:"bytes,2,opt,name=precondition,proto3" json:"precondition,omitempty"`
	// parallel sequences: field_paths[i] corresponds to json_values[i]
	FieldPaths           []*FieldPath           `protobuf:"bytes,3,rep,name=field_paths,json=fieldPaths,proto3" json:"field_paths,omitempty"`
	JsonValues           []string               `protobuf:"bytes,4,rep,name=json_values,json=jsonValues,proto3" json:"json_values,omitempty"`
	Request              *v1beta1.CommitRequest `protobuf:"bytes,5,opt,name=request,proto3" json:"request,omitempty"`
	IsError              bool                   `protobuf:"varint,6,opt,name=is_error,json=isError,proto3" json:"is_error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *UpdatePathsTest) Reset()         { *m = UpdatePathsTest{} }
func (m *UpdatePathsTest) String() string { return proto.CompactTextString(m) }
func (*UpdatePathsTest) ProtoMessage()    {}
func (*UpdatePathsTest) Descriptor() ([]byte, []int) {
	return fileDescriptor_test_338de568ad9314f7, []int{6}
}
func (m *UpdatePathsTest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UpdatePathsTest.Unmarshal(m, b)
}
func (m *UpdatePathsTest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UpdatePathsTest.Marshal(b, m, deterministic)
}
func (dst *UpdatePathsTest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdatePathsTest.Merge(dst, src)
}
func (m *UpdatePathsTest) XXX_Size() int {
	return xxx_messageInfo_UpdatePathsTest.Size(m)
}
func (m *UpdatePathsTest) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdatePathsTest.DiscardUnknown(m)
}

var xxx_messageInfo_UpdatePathsTest proto.InternalMessageInfo

func (m *UpdatePathsTest) GetDocRefPath() string {
	if m != nil {
		return m.DocRefPath
	}
	return ""
}

func (m *UpdatePathsTest) GetPrecondition() *v1beta1.Precondition {
	if m != nil {
		return m.Precondition
	}
	return nil
}

func (m *UpdatePathsTest) GetFieldPaths() []*FieldPath {
	if m != nil {
		return m.FieldPaths
	}
	return nil
}

func (m *UpdatePathsTest) GetJsonValues() []string {
	if m != nil {
		return m.JsonValues
	}
	return nil
}

func (m *UpdatePathsTest) GetRequest() *v1beta1.CommitRequest {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *UpdatePathsTest) GetIsError() bool {
	if m != nil {
		return m.IsError
	}
	return false
}

// A call to DocmentRef.Delete
type DeleteTest struct {
	DocRefPath           string                 `protobuf:"bytes,1,opt,name=doc_ref_path,json=docRefPath,proto3" json:"doc_ref_path,omitempty"`
	Precondition         *v1beta1.Precondition  `protobuf:"bytes,2,opt,name=precondition,proto3" json:"precondition,omitempty"`
	Request              *v1beta1.CommitRequest `protobuf:"bytes,3,opt,name=request,proto3" json:"request,omitempty"`
	IsError              bool                   `protobuf:"varint,4,opt,name=is_error,json=isError,proto3" json:"is_error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *DeleteTest) Reset()         { *m = DeleteTest{} }
func (m *DeleteTest) String() string { return proto.CompactTextString(m) }
func (*DeleteTest) ProtoMessage()    {}
func (*DeleteTest) Descriptor() ([]byte, []int) {
	return fileDescriptor_test_338de568ad9314f7, []int{7}
}
func (m *DeleteTest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DeleteTest.Unmarshal(m, b)
}
func (m *DeleteTest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DeleteTest.Marshal(b, m, deterministic)
}
func (dst *DeleteTest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteTest.Merge(dst, src)
}
func (m *DeleteTest) XXX_Size() int {
	return xxx_messageInfo_DeleteTest.Size(m)
}
func (m *DeleteTest) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteTest.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteTest proto.InternalMessageInfo

func (m *DeleteTest) GetDocRefPath() string {
	if m != nil {
		return m.DocRefPath
	}
	return ""
}

func (m *DeleteTest) GetPrecondition() *v1beta1.Precondition {
	if m != nil {
		return m.Precondition
	}
	return nil
}

func (m *DeleteTest) GetRequest() *v1beta1.CommitRequest {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *DeleteTest) GetIsError() bool {
	if m != nil {
		return m.IsError
	}
	return false
}

// An option to the DocumentRef.Set call.
type SetOption struct {
	All                  bool         `protobuf:"varint,1,opt,name=all,proto3" json:"all,omitempty"`
	Fields               []*FieldPath `protobuf:"bytes,2,rep,name=fields,proto3" json:"fields,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *SetOption) Reset()         { *m = SetOption{} }
func (m *SetOption) String() string { return proto.CompactTextString(m) }
func (*SetOption) ProtoMessage()    {}
func (*SetOption) Descriptor() ([]byte, []int) {
	return fileDescriptor_test_338de568ad9314f7, []int{8}
}
func (m *SetOption) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SetOption.Unmarshal(m, b)
}
func (m *SetOption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SetOption.Marshal(b, m, deterministic)
}
func (dst *SetOption) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetOption.Merge(dst, src)
}
func (m *SetOption) XXX_Size() int {
	return xxx_messageInfo_SetOption.Size(m)
}
func (m *SetOption) XXX_DiscardUnknown() {
	xxx_messageInfo_SetOption.DiscardUnknown(m)
}

var xxx_messageInfo_SetOption proto.InternalMessageInfo

func (m *SetOption) GetAll() bool {
	if m != nil {
		return m.All
	}
	return false
}

func (m *SetOption) GetFields() []*FieldPath {
	if m != nil {
		return m.Fields
	}
	return nil
}

type QueryTest struct {
	CollPath             string                   `protobuf:"bytes,1,opt,name=coll_path,json=collPath,proto3" json:"coll_path,omitempty"`
	Clauses              []*Clause                `protobuf:"bytes,2,rep,name=clauses,proto3" json:"clauses,omitempty"`
	Query                *v1beta1.StructuredQuery `protobuf:"bytes,3,opt,name=query,proto3" json:"query,omitempty"`
	IsError              bool                     `protobuf:"varint,4,opt,name=is_error,json=isError,proto3" json:"is_error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

func (m *QueryTest) Reset()         { *m = QueryTest{} }
func (m *QueryTest) String() string { return proto.CompactTextString(m) }
func (*QueryTest) ProtoMessage()    {}
func (*QueryTest) Descriptor() ([]byte, []int) {
	return fileDescriptor_test_338de568ad9314f7, []int{9}
}
func (m *QueryTest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_QueryTest.Unmarshal(m, b)
}
func (m *QueryTest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_QueryTest.Marshal(b, m, deterministic)
}
func (dst *QueryTest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryTest.Merge(dst, src)
}
func (m *QueryTest) XXX_Size() int {
	return xxx_messageInfo_QueryTest.Size(m)
}
func (m *QueryTest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryTest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryTest proto.InternalMessageInfo

func (m *QueryTest) GetCollPath() string {
	if m != nil {
		return m.CollPath
	}
	return ""
}

func (m *QueryTest) GetClauses() []*Clause {
	if m != nil {
		return m.Clauses
	}
	return nil
}

func (m *QueryTest) GetQuery() *v1beta1.StructuredQuery {
	if m != nil {
		return m.Query
	}
	return nil
}

func (m *QueryTest) GetIsError() bool {
	if m != nil {
		return m.IsError
	}
	return false
}

type Clause struct {
	// Types that are valid to be assigned to Clause:
	//	*Clause_Select
	//	*Clause_Where
	//	*Clause_OrderBy
	//	*Clause_Offset
	//	*Clause_Limit
	//	*Clause_StartAt
	//	*Clause_StartAfter
	//	*Clause_EndAt
	//	*Clause_EndBefore
	Clause               isClause_Clause `protobuf_oneof:"clause"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *Clause) Reset()         { *m = Clause{} }
func (m *Clause) String() string { return proto.CompactTextString(m) }
func (*Clause) ProtoMessage()    {}
func (*Clause) Descriptor() ([]byte, []int) {
	return fileDescriptor_test_338de568ad9314f7, []int{10}
}
func (m *Clause) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Clause.Unmarshal(m, b)
}
func (m *Clause) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Clause.Marshal(b, m, deterministic)
}
func (dst *Clause) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Clause.Merge(dst, src)
}
func (m *Clause) XXX_Size() int {
	return xxx_messageInfo_Clause.Size(m)
}
func (m *Clause) XXX_DiscardUnknown() {
	xxx_messageInfo_Clause.DiscardUnknown(m)
}

var xxx_messageInfo_Clause proto.InternalMessageInfo

type isClause_Clause interface {
	isClause_Clause()
}

type Clause_Select struct {
	Select *Select `protobuf:"bytes,1,opt,name=select,proto3,oneof"`
}
type Clause_Where struct {
	Where *Where `protobuf:"bytes,2,opt,name=where,proto3,oneof"`
}
type Clause_OrderBy struct {
	OrderBy *OrderBy `protobuf:"bytes,3,opt,name=order_by,json=orderBy,proto3,oneof"`
}
type Clause_Offset struct {
	Offset int32 `protobuf:"varint,4,opt,name=offset,proto3,oneof"`
}
type Clause_Limit struct {
	Limit int32 `protobuf:"varint,5,opt,name=limit,proto3,oneof"`
}
type Clause_StartAt struct {
	StartAt *Cursor `protobuf:"bytes,6,opt,name=start_at,json=startAt,proto3,oneof"`
}
type Clause_StartAfter struct {
	StartAfter *Cursor `protobuf:"bytes,7,opt,name=start_after,json=startAfter,proto3,oneof"`
}
type Clause_EndAt struct {
	EndAt *Cursor `protobuf:"bytes,8,opt,name=end_at,json=endAt,proto3,oneof"`
}
type Clause_EndBefore struct {
	EndBefore *Cursor `protobuf:"bytes,9,opt,name=end_before,json=endBefore,proto3,oneof"`
}

func (*Clause_Select) isClause_Clause()     {}
func (*Clause_Where) isClause_Clause()      {}
func (*Clause_OrderBy) isClause_Clause()    {}
func (*Clause_Offset) isClause_Clause()     {}
func (*Clause_Limit) isClause_Clause()      {}
func (*Clause_StartAt) isClause_Clause()    {}
func (*Clause_StartAfter) isClause_Clause() {}
func (*Clause_EndAt) isClause_Clause()      {}
func (*Clause_EndBefore) isClause_Clause()  {}

func (m *Clause) GetClause() isClause_Clause {
	if m != nil {
		return m.Clause
	}
	return nil
}

func (m *Clause) GetSelect() *Select {
	if x, ok := m.GetClause().(*Clause_Select); ok {
		return x.Select
	}
	return nil
}

func (m *Clause) GetWhere() *Where {
	if x, ok := m.GetClause().(*Clause_Where); ok {
		return x.Where
	}
	return nil
}

func (m *Clause) GetOrderBy() *OrderBy {
	if x, ok := m.GetClause().(*Clause_OrderBy); ok {
		return x.OrderBy
	}
	return nil
}

func (m *Clause) GetOffset() int32 {
	if x, ok := m.GetClause().(*Clause_Offset); ok {
		return x.Offset
	}
	return 0
}

func (m *Clause) GetLimit() int32 {
	if x, ok := m.GetClause().(*Clause_Limit); ok {
		return x.Limit
	}
	return 0
}

func (m *Clause) GetStartAt() *Cursor {
	if x, ok := m.GetClause().(*Clause_StartAt); ok {
		return x.StartAt
	}
	return nil
}

func (m *Clause) GetStartAfter() *Cursor {
	if x, ok := m.GetClause().(*Clause_StartAfter); ok {
		return x.StartAfter
	}
	return nil
}

func (m *Clause) GetEndAt() *Cursor {
	if x, ok := m.GetClause().(*Clause_EndAt); ok {
		return x.EndAt
	}
	return nil
}

func (m *Clause) GetEndBefore() *Cursor {
	if x, ok := m.GetClause().(*Clause_EndBefore); ok {
		return x.EndBefore
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Clause) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Clause_OneofMarshaler, _Clause_OneofUnmarshaler, _Clause_OneofSizer, []interface{}{
		(*Clause_Select)(nil),
		(*Clause_Where)(nil),
		(*Clause_OrderBy)(nil),
		(*Clause_Offset)(nil),
		(*Clause_Limit)(nil),
		(*Clause_StartAt)(nil),
		(*Clause_StartAfter)(nil),
		(*Clause_EndAt)(nil),
		(*Clause_EndBefore)(nil),
	}
}

func _Clause_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Clause)
	// clause
	switch x := m.Clause.(type) {
	case *Clause_Select:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Select); err != nil {
			return err
		}
	case *Clause_Where:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Where); err != nil {
			return err
		}
	case *Clause_OrderBy:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.OrderBy); err != nil {
			return err
		}
	case *Clause_Offset:
		b.EncodeVarint(4<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.Offset))
	case *Clause_Limit:
		b.EncodeVarint(5<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.Limit))
	case *Clause_StartAt:
		b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.StartAt); err != nil {
			return err
		}
	case *Clause_StartAfter:
		b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.StartAfter); err != nil {
			return err
		}
	case *Clause_EndAt:
		b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.EndAt); err != nil {
			return err
		}
	case *Clause_EndBefore:
		b.EncodeVarint(9<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.EndBefore); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Clause.Clause has unexpected type %T", x)
	}
	return nil
}

func _Clause_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Clause)
	switch tag {
	case 1: // clause.select
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Select)
		err := b.DecodeMessage(msg)
		m.Clause = &Clause_Select{msg}
		return true, err
	case 2: // clause.where
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Where)
		err := b.DecodeMessage(msg)
		m.Clause = &Clause_Where{msg}
		return true, err
	case 3: // clause.order_by
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(OrderBy)
		err := b.DecodeMessage(msg)
		m.Clause = &Clause_OrderBy{msg}
		return true, err
	case 4: // clause.offset
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Clause = &Clause_Offset{int32(x)}
		return true, err
	case 5: // clause.limit
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Clause = &Clause_Limit{int32(x)}
		return true, err
	case 6: // clause.start_at
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Cursor)
		err := b.DecodeMessage(msg)
		m.Clause = &Clause_StartAt{msg}
		return true, err
	case 7: // clause.start_after
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Cursor)
		err := b.DecodeMessage(msg)
		m.Clause = &Clause_StartAfter{msg}
		return true, err
	case 8: // clause.end_at
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Cursor)
		err := b.DecodeMessage(msg)
		m.Clause = &Clause_EndAt{msg}
		return true, err
	case 9: // clause.end_before
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Cursor)
		err := b.DecodeMessage(msg)
		m.Clause = &Clause_EndBefore{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Clause_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Clause)
	// clause
	switch x := m.Clause.(type) {
	case *Clause_Select:
		s := proto.Size(x.Select)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Clause_Where:
		s := proto.Size(x.Where)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Clause_OrderBy:
		s := proto.Size(x.OrderBy)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Clause_Offset:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.Offset))
	case *Clause_Limit:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.Limit))
	case *Clause_StartAt:
		s := proto.Size(x.StartAt)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Clause_StartAfter:
		s := proto.Size(x.StartAfter)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Clause_EndAt:
		s := proto.Size(x.EndAt)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Clause_EndBefore:
		s := proto.Size(x.EndBefore)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type Select struct {
	Fields               []*FieldPath `protobuf:"bytes,1,rep,name=fields,proto3" json:"fields,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *Select) Reset()         { *m = Select{} }
func (m *Select) String() string { return proto.CompactTextString(m) }
func (*Select) ProtoMessage()    {}
func (*Select) Descriptor() ([]byte, []int) {
	return fileDescriptor_test_338de568ad9314f7, []int{11}
}
func (m *Select) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Select.Unmarshal(m, b)
}
func (m *Select) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Select.Marshal(b, m, deterministic)
}
func (dst *Select) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Select.Merge(dst, src)
}
func (m *Select) XXX_Size() int {
	return xxx_messageInfo_Select.Size(m)
}
func (m *Select) XXX_DiscardUnknown() {
	xxx_messageInfo_Select.DiscardUnknown(m)
}

var xxx_messageInfo_Select proto.InternalMessageInfo

func (m *Select) GetFields() []*FieldPath {
	if m != nil {
		return m.Fields
	}
	return nil
}

type Where struct {
	Path                 *FieldPath `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	Op                   string     `protobuf:"bytes,2,opt,name=op,proto3" json:"op,omitempty"`
	JsonValue            string     `protobuf:"bytes,3,opt,name=json_value,json=jsonValue,proto3" json:"json_value,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *Where) Reset()         { *m = Where{} }
func (m *Where) String() string { return proto.CompactTextString(m) }
func (*Where) ProtoMessage()    {}
func (*Where) Descriptor() ([]byte, []int) {
	return fileDescriptor_test_338de568ad9314f7, []int{12}
}
func (m *Where) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Where.Unmarshal(m, b)
}
func (m *Where) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Where.Marshal(b, m, deterministic)
}
func (dst *Where) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Where.Merge(dst, src)
}
func (m *Where) XXX_Size() int {
	return xxx_messageInfo_Where.Size(m)
}
func (m *Where) XXX_DiscardUnknown() {
	xxx_messageInfo_Where.DiscardUnknown(m)
}

var xxx_messageInfo_Where proto.InternalMessageInfo

func (m *Where) GetPath() *FieldPath {
	if m != nil {
		return m.Path
	}
	return nil
}

func (m *Where) GetOp() string {
	if m != nil {
		return m.Op
	}
	return ""
}

func (m *Where) GetJsonValue() string {
	if m != nil {
		return m.JsonValue
	}
	return ""
}

type OrderBy struct {
	Path                 *FieldPath `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	Direction            string     `protobuf:"bytes,2,opt,name=direction,proto3" json:"direction,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *OrderBy) Reset()         { *m = OrderBy{} }
func (m *OrderBy) String() string { return proto.CompactTextString(m) }
func (*OrderBy) ProtoMessage()    {}
func (*OrderBy) Descriptor() ([]byte, []int) {
	return fileDescriptor_test_338de568ad9314f7, []int{13}
}
func (m *OrderBy) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_OrderBy.Unmarshal(m, b)
}
func (m *OrderBy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_OrderBy.Marshal(b, m, deterministic)
}
func (dst *OrderBy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OrderBy.Merge(dst, src)
}
func (m *OrderBy) XXX_Size() int {
	return xxx_messageInfo_OrderBy.Size(m)
}
func (m *OrderBy) XXX_DiscardUnknown() {
	xxx_messageInfo_OrderBy.DiscardUnknown(m)
}

var xxx_messageInfo_OrderBy proto.InternalMessageInfo

func (m *OrderBy) GetPath() *FieldPath {
	if m != nil {
		return m.Path
	}
	return nil
}

func (m *OrderBy) GetDirection() string {
	if m != nil {
		return m.Direction
	}
	return ""
}

type Cursor struct {
	// one of:
	DocSnapshot          *DocSnapshot `protobuf:"bytes,1,opt,name=doc_snapshot,json=docSnapshot,proto3" json:"doc_snapshot,omitempty"`
	JsonValues           []string     `protobuf:"bytes,2,rep,name=json_values,json=jsonValues,proto3" json:"json_values,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_test_338de568ad9314f7, []int{14}
}
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) GetDocSnapshot() *DocSnapshot {
	if m != nil {
		return m.DocSnapshot
	}
	return nil
}

func (m *Cursor) GetJsonValues() []string {
	if m != nil {
		return m.JsonValues
	}
	return nil
}

type DocSnapshot struct {
	Path                 string   `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	JsonData             string   `protobuf:"bytes,2,opt,name=json_data,json=jsonData,proto3" json:"json_data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DocSnapshot) Reset()         { *m = DocSnapshot{} }
func (m *DocSnapshot) String() string { return proto.CompactTextString(m) }
func (*DocSnapshot) ProtoMessage()    {}
func (*DocSnapshot) Descriptor() ([]byte, []int) {
	return fileDescriptor_test_338de568ad9314f7, []int{15}
}
func (m *DocSnapshot) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DocSnapshot.Unmarshal(m, b)
}
func (m *DocSnapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DocSnapshot.Marshal(b, m, deterministic)
}
func (dst *DocSnapshot) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DocSnapshot.Merge(dst, src)
}
func (m *DocSnapshot) XXX_Size() int {
	return xxx_messageInfo_DocSnapshot.Size(m)
}
func (m *DocSnapshot) XXX_DiscardUnknown() {
	xxx_messageInfo_DocSnapshot.DiscardUnknown(m)
}

var xxx_messageInfo_DocSnapshot proto.InternalMessageInfo

func (m *DocSnapshot) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *DocSnapshot) GetJsonData() string {
	if m != nil {
		return m.JsonData
	}
	return ""
}

type FieldPath struct {
	Field                []string `protobuf:"bytes,1,rep,name=field,proto3" json:"field,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FieldPath) Reset()         { *m = FieldPath{} }
func (m *FieldPath) String() string { return proto.CompactTextString(m) }
func (*FieldPath) ProtoMessage()    {}
func (*FieldPath) Descriptor() ([]byte, []int) {
	return fileDescriptor_test_338de568ad9314f7, []int{16}
}
func (m *FieldPath) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FieldPath.Unmarshal(m, b)
}
func (m *FieldPath) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FieldPath.Marshal(b, m, deterministic)
}
func (dst *FieldPath) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FieldPath.Merge(dst, src)
}
func (m *FieldPath) XXX_Size() int {
	return xxx_messageInfo_FieldPath.Size(m)
}
func (m *FieldPath) XXX_DiscardUnknown() {
	xxx_messageInfo_FieldPath.DiscardUnknown(m)
}

var xxx_messageInfo_FieldPath proto.InternalMessageInfo

func (m *FieldPath) GetField() []string {
	if m != nil {
		return m.Field
	}
	return nil
}

// A test of the Listen streaming RPC (a.k.a. FireStore watch).
// If the sequence of responses is provided to the implementation,
// it should produce the sequence of snapshots.
// If is_error is true, an error should occur after the snapshots.
//
// The tests assume that the query is
// Collection("projects/projectID/databases/(default)/documents/C").OrderBy("a", Ascending)
//
// The watch target ID used in these tests is 1. Test interpreters
// should either change their client's ID for testing,
// or change the ID in the tests before running them.
type ListenTest struct {
	Responses            []*v1beta1.ListenResponse `protobuf:"bytes,1,rep,name=responses,proto3" json:"responses,omitempty"`
	Snapshots            []*Snapshot               `protobuf:"bytes,2,rep,name=snapshots,proto3" json:"snapshots,omitempty"`
	IsError              bool                      `protobuf:"varint,3,opt,name=is_error,json=isError,proto3" json:"is_error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

func (m *ListenTest) Reset()         { *m = ListenTest{} }
func (m *ListenTest) String() string { return proto.CompactTextString(m) }
func (*ListenTest) ProtoMessage()    {}
func (*ListenTest) Descriptor() ([]byte, []int) {
	return fileDescriptor_test_338de568ad9314f7, []int{17}
}
func (m *ListenTest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListenTest.Unmarshal(m, b)
}
func (m *ListenTest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListenTest.Marshal(b, m, deterministic)
}
func (dst *ListenTest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListenTest.Merge(dst, src)
}
func (m *ListenTest) XXX_Size() int {
	return xxx_messageInfo_ListenTest.Size(m)
}
func (m *ListenTest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListenTest.DiscardUnknown(m)
}

var xxx_messageInfo_ListenTest proto.InternalMessageInfo

func (m *ListenTest) GetResponses() []*v1beta1.ListenResponse {
	if m != nil {
		return m.Responses
	}
	return nil
}

func (m *ListenTest) GetSnapshots() []*Snapshot {
	if m != nil {
		return m.Snapshots
	}
	return nil
}

func (m *ListenTest) GetIsError() bool {
	if m != nil {
		return m.IsError
	}
	return false
}

type Snapshot struct {
	Docs                 []*v1beta1.Document  `protobuf:"bytes,1,rep,name=docs,proto3" json:"docs,omitempty"`
	Changes              []*DocChange         `protobuf:"bytes,2,rep,name=changes,proto3" json:"changes,omitempty"`
	ReadTime             *timestamp.Timestamp `protobuf:"bytes,3,opt,name=read_time,json=readTime,proto3" json:"read_time,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_test_338de568ad9314f7, []int{18}
}
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) GetDocs() []*v1beta1.Document {
	if m != nil {
		return m.Docs
	}
	return nil
}

func (m *Snapshot) GetChanges() []*DocChange {
	if m != nil {
		return m.Changes
	}
	return nil
}

func (m *Snapshot) GetReadTime() *timestamp.Timestamp {
	if m != nil {
		return m.ReadTime
	}
	return nil
}

type DocChange struct {
	Kind                 DocChange_Kind    `protobuf:"varint,1,opt,name=kind,proto3,enum=tests.DocChange_Kind" json:"kind,omitempty"`
	Doc                  *v1beta1.Document `protobuf:"bytes,2,opt,name=doc,proto3" json:"doc,omitempty"`
	OldIndex             int32             `protobuf:"varint,3,opt,name=old_index,json=oldIndex,proto3" json:"old_index,omitempty"`
	NewIndex             int32             `protobuf:"varint,4,opt,name=new_index,json=newIndex,proto3" json:"new_index,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *DocChange) Reset()         { *m = DocChange{} }
func (m *DocChange) String() string { return proto.CompactTextString(m) }
func (*DocChange) ProtoMessage()    {}
func (*DocChange) Descriptor() ([]byte, []int) {
	return fileDescriptor_test_338de568ad9314f7, []int{19}
}
func (m *DocChange) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DocChange.Unmarshal(m, b)
}
func (m *DocChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DocChange.Marshal(b, m, deterministic)
}
func (dst *DocChange) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DocChange.Merge(dst, src)
}
func (m *DocChange) XXX_Size() int {
	return xxx_messageInfo_DocChange.Size(m)
}
func (m *DocChange) XXX_DiscardUnknown() {
	xxx_messageInfo_DocChange.DiscardUnknown(m)
}

var xxx_messageInfo_DocChange proto.InternalMessageInfo

func (m *DocChange) GetKind() DocChange_Kind {
	if m != nil {
		return m.Kind
	}
	return DocChange_KIND_UNSPECIFIED
}

func (m *DocChange) GetDoc() *v1beta1.Document {
	if m != nil {
		return m.Doc
	}
	return nil
}

func (m *DocChange) GetOldIndex() int32 {
	if m != nil {
		return m.OldIndex
	}
	return 0
}

func (m *DocChange) GetNewIndex() int32 {
	if m != nil {
		return m.NewIndex
	}
	return 0
}

func init() {
	proto.RegisterType((*TestSuite)(nil), "tests.TestSuite")
	proto.RegisterType((*Test)(nil), "tests.Test")
	proto.RegisterType((*GetTest)(nil), "tests.GetTest")
	proto.RegisterType((*CreateTest)(nil), "tests.CreateTest")
	proto.RegisterType((*SetTest)(nil), "tests.SetTest")
	proto.RegisterType((*UpdateTest)(nil), "tests.UpdateTest")
	proto.RegisterType((*UpdatePathsTest)(nil), "tests.UpdatePathsTest")
	proto.RegisterType((*DeleteTest)(nil), "tests.DeleteTest")
	proto.RegisterType((*SetOption)(nil), "tests.SetOption")
	proto.RegisterType((*QueryTest)(nil), "tests.QueryTest")
	proto.RegisterType((*Clause)(nil), "tests.Clause")
	proto.RegisterType((*Select)(nil), "tests.Select")
	proto.RegisterType((*Where)(nil), "tests.Where")
	proto.RegisterType((*OrderBy)(nil), "tests.OrderBy")
	proto.RegisterType((*Cursor)(nil), "tests.Cursor")
	proto.RegisterType((*DocSnapshot)(nil), "tests.DocSnapshot")
	proto.RegisterType((*FieldPath)(nil), "tests.FieldPath")
	proto.RegisterType((*ListenTest)(nil), "tests.ListenTest")
	proto.RegisterType((*Snapshot)(nil), "tests.Snapshot")
	proto.RegisterType((*DocChange)(nil), "tests.DocChange")
	proto.RegisterEnum("tests.DocChange_Kind", DocChange_Kind_name, DocChange_Kind_value)
}

func init() { proto.RegisterFile("test.proto", fileDescriptor_test_338de568ad9314f7) }

var fileDescriptor_test_338de568ad9314f7 = []byte{
	// 1292 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x57, 0x4d, 0x73, 0xdb, 0xc4,
	0x1b, 0xaf, 0x6c, 0x4b, 0x96, 0x1e, 0xe7, 0xdf, 0xe6, 0xbf, 0x53, 0x3a, 0x26, 0xc0, 0x34, 0xd5,
	0x94, 0xc6, 0x6d, 0xc1, 0xa1, 0xe1, 0xed, 0xc0, 0x0c, 0x4c, 0x12, 0x3b, 0x6d, 0x28, 0x6d, 0x82,
	0xdc, 0x96, 0x4b, 0x66, 0x8c, 0xa2, 0x5d, 0x27, 0x02, 0x59, 0xeb, 0xee, 0xae, 0xfa, 0xf2, 0x39,
	0xb8, 0x73, 0x65, 0x60, 0x86, 0x03, 0x5f, 0x83, 0x13, 0x47, 0x3e, 0x03, 0x77, 0x38, 0x33, 0xfb,
	0x26, 0x59, 0x69, 0x5d, 0x72, 0x28, 0xe5, 0xb6, 0xfb, 0x3c, 0xbf, 0xe7, 0xfd, 0x65, 0x25, 0x00,
	0x41, 0xb8, 0xe8, 0xcf, 0x18, 0x15, 0x14, 0xb9, 0xf2, 0xcc, 0x57, 0xde, 0x3e, 0xa2, 0xf4, 0x28,
	0x23, 0xeb, 0x93, 0x94, 0x11, 0x2e, 0x28, 0x23, 0xeb, 0x8f, 0x6e, 0x1c, 0x12, 0x11, 0xdf, 0x58,
	0x4f, 0xe8, 0x74, 0x4a, 0x73, 0x8d, 0x5e, 0x59, 0x5b, 0x08, 0xc3, 0x34, 0x29, 0xa6, 0x24, 0x37,
	0x6a, 0x57, 0x7a, 0x0b, 0x81, 0x25, 0xc5, 0x20, 0x2f, 0x2f, 0x44, 0x3e, 0x2c, 0x08, 0x7b, 0x6a,
	0x50, 0x17, 0x0d, 0x4a, 0xdd, 0x0e, 0x8b, 0xc9, 0xba, 0x48, 0xa7, 0x84, 0x8b, 0x78, 0x3a, 0xd3,
	0x80, 0xb0, 0x0f, 0xc1, 0x3d, 0xc2, 0xc5, 0xa8, 0x48, 0x05, 0x41, 0x97, 0x40, 0x87, 0xd5, 0x75,
	0x56, 0x9b, 0xbd, 0xce, 0x46, 0xa7, 0xaf, 0x6e, 0x7d, 0x09, 0x88, 0x34, 0x27, 0xfc, 0xae, 0x09,
	0x2d, 0x79, 0x47, 0xab, 0xd0, 0xc1, 0x84, 0x27, 0x2c, 0x9d, 0x89, 0x94, 0xe6, 0x5d, 0x67, 0xd5,
	0xe9, 0x05, 0xd1, 0x3c, 0x09, 0x85, 0xd0, 0x3c, 0x22, 0xa2, 0xdb, 0x58, 0x75, 0x7a, 0x9d, 0x8d,
	0xb3, 0x46, 0xd7, 0x4d, 0x22, 0xa4, 0xf8, 0xad, 0x33, 0x91, 0x64, 0xa2, 0xeb, 0xe0, 0x25, 0x8c,
	0xc4, 0x82, 0x74, 0x9b, 0x0a, 0xf6, 0x7f, 0x03, 0xdb, 0x56, 0x44, 0x83, 0x34, 0x10, 0xa9, 0x90,
	0x13, 0xd1, 0x6d, 0xd5, 0x14, 0x8e, 0x2a, 0x85, 0x5c, 0x2b, 0x2c, 0x66, 0x58, 0x2a, 0x74, 0x6b,
	0x0a, 0xef, 0x2b, 0xa2, 0x55, 0xa8, 0x21, 0xe8, 0x13, 0x58, 0xd2, 0xa7, 0xf1, 0x2c, 0x16, 0xc7,
	0xbc, 0xeb, 0x29, 0x91, 0x0b, 0x35, 0x91, 0x7d, 0xc9, 0x31, 0x72, 0x9d, 0xa2, 0x22, 0x49, 0x4b,
	0x98, 0x64, 0x44, 0x90, 0x6e, 0xbb, 0x66, 0x69, 0xa0, 0x88, 0xd6, 0x92, 0x86, 0xa0, 0x1e, 0xb8,
	0xaa, 0x2c, 0x5d, 0x5f, 0x61, 0x97, 0x0d, 0xf6, 0x4b, 0x49, 0x33, 0x50, 0x0d, 0x90, 0x6a, 0xb3,
	0x94, 0x0b, 0x92, 0x77, 0x83, 0x9a, 0xda, 0x2f, 0x14, 0xd1, 0xaa, 0xd5, 0x90, 0x2d, 0x0f, 0x5a,
	0x92, 0x1b, 0x72, 0x68, 0x9b, 0xc4, 0xa2, 0x55, 0x58, 0xc2, 0x34, 0x19, 0x33, 0x32, 0x51, 0x41,
	0x99, 0xc2, 0x00, 0xa6, 0x49, 0x44, 0x26, 0xd2, 0x73, 0xb4, 0x03, 0x6d, 0x46, 0x1e, 0x16, 0x84,
	0xdb, 0xda, 0xbc, 0xd3, 0xd7, 0x5d, 0xd2, 0xaf, 0x7a, 0xcc, 0xf4, 0x92, 0x2c, 0xd7, 0xc0, 0x74,
	0x68, 0xa4, 0x65, 0x22, 0x2b, 0x1c, 0xfe, 0xe8, 0x00, 0x54, 0x75, 0x3a, 0x85, 0xe1, 0x37, 0x20,
	0xf8, 0x86, 0xd3, 0x7c, 0x8c, 0x63, 0x11, 0x2b, 0xd3, 0x41, 0xe4, 0x4b, 0xc2, 0x20, 0x16, 0x31,
	0xda, 0xac, 0xbc, 0xd2, 0xad, 0xb0, 0xb6, 0xd8, 0xab, 0x6d, 0x3a, 0x9d, 0xa6, 0xcf, 0x38, 0x84,
	0x5e, 0x07, 0x3f, 0xe5, 0x63, 0xc2, 0x18, 0x65, 0xaa, 0x49, 0xfc, 0xa8, 0x9d, 0xf2, 0xa1, 0xbc,
	0x86, 0xbf, 0x39, 0xd0, 0x1e, 0x9d, 0x3a, 0x43, 0x3d, 0xf0, 0xa8, 0x6e, 0xeb, 0x46, 0xad, 0x5c,
	0x23, 0x22, 0xf6, 0x14, 0x3d, 0x32, 0xfc, 0x7a, 0x48, 0xcd, 0xc5, 0x21, 0xb5, 0x5e, 0x42, 0x48,
	0x6e, 0x3d, 0xa4, 0x3f, 0x1d, 0x80, 0xaa, 0xab, 0x4f, 0x11, 0xd5, 0xe7, 0xb0, 0x34, 0x63, 0x24,
	0xa1, 0x39, 0x4e, 0xe7, 0x62, 0xbb, 0xb2, 0xd8, 0xa7, 0xfd, 0x39, 0x74, 0x54, 0x93, 0xfd, 0x2f,
	0xe3, 0xfe, 0xa5, 0x01, 0xe7, 0x4e, 0x8c, 0xe6, 0x2b, 0x0e, 0xfe, 0x06, 0x74, 0x26, 0x29, 0xc9,
	0xb0, 0xd9, 0x1a, 0x4d, 0xb5, 0x2c, 0x6d, 0x8f, 0xec, 0x48, 0x8e, 0x34, 0x19, 0xc1, 0xc4, 0x1e,
	0x39, 0xba, 0x08, 0x1d, 0x95, 0xaf, 0x47, 0x71, 0x56, 0x10, 0xde, 0x6d, 0xad, 0x36, 0xa5, 0x7f,
	0x92, 0xf4, 0x40, 0x51, 0xe6, 0x73, 0xe6, 0xbe, 0x84, 0x9c, 0x79, 0xf5, 0x9c, 0xfd, 0xee, 0x00,
	0x54, 0x7b, 0xe9, 0x15, 0xa7, 0xeb, 0xdf, 0x9d, 0xec, 0x9b, 0x10, 0x94, 0x63, 0x89, 0x96, 0xa1,
	0x19, 0x67, 0x99, 0x8a, 0xc7, 0x8f, 0xe4, 0x51, 0x8e, 0xb2, 0x2a, 0x03, 0xef, 0x36, 0x16, 0x94,
	0xc9, 0xf0, 0xc3, 0x9f, 0x1d, 0x08, 0xca, 0x7d, 0x2c, 0x1b, 0x3c, 0xa1, 0x59, 0x36, 0x9f, 0x1f,
	0x5f, 0x12, 0x54, 0x76, 0xd6, 0xa0, 0x9d, 0x64, 0x71, 0xc1, 0x89, 0xd5, 0xfa, 0x3f, 0xfb, 0x6c,
	0x29, 0x6a, 0x64, 0xb9, 0xe8, 0x33, 0xbb, 0xf6, 0x75, 0xe0, 0x57, 0x17, 0x07, 0x3e, 0x12, 0xac,
	0x48, 0x44, 0xc1, 0x08, 0x56, 0x3e, 0xd8, 0xd7, 0xe0, 0x05, 0x81, 0xff, 0xd5, 0x00, 0x4f, 0xdb,
	0x43, 0x6b, 0xe0, 0x71, 0x92, 0x91, 0x44, 0x28, 0x4f, 0x2b, 0x77, 0x46, 0x8a, 0x28, 0xdf, 0x0b,
	0xcd, 0x46, 0x97, 0xc1, 0x7d, 0x7c, 0x4c, 0x18, 0x31, 0xf5, 0x5c, 0x32, 0xb8, 0xaf, 0x24, 0x4d,
	0x3e, 0x41, 0x8a, 0x89, 0xae, 0x83, 0x4f, 0x19, 0x26, 0x6c, 0x7c, 0x68, 0x1d, 0xb7, 0x8f, 0xed,
	0x9e, 0x24, 0x6f, 0x3d, 0xbd, 0x75, 0x26, 0x6a, 0x53, 0x7d, 0x44, 0x5d, 0xf0, 0xe8, 0x64, 0x62,
	0xdf, 0x65, 0x57, 0x1a, 0xd3, 0x77, 0x74, 0x01, 0xdc, 0x2c, 0x9d, 0xa6, 0xba, 0xa1, 0x25, 0x43,
	0x5f, 0xd1, 0x35, 0xf0, 0xb9, 0x88, 0x99, 0x18, 0xc7, 0xc2, 0xbc, 0xb8, 0x65, 0xfa, 0x0a, 0xc6,
	0x29, 0x93, 0xda, 0x15, 0x60, 0x53, 0xa0, 0xf7, 0xa0, 0x63, 0xb0, 0x13, 0x41, 0x98, 0x79, 0x69,
	0x9f, 0x81, 0x83, 0x86, 0x4b, 0x08, 0xba, 0x02, 0x1e, 0xc9, 0xb1, 0xd4, 0xed, 0x3f, 0x1f, 0xec,
	0x92, 0x1c, 0x6f, 0x0a, 0xd4, 0x07, 0x90, 0xb8, 0x43, 0x32, 0xa1, 0x8c, 0x98, 0xb7, 0xf6, 0x19,
	0x6c, 0x40, 0x72, 0xbc, 0xa5, 0x10, 0x5b, 0x3e, 0x78, 0xba, 0xaa, 0xe1, 0x06, 0x78, 0x3a, 0xb1,
	0x73, 0xcd, 0xe5, 0xfc, 0x43, 0x73, 0x1d, 0x80, 0xab, 0x92, 0x8c, 0x2e, 0x43, 0xab, 0x6c, 0xa9,
	0xe7, 0x09, 0x28, 0x2e, 0x3a, 0x0b, 0x0d, 0x3a, 0x33, 0x4f, 0x64, 0x83, 0xce, 0xd0, 0x5b, 0x00,
	0xd5, 0xfa, 0x30, 0xfb, 0x36, 0x28, 0xb7, 0x47, 0x78, 0x07, 0xda, 0xa6, 0x32, 0xa7, 0xd4, 0xff,
	0x26, 0x04, 0x38, 0x65, 0x24, 0x29, 0x67, 0x3b, 0x88, 0x2a, 0x42, 0xf8, 0x35, 0x78, 0x3a, 0x03,
	0xe8, 0x43, 0xbd, 0x28, 0x78, 0x1e, 0xcf, 0xf8, 0x31, 0xb5, 0xed, 0x85, 0xec, 0x97, 0x0e, 0x4d,
	0x46, 0x86, 0x13, 0x75, 0x70, 0x75, 0x39, 0xb9, 0xed, 0x1a, 0x27, 0xb7, 0x5d, 0xf8, 0x29, 0x74,
	0xe6, 0x84, 0x11, 0x9a, 0x73, 0x3a, 0x30, 0x2e, 0xbe, 0xe8, 0x63, 0x21, 0xbc, 0x04, 0x41, 0x19,
	0x12, 0x3a, 0x0f, 0xae, 0xca, 0xb2, 0x2a, 0x42, 0x10, 0xe9, 0x4b, 0xf8, 0xbd, 0x03, 0x50, 0x7d,
	0x33, 0xa1, 0x1d, 0x08, 0x18, 0xe1, 0x33, 0x9a, 0xcb, 0xa1, 0xd5, 0xd5, 0xea, 0x2d, 0x9e, 0x46,
	0x2d, 0x18, 0x19, 0x81, 0xa8, 0x12, 0x45, 0xef, 0x42, 0x60, 0xb3, 0x61, 0x87, 0xff, 0x9c, 0x9d,
	0x36, 0x9b, 0x8b, 0x0a, 0x51, 0x9b, 0xdf, 0x66, 0x7d, 0x7e, 0x7f, 0x70, 0xc0, 0x2f, 0x33, 0xf0,
	0x11, 0xb4, 0x30, 0x4d, 0xac, 0x67, 0xe1, 0x62, 0xcf, 0xca, 0xaf, 0x31, 0x85, 0x47, 0xd7, 0xa0,
	0x9d, 0x1c, 0xc7, 0xf9, 0x11, 0x39, 0xb9, 0xdf, 0x06, 0x34, 0xd9, 0x56, 0x8c, 0xc8, 0x02, 0xd0,
	0xc7, 0x32, 0x05, 0x31, 0x1e, 0xcb, 0x5f, 0x00, 0x33, 0xd7, 0x2b, 0xd6, 0x90, 0xfd, 0x3f, 0xe8,
	0xdf, 0xb3, 0xff, 0x07, 0x91, 0x2f, 0xc1, 0xf2, 0x1a, 0xfe, 0xe1, 0x40, 0x50, 0xea, 0x43, 0x57,
	0xa1, 0xf5, 0x6d, 0x9a, 0x63, 0x55, 0xac, 0xb3, 0x1b, 0xaf, 0x9d, 0xb4, 0xd7, 0xbf, 0x9d, 0xe6,
	0x38, 0x52, 0x10, 0xf4, 0x01, 0x34, 0x31, 0x4d, 0xcc, 0xb2, 0x39, 0x4d, 0x50, 0x12, 0x2e, 0x2b,
	0x4f, 0x33, 0x3c, 0x4e, 0x73, 0x4c, 0x9e, 0x28, 0x3f, 0xdd, 0xc8, 0xa7, 0x19, 0xde, 0x95, 0x77,
	0xc9, 0xcc, 0xc9, 0x63, 0xc3, 0x6c, 0x69, 0x66, 0x4e, 0x1e, 0x2b, 0x66, 0xb8, 0x05, 0x2d, 0x69,
	0x1d, 0x9d, 0x87, 0xe5, 0xdb, 0xbb, 0x77, 0x07, 0xe3, 0xfb, 0x77, 0x47, 0xfb, 0xc3, 0xed, 0xdd,
	0x9d, 0xdd, 0xe1, 0x60, 0xf9, 0x0c, 0x0a, 0xc0, 0xdd, 0x1c, 0x0c, 0x86, 0x83, 0x65, 0x07, 0x75,
	0xa0, 0x1d, 0x0d, 0xef, 0xec, 0x3d, 0x18, 0x0e, 0x96, 0x1b, 0x68, 0x09, 0xfc, 0x3b, 0x7b, 0x03,
	0x8d, 0x6a, 0x6e, 0x3d, 0x81, 0x2b, 0x09, 0x9d, 0x5a, 0x5f, 0x93, 0x8c, 0x16, 0x78, 0xce, 0xe3,
	0x84, 0xe6, 0x13, 0xca, 0xa6, 0x71, 0x9e, 0x90, 0x9f, 0x1a, 0xe1, 0x4d, 0x0d, 0xda, 0x56, 0xa0,
	0x9d, 0x12, 0x74, 0x4f, 0x65, 0x64, 0x5f, 0xa6, 0xf4, 0xd7, 0x46, 0x4f, 0x83, 0x0e, 0x14, 0xe8,
	0xa0, 0x04, 0x1d, 0x28, 0xd0, 0xc1, 0x76, 0xa5, 0xef, 0xd0, 0x53, 0x45, 0x78, 0xff, 0xef, 0x00,
	0x00, 0x00, 0xff, 0xff, 0xc2, 0x7a, 0x63, 0xd5, 0x67, 0x0e, 0x00, 0x00,
}