basic_example.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: tests/spanner/basic/basic_example.proto

package basic

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	_ "github.com/golang/protobuf/protoc-gen-go/descriptor"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	_ "github.com/tcncloud/protoc-gen-persist/persist"
	test "github.com/tcncloud/protoc-gen-persist/tests/test"
	grpc "google.golang.org/grpc"
	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.ProtoPackageIsVersion3 // please upgrade the proto package

type MyEnum int32

const (
	MyEnum_OPTION_0 MyEnum = 0
	MyEnum_OPTION_1 MyEnum = 1
)

var MyEnum_name = map[int32]string{
	0: "OPTION_0",
	1: "OPTION_1",
}

var MyEnum_value = map[string]int32{
	"OPTION_0": 0,
	"OPTION_1": 1,
}

func (x MyEnum) String() string {
	return proto.EnumName(MyEnum_name, int32(x))
}

func (MyEnum) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b3a4b20bf4552a7a, []int{0}
}

type MappedEnum int32

const (
	MappedEnum_OPT_0 MappedEnum = 0
	MappedEnum_OPT_1 MappedEnum = 1
)

var MappedEnum_name = map[int32]string{
	0: "OPT_0",
	1: "OPT_1",
}

var MappedEnum_value = map[string]int32{
	"OPT_0": 0,
	"OPT_1": 1,
}

func (x MappedEnum) String() string {
	return proto.EnumName(MappedEnum_name, int32(x))
}

func (MappedEnum) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b3a4b20bf4552a7a, []int{1}
}

type Empty struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Empty) Reset()         { *m = Empty{} }
func (m *Empty) String() string { return proto.CompactTextString(m) }
func (*Empty) ProtoMessage()    {}
func (*Empty) Descriptor() ([]byte, []int) {
	return fileDescriptor_b3a4b20bf4552a7a, []int{0}
}

func (m *Empty) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Empty.Unmarshal(m, b)
}
func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Empty.Marshal(b, m, deterministic)
}
func (m *Empty) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Empty.Merge(m, src)
}
func (m *Empty) XXX_Size() int {
	return xxx_messageInfo_Empty.Size(m)
}
func (m *Empty) XXX_DiscardUnknown() {
	xxx_messageInfo_Empty.DiscardUnknown(m)
}

var xxx_messageInfo_Empty proto.InternalMessageInfo

type Something struct {
	Thing                *Something_SomethingElse `protobuf:"bytes,2,opt,name=thing,proto3" json:"thing,omitempty"`
	Myenum               MyEnum                   `protobuf:"varint,3,opt,name=myenum,proto3,enum=tests.MyEnum" json:"myenum,omitempty"`
	Mappedenum           MappedEnum               `protobuf:"varint,4,opt,name=mappedenum,proto3,enum=tests.MappedEnum" json:"mappedenum,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

func (m *Something) Reset()         { *m = Something{} }
func (m *Something) String() string { return proto.CompactTextString(m) }
func (*Something) ProtoMessage()    {}
func (*Something) Descriptor() ([]byte, []int) {
	return fileDescriptor_b3a4b20bf4552a7a, []int{1}
}

func (m *Something) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Something.Unmarshal(m, b)
}
func (m *Something) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Something.Marshal(b, m, deterministic)
}
func (m *Something) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Something.Merge(m, src)
}
func (m *Something) XXX_Size() int {
	return xxx_messageInfo_Something.Size(m)
}
func (m *Something) XXX_DiscardUnknown() {
	xxx_messageInfo_Something.DiscardUnknown(m)
}

var xxx_messageInfo_Something proto.InternalMessageInfo

func (m *Something) GetThing() *Something_SomethingElse {
	if m != nil {
		return m.Thing
	}
	return nil
}

func (m *Something) GetMyenum() MyEnum {
	if m != nil {
		return m.Myenum
	}
	return MyEnum_OPTION_0
}

func (m *Something) GetMappedenum() MappedEnum {
	if m != nil {
		return m.Mappedenum
	}
	return MappedEnum_OPT_0
}

type Something_SomethingElse struct {
	Thing                string   `protobuf:"bytes,1,opt,name=thing,proto3" json:"thing,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Something_SomethingElse) Reset()         { *m = Something_SomethingElse{} }
func (m *Something_SomethingElse) String() string { return proto.CompactTextString(m) }
func (*Something_SomethingElse) ProtoMessage()    {}
func (*Something_SomethingElse) Descriptor() ([]byte, []int) {
	return fileDescriptor_b3a4b20bf4552a7a, []int{1, 0}
}

func (m *Something_SomethingElse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Something_SomethingElse.Unmarshal(m, b)
}
func (m *Something_SomethingElse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Something_SomethingElse.Marshal(b, m, deterministic)
}
func (m *Something_SomethingElse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Something_SomethingElse.Merge(m, src)
}
func (m *Something_SomethingElse) XXX_Size() int {
	return xxx_messageInfo_Something_SomethingElse.Size(m)
}
func (m *Something_SomethingElse) XXX_DiscardUnknown() {
	xxx_messageInfo_Something_SomethingElse.DiscardUnknown(m)
}

var xxx_messageInfo_Something_SomethingElse proto.InternalMessageInfo

func (m *Something_SomethingElse) GetThing() string {
	if m != nil {
		return m.Thing
	}
	return ""
}

type HasTimestamp struct {
	Time                 *timestamp.Timestamp   `protobuf:"bytes,1,opt,name=time,proto3" json:"time,omitempty"`
	Some                 *Something             `protobuf:"bytes,2,opt,name=some,proto3" json:"some,omitempty"`
	Str                  string                 `protobuf:"bytes,3,opt,name=str,proto3" json:"str,omitempty"`
	Table                *test.ExampleTable     `protobuf:"bytes,4,opt,name=table,proto3" json:"table,omitempty"`
	Strs                 []string               `protobuf:"bytes,5,rep,name=strs,proto3" json:"strs,omitempty"`
	Tables               []*test.ExampleTable   `protobuf:"bytes,6,rep,name=tables,proto3" json:"tables,omitempty"`
	Somes                []*Something           `protobuf:"bytes,7,rep,name=somes,proto3" json:"somes,omitempty"`
	Times                []*timestamp.Timestamp `protobuf:"bytes,8,rep,name=times,proto3" json:"times,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *HasTimestamp) Reset()         { *m = HasTimestamp{} }
func (m *HasTimestamp) String() string { return proto.CompactTextString(m) }
func (*HasTimestamp) ProtoMessage()    {}
func (*HasTimestamp) Descriptor() ([]byte, []int) {
	return fileDescriptor_b3a4b20bf4552a7a, []int{2}
}

func (m *HasTimestamp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_HasTimestamp.Unmarshal(m, b)
}
func (m *HasTimestamp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_HasTimestamp.Marshal(b, m, deterministic)
}
func (m *HasTimestamp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HasTimestamp.Merge(m, src)
}
func (m *HasTimestamp) XXX_Size() int {
	return xxx_messageInfo_HasTimestamp.Size(m)
}
func (m *HasTimestamp) XXX_DiscardUnknown() {
	xxx_messageInfo_HasTimestamp.DiscardUnknown(m)
}

var xxx_messageInfo_HasTimestamp proto.InternalMessageInfo

func (m *HasTimestamp) GetTime() *timestamp.Timestamp {
	if m != nil {
		return m.Time
	}
	return nil
}

func (m *HasTimestamp) GetSome() *Something {
	if m != nil {
		return m.Some
	}
	return nil
}

func (m *HasTimestamp) GetStr() string {
	if m != nil {
		return m.Str
	}
	return ""
}

func (m *HasTimestamp) GetTable() *test.ExampleTable {
	if m != nil {
		return m.Table
	}
	return nil
}

func (m *HasTimestamp) GetStrs() []string {
	if m != nil {
		return m.Strs
	}
	return nil
}

func (m *HasTimestamp) GetTables() []*test.ExampleTable {
	if m != nil {
		return m.Tables
	}
	return nil
}

func (m *HasTimestamp) GetSomes() []*Something {
	if m != nil {
		return m.Somes
	}
	return nil
}

func (m *HasTimestamp) GetTimes() []*timestamp.Timestamp {
	if m != nil {
		return m.Times
	}
	return nil
}

func init() {
	proto.RegisterEnum("tests.MyEnum", MyEnum_name, MyEnum_value)
	proto.RegisterEnum("tests.MappedEnum", MappedEnum_name, MappedEnum_value)
	proto.RegisterType((*Empty)(nil), "tests.Empty")
	proto.RegisterType((*Something)(nil), "tests.Something")
	proto.RegisterType((*Something_SomethingElse)(nil), "tests.Something.SomethingElse")
	proto.RegisterType((*HasTimestamp)(nil), "tests.HasTimestamp")
}

func init() {
	proto.RegisterFile("tests/spanner/basic/basic_example.proto", fileDescriptor_b3a4b20bf4552a7a)
}

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// ExtraSrvClient is the client API for ExtraSrv service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ExtraSrvClient interface {
	ExtraUnary(ctx context.Context, in *test.NumRows, opts ...grpc.CallOption) (*test.ExampleTable, error)
	ExtraMethod(ctx context.Context, in *test.ExampleTable, opts ...grpc.CallOption) (*test.ExampleTable, error)
}

type extraSrvClient struct {
	cc *grpc.ClientConn
}

func NewExtraSrvClient(cc *grpc.ClientConn) ExtraSrvClient {
	return &extraSrvClient{cc}
}

func (c *extraSrvClient) ExtraUnary(ctx context.Context, in *test.NumRows, opts ...grpc.CallOption) (*test.ExampleTable, error) {
	out := new(test.ExampleTable)
	err := c.cc.Invoke(ctx, "/tests.ExtraSrv/ExtraUnary", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extraSrvClient) ExtraMethod(ctx context.Context, in *test.ExampleTable, opts ...grpc.CallOption) (*test.ExampleTable, error) {
	out := new(test.ExampleTable)
	err := c.cc.Invoke(ctx, "/tests.ExtraSrv/ExtraMethod", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ExtraSrvServer is the server API for ExtraSrv service.
type ExtraSrvServer interface {
	ExtraUnary(context.Context, *test.NumRows) (*test.ExampleTable, error)
	ExtraMethod(context.Context, *test.ExampleTable) (*test.ExampleTable, error)
}

func RegisterExtraSrvServer(s *grpc.Server, srv ExtraSrvServer) {
	s.RegisterService(&_ExtraSrv_serviceDesc, srv)
}

func _ExtraSrv_ExtraUnary_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(test.NumRows)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtraSrvServer).ExtraUnary(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tests.ExtraSrv/ExtraUnary",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtraSrvServer).ExtraUnary(ctx, req.(*test.NumRows))
	}
	return interceptor(ctx, in, info, handler)
}

func _ExtraSrv_ExtraMethod_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(test.ExampleTable)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtraSrvServer).ExtraMethod(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tests.ExtraSrv/ExtraMethod",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtraSrvServer).ExtraMethod(ctx, req.(*test.ExampleTable))
	}
	return interceptor(ctx, in, info, handler)
}

var _ExtraSrv_serviceDesc = grpc.ServiceDesc{
	ServiceName: "tests.ExtraSrv",
	HandlerType: (*ExtraSrvServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ExtraUnary",
			Handler:    _ExtraSrv_ExtraUnary_Handler,
		},
		{
			MethodName: "ExtraMethod",
			Handler:    _ExtraSrv_ExtraMethod_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "tests/spanner/basic/basic_example.proto",
}

// MySpannerClient is the client API for MySpanner service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MySpannerClient interface {
	UniaryInsert(ctx context.Context, in *test.ExampleTable, opts ...grpc.CallOption) (*test.ExampleTable, error)
	UniarySelect(ctx context.Context, in *test.ExampleTable, opts ...grpc.CallOption) (*test.ExampleTable, error)
	UniarySelectWithDirectives(ctx context.Context, in *test.ExampleTable, opts ...grpc.CallOption) (*test.ExampleTable, error)
	UniaryUpdate(ctx context.Context, in *test.ExampleTable, opts ...grpc.CallOption) (*test.PartialTable, error)
	UniaryDeleteRange(ctx context.Context, in *test.ExampleTableRange, opts ...grpc.CallOption) (*test.ExampleTable, error)
	ServerStream(ctx context.Context, in *test.Name, opts ...grpc.CallOption) (MySpanner_ServerStreamClient, error)
	ClientStreamInsert(ctx context.Context, opts ...grpc.CallOption) (MySpanner_ClientStreamInsertClient, error)
	ClientStreamDelete(ctx context.Context, opts ...grpc.CallOption) (MySpanner_ClientStreamDeleteClient, error)
	UniarySelectWithHooks(ctx context.Context, in *test.ExampleTable, opts ...grpc.CallOption) (*test.ExampleTable, error)
	ServerStreamWithHooks(ctx context.Context, in *test.Name, opts ...grpc.CallOption) (MySpanner_ServerStreamWithHooksClient, error)
	ClientStreamUpdateWithHooks(ctx context.Context, opts ...grpc.CallOption) (MySpanner_ClientStreamUpdateWithHooksClient, error)
}

type mySpannerClient struct {
	cc *grpc.ClientConn
}

func NewMySpannerClient(cc *grpc.ClientConn) MySpannerClient {
	return &mySpannerClient{cc}
}

func (c *mySpannerClient) UniaryInsert(ctx context.Context, in *test.ExampleTable, opts ...grpc.CallOption) (*test.ExampleTable, error) {
	out := new(test.ExampleTable)
	err := c.cc.Invoke(ctx, "/tests.MySpanner/UniaryInsert", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *mySpannerClient) UniarySelect(ctx context.Context, in *test.ExampleTable, opts ...grpc.CallOption) (*test.ExampleTable, error) {
	out := new(test.ExampleTable)
	err := c.cc.Invoke(ctx, "/tests.MySpanner/UniarySelect", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *mySpannerClient) UniarySelectWithDirectives(ctx context.Context, in *test.ExampleTable, opts ...grpc.CallOption) (*test.ExampleTable, error) {
	out := new(test.ExampleTable)
	err := c.cc.Invoke(ctx, "/tests.MySpanner/UniarySelectWithDirectives", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *mySpannerClient) UniaryUpdate(ctx context.Context, in *test.ExampleTable, opts ...grpc.CallOption) (*test.PartialTable, error) {
	out := new(test.PartialTable)
	err := c.cc.Invoke(ctx, "/tests.MySpanner/UniaryUpdate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *mySpannerClient) UniaryDeleteRange(ctx context.Context, in *test.ExampleTableRange, opts ...grpc.CallOption) (*test.ExampleTable, error) {
	out := new(test.ExampleTable)
	err := c.cc.Invoke(ctx, "/tests.MySpanner/UniaryDeleteRange", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *mySpannerClient) ServerStream(ctx context.Context, in *test.Name, opts ...grpc.CallOption) (MySpanner_ServerStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_MySpanner_serviceDesc.Streams[0], "/tests.MySpanner/ServerStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &mySpannerServerStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type MySpanner_ServerStreamClient interface {
	Recv() (*test.ExampleTable, error)
	grpc.ClientStream
}

type mySpannerServerStreamClient struct {
	grpc.ClientStream
}

func (x *mySpannerServerStreamClient) Recv() (*test.ExampleTable, error) {
	m := new(test.ExampleTable)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *mySpannerClient) ClientStreamInsert(ctx context.Context, opts ...grpc.CallOption) (MySpanner_ClientStreamInsertClient, error) {
	stream, err := c.cc.NewStream(ctx, &_MySpanner_serviceDesc.Streams[1], "/tests.MySpanner/ClientStreamInsert", opts...)
	if err != nil {
		return nil, err
	}
	x := &mySpannerClientStreamInsertClient{stream}
	return x, nil
}

type MySpanner_ClientStreamInsertClient interface {
	Send(*test.ExampleTable) error
	CloseAndRecv() (*test.NumRows, error)
	grpc.ClientStream
}

type mySpannerClientStreamInsertClient struct {
	grpc.ClientStream
}

func (x *mySpannerClientStreamInsertClient) Send(m *test.ExampleTable) error {
	return x.ClientStream.SendMsg(m)
}

func (x *mySpannerClientStreamInsertClient) CloseAndRecv() (*test.NumRows, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(test.NumRows)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *mySpannerClient) ClientStreamDelete(ctx context.Context, opts ...grpc.CallOption) (MySpanner_ClientStreamDeleteClient, error) {
	stream, err := c.cc.NewStream(ctx, &_MySpanner_serviceDesc.Streams[2], "/tests.MySpanner/ClientStreamDelete", opts...)
	if err != nil {
		return nil, err
	}
	x := &mySpannerClientStreamDeleteClient{stream}
	return x, nil
}

type MySpanner_ClientStreamDeleteClient interface {
	Send(*test.ExampleTable) error
	CloseAndRecv() (*test.NumRows, error)
	grpc.ClientStream
}

type mySpannerClientStreamDeleteClient struct {
	grpc.ClientStream
}

func (x *mySpannerClientStreamDeleteClient) Send(m *test.ExampleTable) error {
	return x.ClientStream.SendMsg(m)
}

func (x *mySpannerClientStreamDeleteClient) CloseAndRecv() (*test.NumRows, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(test.NumRows)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *mySpannerClient) UniarySelectWithHooks(ctx context.Context, in *test.ExampleTable, opts ...grpc.CallOption) (*test.ExampleTable, error) {
	out := new(test.ExampleTable)
	err := c.cc.Invoke(ctx, "/tests.MySpanner/UniarySelectWithHooks", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *mySpannerClient) ServerStreamWithHooks(ctx context.Context, in *test.Name, opts ...grpc.CallOption) (MySpanner_ServerStreamWithHooksClient, error) {
	stream, err := c.cc.NewStream(ctx, &_MySpanner_serviceDesc.Streams[3], "/tests.MySpanner/ServerStreamWithHooks", opts...)
	if err != nil {
		return nil, err
	}
	x := &mySpannerServerStreamWithHooksClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type MySpanner_ServerStreamWithHooksClient interface {
	Recv() (*test.ExampleTable, error)
	grpc.ClientStream
}

type mySpannerServerStreamWithHooksClient struct {
	grpc.ClientStream
}

func (x *mySpannerServerStreamWithHooksClient) Recv() (*test.ExampleTable, error) {
	m := new(test.ExampleTable)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *mySpannerClient) ClientStreamUpdateWithHooks(ctx context.Context, opts ...grpc.CallOption) (MySpanner_ClientStreamUpdateWithHooksClient, error) {
	stream, err := c.cc.NewStream(ctx, &_MySpanner_serviceDesc.Streams[4], "/tests.MySpanner/ClientStreamUpdateWithHooks", opts...)
	if err != nil {
		return nil, err
	}
	x := &mySpannerClientStreamUpdateWithHooksClient{stream}
	return x, nil
}

type MySpanner_ClientStreamUpdateWithHooksClient interface {
	Send(*test.ExampleTable) error
	CloseAndRecv() (*test.NumRows, error)
	grpc.ClientStream
}

type mySpannerClientStreamUpdateWithHooksClient struct {
	grpc.ClientStream
}

func (x *mySpannerClientStreamUpdateWithHooksClient) Send(m *test.ExampleTable) error {
	return x.ClientStream.SendMsg(m)
}

func (x *mySpannerClientStreamUpdateWithHooksClient) CloseAndRecv() (*test.NumRows, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(test.NumRows)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// MySpannerServer is the server API for MySpanner service.
type MySpannerServer interface {
	UniaryInsert(context.Context, *test.ExampleTable) (*test.ExampleTable, error)
	UniarySelect(context.Context, *test.ExampleTable) (*test.ExampleTable, error)
	UniarySelectWithDirectives(context.Context, *test.ExampleTable) (*test.ExampleTable, error)
	UniaryUpdate(context.Context, *test.ExampleTable) (*test.PartialTable, error)
	UniaryDeleteRange(context.Context, *test.ExampleTableRange) (*test.ExampleTable, error)
	ServerStream(*test.Name, MySpanner_ServerStreamServer) error
	ClientStreamInsert(MySpanner_ClientStreamInsertServer) error
	ClientStreamDelete(MySpanner_ClientStreamDeleteServer) error
	UniarySelectWithHooks(context.Context, *test.ExampleTable) (*test.ExampleTable, error)
	ServerStreamWithHooks(*test.Name, MySpanner_ServerStreamWithHooksServer) error
	ClientStreamUpdateWithHooks(MySpanner_ClientStreamUpdateWithHooksServer) error
}

func RegisterMySpannerServer(s *grpc.Server, srv MySpannerServer) {
	s.RegisterService(&_MySpanner_serviceDesc, srv)
}

func _MySpanner_UniaryInsert_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(test.ExampleTable)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MySpannerServer).UniaryInsert(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tests.MySpanner/UniaryInsert",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MySpannerServer).UniaryInsert(ctx, req.(*test.ExampleTable))
	}
	return interceptor(ctx, in, info, handler)
}

func _MySpanner_UniarySelect_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(test.ExampleTable)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MySpannerServer).UniarySelect(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tests.MySpanner/UniarySelect",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MySpannerServer).UniarySelect(ctx, req.(*test.ExampleTable))
	}
	return interceptor(ctx, in, info, handler)
}

func _MySpanner_UniarySelectWithDirectives_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(test.ExampleTable)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MySpannerServer).UniarySelectWithDirectives(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tests.MySpanner/UniarySelectWithDirectives",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MySpannerServer).UniarySelectWithDirectives(ctx, req.(*test.ExampleTable))
	}
	return interceptor(ctx, in, info, handler)
}

func _MySpanner_UniaryUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(test.ExampleTable)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MySpannerServer).UniaryUpdate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tests.MySpanner/UniaryUpdate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MySpannerServer).UniaryUpdate(ctx, req.(*test.ExampleTable))
	}
	return interceptor(ctx, in, info, handler)
}

func _MySpanner_UniaryDeleteRange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(test.ExampleTableRange)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MySpannerServer).UniaryDeleteRange(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tests.MySpanner/UniaryDeleteRange",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MySpannerServer).UniaryDeleteRange(ctx, req.(*test.ExampleTableRange))
	}
	return interceptor(ctx, in, info, handler)
}

func _MySpanner_ServerStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(test.Name)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(MySpannerServer).ServerStream(m, &mySpannerServerStreamServer{stream})
}

type MySpanner_ServerStreamServer interface {
	Send(*test.ExampleTable) error
	grpc.ServerStream
}

type mySpannerServerStreamServer struct {
	grpc.ServerStream
}

func (x *mySpannerServerStreamServer) Send(m *test.ExampleTable) error {
	return x.ServerStream.SendMsg(m)
}

func _MySpanner_ClientStreamInsert_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(MySpannerServer).ClientStreamInsert(&mySpannerClientStreamInsertServer{stream})
}

type MySpanner_ClientStreamInsertServer interface {
	SendAndClose(*test.NumRows) error
	Recv() (*test.ExampleTable, error)
	grpc.ServerStream
}

type mySpannerClientStreamInsertServer struct {
	grpc.ServerStream
}

func (x *mySpannerClientStreamInsertServer) SendAndClose(m *test.NumRows) error {
	return x.ServerStream.SendMsg(m)
}

func (x *mySpannerClientStreamInsertServer) Recv() (*test.ExampleTable, error) {
	m := new(test.ExampleTable)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _MySpanner_ClientStreamDelete_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(MySpannerServer).ClientStreamDelete(&mySpannerClientStreamDeleteServer{stream})
}

type MySpanner_ClientStreamDeleteServer interface {
	SendAndClose(*test.NumRows) error
	Recv() (*test.ExampleTable, error)
	grpc.ServerStream
}

type mySpannerClientStreamDeleteServer struct {
	grpc.ServerStream
}

func (x *mySpannerClientStreamDeleteServer) SendAndClose(m *test.NumRows) error {
	return x.ServerStream.SendMsg(m)
}

func (x *mySpannerClientStreamDeleteServer) Recv() (*test.ExampleTable, error) {
	m := new(test.ExampleTable)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _MySpanner_UniarySelectWithHooks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(test.ExampleTable)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MySpannerServer).UniarySelectWithHooks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tests.MySpanner/UniarySelectWithHooks",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MySpannerServer).UniarySelectWithHooks(ctx, req.(*test.ExampleTable))
	}
	return interceptor(ctx, in, info, handler)
}

func _MySpanner_ServerStreamWithHooks_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(test.Name)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(MySpannerServer).ServerStreamWithHooks(m, &mySpannerServerStreamWithHooksServer{stream})
}

type MySpanner_ServerStreamWithHooksServer interface {
	Send(*test.ExampleTable) error
	grpc.ServerStream
}

type mySpannerServerStreamWithHooksServer struct {
	grpc.ServerStream
}

func (x *mySpannerServerStreamWithHooksServer) Send(m *test.ExampleTable) error {
	return x.ServerStream.SendMsg(m)
}

func _MySpanner_ClientStreamUpdateWithHooks_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(MySpannerServer).ClientStreamUpdateWithHooks(&mySpannerClientStreamUpdateWithHooksServer{stream})
}

type MySpanner_ClientStreamUpdateWithHooksServer interface {
	SendAndClose(*test.NumRows) error
	Recv() (*test.ExampleTable, error)
	grpc.ServerStream
}

type mySpannerClientStreamUpdateWithHooksServer struct {
	grpc.ServerStream
}

func (x *mySpannerClientStreamUpdateWithHooksServer) SendAndClose(m *test.NumRows) error {
	return x.ServerStream.SendMsg(m)
}

func (x *mySpannerClientStreamUpdateWithHooksServer) Recv() (*test.ExampleTable, error) {
	m := new(test.ExampleTable)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _MySpanner_serviceDesc = grpc.ServiceDesc{
	ServiceName: "tests.MySpanner",
	HandlerType: (*MySpannerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "UniaryInsert",
			Handler:    _MySpanner_UniaryInsert_Handler,
		},
		{
			MethodName: "UniarySelect",
			Handler:    _MySpanner_UniarySelect_Handler,
		},
		{
			MethodName: "UniarySelectWithDirectives",
			Handler:    _MySpanner_UniarySelectWithDirectives_Handler,
		},
		{
			MethodName: "UniaryUpdate",
			Handler:    _MySpanner_UniaryUpdate_Handler,
		},
		{
			MethodName: "UniaryDeleteRange",
			Handler:    _MySpanner_UniaryDeleteRange_Handler,
		},
		{
			MethodName: "UniarySelectWithHooks",
			Handler:    _MySpanner_UniarySelectWithHooks_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ServerStream",
			Handler:       _MySpanner_ServerStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ClientStreamInsert",
			Handler:       _MySpanner_ClientStreamInsert_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "ClientStreamDelete",
			Handler:       _MySpanner_ClientStreamDelete_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "ServerStreamWithHooks",
			Handler:       _MySpanner_ServerStreamWithHooks_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ClientStreamUpdateWithHooks",
			Handler:       _MySpanner_ClientStreamUpdateWithHooks_Handler,
			ClientStreams: true,
		},
	},
	Metadata: "tests/spanner/basic/basic_example.proto",
}