ObjectStore.pb.go

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

package generated

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

type PutObjectRequest struct {
	Plugin string `protobuf:"bytes,1,opt,name=plugin" json:"plugin,omitempty"`
	Bucket string `protobuf:"bytes,2,opt,name=bucket" json:"bucket,omitempty"`
	Key    string `protobuf:"bytes,3,opt,name=key" json:"key,omitempty"`
	Body   []byte `protobuf:"bytes,4,opt,name=body,proto3" json:"body,omitempty"`
}

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

func (m *PutObjectRequest) GetPlugin() string {
	if m != nil {
		return m.Plugin
	}
	return ""
}

func (m *PutObjectRequest) GetBucket() string {
	if m != nil {
		return m.Bucket
	}
	return ""
}

func (m *PutObjectRequest) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *PutObjectRequest) GetBody() []byte {
	if m != nil {
		return m.Body
	}
	return nil
}

type ObjectExistsRequest struct {
	Plugin string `protobuf:"bytes,1,opt,name=plugin" json:"plugin,omitempty"`
	Bucket string `protobuf:"bytes,2,opt,name=bucket" json:"bucket,omitempty"`
	Key    string `protobuf:"bytes,3,opt,name=key" json:"key,omitempty"`
}

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

func (m *ObjectExistsRequest) GetPlugin() string {
	if m != nil {
		return m.Plugin
	}
	return ""
}

func (m *ObjectExistsRequest) GetBucket() string {
	if m != nil {
		return m.Bucket
	}
	return ""
}

func (m *ObjectExistsRequest) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

type ObjectExistsResponse struct {
	Exists bool `protobuf:"varint,1,opt,name=exists" json:"exists,omitempty"`
}

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

func (m *ObjectExistsResponse) GetExists() bool {
	if m != nil {
		return m.Exists
	}
	return false
}

type GetObjectRequest struct {
	Plugin string `protobuf:"bytes,1,opt,name=plugin" json:"plugin,omitempty"`
	Bucket string `protobuf:"bytes,2,opt,name=bucket" json:"bucket,omitempty"`
	Key    string `protobuf:"bytes,3,opt,name=key" json:"key,omitempty"`
}

func (m *GetObjectRequest) Reset()                    { *m = GetObjectRequest{} }
func (m *GetObjectRequest) String() string            { return proto.CompactTextString(m) }
func (*GetObjectRequest) ProtoMessage()               {}
func (*GetObjectRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{3} }

func (m *GetObjectRequest) GetPlugin() string {
	if m != nil {
		return m.Plugin
	}
	return ""
}

func (m *GetObjectRequest) GetBucket() string {
	if m != nil {
		return m.Bucket
	}
	return ""
}

func (m *GetObjectRequest) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

type Bytes struct {
	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
}

func (m *Bytes) Reset()                    { *m = Bytes{} }
func (m *Bytes) String() string            { return proto.CompactTextString(m) }
func (*Bytes) ProtoMessage()               {}
func (*Bytes) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{4} }

func (m *Bytes) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

type ListCommonPrefixesRequest struct {
	Plugin    string `protobuf:"bytes,1,opt,name=plugin" json:"plugin,omitempty"`
	Bucket    string `protobuf:"bytes,2,opt,name=bucket" json:"bucket,omitempty"`
	Delimiter string `protobuf:"bytes,3,opt,name=delimiter" json:"delimiter,omitempty"`
	Prefix    string `protobuf:"bytes,4,opt,name=prefix" json:"prefix,omitempty"`
}

func (m *ListCommonPrefixesRequest) Reset()                    { *m = ListCommonPrefixesRequest{} }
func (m *ListCommonPrefixesRequest) String() string            { return proto.CompactTextString(m) }
func (*ListCommonPrefixesRequest) ProtoMessage()               {}
func (*ListCommonPrefixesRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{5} }

func (m *ListCommonPrefixesRequest) GetPlugin() string {
	if m != nil {
		return m.Plugin
	}
	return ""
}

func (m *ListCommonPrefixesRequest) GetBucket() string {
	if m != nil {
		return m.Bucket
	}
	return ""
}

func (m *ListCommonPrefixesRequest) GetDelimiter() string {
	if m != nil {
		return m.Delimiter
	}
	return ""
}

func (m *ListCommonPrefixesRequest) GetPrefix() string {
	if m != nil {
		return m.Prefix
	}
	return ""
}

type ListCommonPrefixesResponse struct {
	Prefixes []string `protobuf:"bytes,1,rep,name=prefixes" json:"prefixes,omitempty"`
}

func (m *ListCommonPrefixesResponse) Reset()                    { *m = ListCommonPrefixesResponse{} }
func (m *ListCommonPrefixesResponse) String() string            { return proto.CompactTextString(m) }
func (*ListCommonPrefixesResponse) ProtoMessage()               {}
func (*ListCommonPrefixesResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{6} }

func (m *ListCommonPrefixesResponse) GetPrefixes() []string {
	if m != nil {
		return m.Prefixes
	}
	return nil
}

type ListObjectsRequest struct {
	Plugin string `protobuf:"bytes,1,opt,name=plugin" json:"plugin,omitempty"`
	Bucket string `protobuf:"bytes,2,opt,name=bucket" json:"bucket,omitempty"`
	Prefix string `protobuf:"bytes,3,opt,name=prefix" json:"prefix,omitempty"`
}

func (m *ListObjectsRequest) Reset()                    { *m = ListObjectsRequest{} }
func (m *ListObjectsRequest) String() string            { return proto.CompactTextString(m) }
func (*ListObjectsRequest) ProtoMessage()               {}
func (*ListObjectsRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{7} }

func (m *ListObjectsRequest) GetPlugin() string {
	if m != nil {
		return m.Plugin
	}
	return ""
}

func (m *ListObjectsRequest) GetBucket() string {
	if m != nil {
		return m.Bucket
	}
	return ""
}

func (m *ListObjectsRequest) GetPrefix() string {
	if m != nil {
		return m.Prefix
	}
	return ""
}

type ListObjectsResponse struct {
	Keys []string `protobuf:"bytes,1,rep,name=keys" json:"keys,omitempty"`
}

func (m *ListObjectsResponse) Reset()                    { *m = ListObjectsResponse{} }
func (m *ListObjectsResponse) String() string            { return proto.CompactTextString(m) }
func (*ListObjectsResponse) ProtoMessage()               {}
func (*ListObjectsResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{8} }

func (m *ListObjectsResponse) GetKeys() []string {
	if m != nil {
		return m.Keys
	}
	return nil
}

type DeleteObjectRequest struct {
	Plugin string `protobuf:"bytes,1,opt,name=plugin" json:"plugin,omitempty"`
	Bucket string `protobuf:"bytes,2,opt,name=bucket" json:"bucket,omitempty"`
	Key    string `protobuf:"bytes,3,opt,name=key" json:"key,omitempty"`
}

func (m *DeleteObjectRequest) Reset()                    { *m = DeleteObjectRequest{} }
func (m *DeleteObjectRequest) String() string            { return proto.CompactTextString(m) }
func (*DeleteObjectRequest) ProtoMessage()               {}
func (*DeleteObjectRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{9} }

func (m *DeleteObjectRequest) GetPlugin() string {
	if m != nil {
		return m.Plugin
	}
	return ""
}

func (m *DeleteObjectRequest) GetBucket() string {
	if m != nil {
		return m.Bucket
	}
	return ""
}

func (m *DeleteObjectRequest) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

type CreateSignedURLRequest struct {
	Plugin string `protobuf:"bytes,1,opt,name=plugin" json:"plugin,omitempty"`
	Bucket string `protobuf:"bytes,2,opt,name=bucket" json:"bucket,omitempty"`
	Key    string `protobuf:"bytes,3,opt,name=key" json:"key,omitempty"`
	Ttl    int64  `protobuf:"varint,4,opt,name=ttl" json:"ttl,omitempty"`
}

func (m *CreateSignedURLRequest) Reset()                    { *m = CreateSignedURLRequest{} }
func (m *CreateSignedURLRequest) String() string            { return proto.CompactTextString(m) }
func (*CreateSignedURLRequest) ProtoMessage()               {}
func (*CreateSignedURLRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{10} }

func (m *CreateSignedURLRequest) GetPlugin() string {
	if m != nil {
		return m.Plugin
	}
	return ""
}

func (m *CreateSignedURLRequest) GetBucket() string {
	if m != nil {
		return m.Bucket
	}
	return ""
}

func (m *CreateSignedURLRequest) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *CreateSignedURLRequest) GetTtl() int64 {
	if m != nil {
		return m.Ttl
	}
	return 0
}

type CreateSignedURLResponse struct {
	Url string `protobuf:"bytes,1,opt,name=url" json:"url,omitempty"`
}

func (m *CreateSignedURLResponse) Reset()                    { *m = CreateSignedURLResponse{} }
func (m *CreateSignedURLResponse) String() string            { return proto.CompactTextString(m) }
func (*CreateSignedURLResponse) ProtoMessage()               {}
func (*CreateSignedURLResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{11} }

func (m *CreateSignedURLResponse) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

type ObjectStoreInitRequest struct {
	Plugin string            `protobuf:"bytes,1,opt,name=plugin" json:"plugin,omitempty"`
	Config map[string]string `protobuf:"bytes,2,rep,name=config" json:"config,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
}

func (m *ObjectStoreInitRequest) Reset()                    { *m = ObjectStoreInitRequest{} }
func (m *ObjectStoreInitRequest) String() string            { return proto.CompactTextString(m) }
func (*ObjectStoreInitRequest) ProtoMessage()               {}
func (*ObjectStoreInitRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{12} }

func (m *ObjectStoreInitRequest) GetPlugin() string {
	if m != nil {
		return m.Plugin
	}
	return ""
}

func (m *ObjectStoreInitRequest) GetConfig() map[string]string {
	if m != nil {
		return m.Config
	}
	return nil
}

func init() {
	proto.RegisterType((*PutObjectRequest)(nil), "generated.PutObjectRequest")
	proto.RegisterType((*ObjectExistsRequest)(nil), "generated.ObjectExistsRequest")
	proto.RegisterType((*ObjectExistsResponse)(nil), "generated.ObjectExistsResponse")
	proto.RegisterType((*GetObjectRequest)(nil), "generated.GetObjectRequest")
	proto.RegisterType((*Bytes)(nil), "generated.Bytes")
	proto.RegisterType((*ListCommonPrefixesRequest)(nil), "generated.ListCommonPrefixesRequest")
	proto.RegisterType((*ListCommonPrefixesResponse)(nil), "generated.ListCommonPrefixesResponse")
	proto.RegisterType((*ListObjectsRequest)(nil), "generated.ListObjectsRequest")
	proto.RegisterType((*ListObjectsResponse)(nil), "generated.ListObjectsResponse")
	proto.RegisterType((*DeleteObjectRequest)(nil), "generated.DeleteObjectRequest")
	proto.RegisterType((*CreateSignedURLRequest)(nil), "generated.CreateSignedURLRequest")
	proto.RegisterType((*CreateSignedURLResponse)(nil), "generated.CreateSignedURLResponse")
	proto.RegisterType((*ObjectStoreInitRequest)(nil), "generated.ObjectStoreInitRequest")
}

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

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

// Client API for ObjectStore service

type ObjectStoreClient interface {
	Init(ctx context.Context, in *ObjectStoreInitRequest, opts ...grpc.CallOption) (*Empty, error)
	PutObject(ctx context.Context, opts ...grpc.CallOption) (ObjectStore_PutObjectClient, error)
	ObjectExists(ctx context.Context, in *ObjectExistsRequest, opts ...grpc.CallOption) (*ObjectExistsResponse, error)
	GetObject(ctx context.Context, in *GetObjectRequest, opts ...grpc.CallOption) (ObjectStore_GetObjectClient, error)
	ListCommonPrefixes(ctx context.Context, in *ListCommonPrefixesRequest, opts ...grpc.CallOption) (*ListCommonPrefixesResponse, error)
	ListObjects(ctx context.Context, in *ListObjectsRequest, opts ...grpc.CallOption) (*ListObjectsResponse, error)
	DeleteObject(ctx context.Context, in *DeleteObjectRequest, opts ...grpc.CallOption) (*Empty, error)
	CreateSignedURL(ctx context.Context, in *CreateSignedURLRequest, opts ...grpc.CallOption) (*CreateSignedURLResponse, error)
}

type objectStoreClient struct {
	cc *grpc.ClientConn
}

func NewObjectStoreClient(cc *grpc.ClientConn) ObjectStoreClient {
	return &objectStoreClient{cc}
}

func (c *objectStoreClient) Init(ctx context.Context, in *ObjectStoreInitRequest, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := grpc.Invoke(ctx, "/generated.ObjectStore/Init", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *objectStoreClient) PutObject(ctx context.Context, opts ...grpc.CallOption) (ObjectStore_PutObjectClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_ObjectStore_serviceDesc.Streams[0], c.cc, "/generated.ObjectStore/PutObject", opts...)
	if err != nil {
		return nil, err
	}
	x := &objectStorePutObjectClient{stream}
	return x, nil
}

type ObjectStore_PutObjectClient interface {
	Send(*PutObjectRequest) error
	CloseAndRecv() (*Empty, error)
	grpc.ClientStream
}

type objectStorePutObjectClient struct {
	grpc.ClientStream
}

func (x *objectStorePutObjectClient) Send(m *PutObjectRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *objectStoreClient) ObjectExists(ctx context.Context, in *ObjectExistsRequest, opts ...grpc.CallOption) (*ObjectExistsResponse, error) {
	out := new(ObjectExistsResponse)
	err := grpc.Invoke(ctx, "/generated.ObjectStore/ObjectExists", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *objectStoreClient) GetObject(ctx context.Context, in *GetObjectRequest, opts ...grpc.CallOption) (ObjectStore_GetObjectClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_ObjectStore_serviceDesc.Streams[1], c.cc, "/generated.ObjectStore/GetObject", opts...)
	if err != nil {
		return nil, err
	}
	x := &objectStoreGetObjectClient{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 ObjectStore_GetObjectClient interface {
	Recv() (*Bytes, error)
	grpc.ClientStream
}

type objectStoreGetObjectClient struct {
	grpc.ClientStream
}

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

func (c *objectStoreClient) ListCommonPrefixes(ctx context.Context, in *ListCommonPrefixesRequest, opts ...grpc.CallOption) (*ListCommonPrefixesResponse, error) {
	out := new(ListCommonPrefixesResponse)
	err := grpc.Invoke(ctx, "/generated.ObjectStore/ListCommonPrefixes", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *objectStoreClient) ListObjects(ctx context.Context, in *ListObjectsRequest, opts ...grpc.CallOption) (*ListObjectsResponse, error) {
	out := new(ListObjectsResponse)
	err := grpc.Invoke(ctx, "/generated.ObjectStore/ListObjects", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *objectStoreClient) DeleteObject(ctx context.Context, in *DeleteObjectRequest, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := grpc.Invoke(ctx, "/generated.ObjectStore/DeleteObject", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *objectStoreClient) CreateSignedURL(ctx context.Context, in *CreateSignedURLRequest, opts ...grpc.CallOption) (*CreateSignedURLResponse, error) {
	out := new(CreateSignedURLResponse)
	err := grpc.Invoke(ctx, "/generated.ObjectStore/CreateSignedURL", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for ObjectStore service

type ObjectStoreServer interface {
	Init(context.Context, *ObjectStoreInitRequest) (*Empty, error)
	PutObject(ObjectStore_PutObjectServer) error
	ObjectExists(context.Context, *ObjectExistsRequest) (*ObjectExistsResponse, error)
	GetObject(*GetObjectRequest, ObjectStore_GetObjectServer) error
	ListCommonPrefixes(context.Context, *ListCommonPrefixesRequest) (*ListCommonPrefixesResponse, error)
	ListObjects(context.Context, *ListObjectsRequest) (*ListObjectsResponse, error)
	DeleteObject(context.Context, *DeleteObjectRequest) (*Empty, error)
	CreateSignedURL(context.Context, *CreateSignedURLRequest) (*CreateSignedURLResponse, error)
}

func RegisterObjectStoreServer(s *grpc.Server, srv ObjectStoreServer) {
	s.RegisterService(&_ObjectStore_serviceDesc, srv)
}

func _ObjectStore_Init_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ObjectStoreInitRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ObjectStoreServer).Init(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/generated.ObjectStore/Init",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ObjectStoreServer).Init(ctx, req.(*ObjectStoreInitRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ObjectStore_PutObject_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ObjectStoreServer).PutObject(&objectStorePutObjectServer{stream})
}

type ObjectStore_PutObjectServer interface {
	SendAndClose(*Empty) error
	Recv() (*PutObjectRequest, error)
	grpc.ServerStream
}

type objectStorePutObjectServer struct {
	grpc.ServerStream
}

func (x *objectStorePutObjectServer) SendAndClose(m *Empty) error {
	return x.ServerStream.SendMsg(m)
}

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

func _ObjectStore_ObjectExists_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ObjectExistsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ObjectStoreServer).ObjectExists(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/generated.ObjectStore/ObjectExists",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ObjectStoreServer).ObjectExists(ctx, req.(*ObjectExistsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ObjectStore_GetObject_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetObjectRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ObjectStoreServer).GetObject(m, &objectStoreGetObjectServer{stream})
}

type ObjectStore_GetObjectServer interface {
	Send(*Bytes) error
	grpc.ServerStream
}

type objectStoreGetObjectServer struct {
	grpc.ServerStream
}

func (x *objectStoreGetObjectServer) Send(m *Bytes) error {
	return x.ServerStream.SendMsg(m)
}

func _ObjectStore_ListCommonPrefixes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListCommonPrefixesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ObjectStoreServer).ListCommonPrefixes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/generated.ObjectStore/ListCommonPrefixes",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ObjectStoreServer).ListCommonPrefixes(ctx, req.(*ListCommonPrefixesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ObjectStore_ListObjects_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListObjectsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ObjectStoreServer).ListObjects(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/generated.ObjectStore/ListObjects",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ObjectStoreServer).ListObjects(ctx, req.(*ListObjectsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ObjectStore_DeleteObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteObjectRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ObjectStoreServer).DeleteObject(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/generated.ObjectStore/DeleteObject",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ObjectStoreServer).DeleteObject(ctx, req.(*DeleteObjectRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ObjectStore_CreateSignedURL_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateSignedURLRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ObjectStoreServer).CreateSignedURL(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/generated.ObjectStore/CreateSignedURL",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ObjectStoreServer).CreateSignedURL(ctx, req.(*CreateSignedURLRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _ObjectStore_serviceDesc = grpc.ServiceDesc{
	ServiceName: "generated.ObjectStore",
	HandlerType: (*ObjectStoreServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Init",
			Handler:    _ObjectStore_Init_Handler,
		},
		{
			MethodName: "ObjectExists",
			Handler:    _ObjectStore_ObjectExists_Handler,
		},
		{
			MethodName: "ListCommonPrefixes",
			Handler:    _ObjectStore_ListCommonPrefixes_Handler,
		},
		{
			MethodName: "ListObjects",
			Handler:    _ObjectStore_ListObjects_Handler,
		},
		{
			MethodName: "DeleteObject",
			Handler:    _ObjectStore_DeleteObject_Handler,
		},
		{
			MethodName: "CreateSignedURL",
			Handler:    _ObjectStore_CreateSignedURL_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "PutObject",
			Handler:       _ObjectStore_PutObject_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "GetObject",
			Handler:       _ObjectStore_GetObject_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "ObjectStore.proto",
}

func init() { proto.RegisterFile("ObjectStore.proto", fileDescriptor2) }

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