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

package gitalypb

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	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 InfoRefsRequest struct {
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// Parameters to use with git -c (key=value pairs)
	GitConfigOptions []string `protobuf:"bytes,2,rep,name=git_config_options,json=gitConfigOptions,proto3" json:"git_config_options,omitempty"`
	// Git protocol version
	GitProtocol          string   `protobuf:"bytes,3,opt,name=git_protocol,json=gitProtocol,proto3" json:"git_protocol,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_InfoRefsRequest proto.InternalMessageInfo

func (m *InfoRefsRequest) GetRepository() *Repository {
	if m != nil {
		return m.Repository
	}
	return nil
}

func (m *InfoRefsRequest) GetGitConfigOptions() []string {
	if m != nil {
		return m.GitConfigOptions
	}
	return nil
}

func (m *InfoRefsRequest) GetGitProtocol() string {
	if m != nil {
		return m.GitProtocol
	}
	return ""
}

type InfoRefsResponse struct {
	Data                 []byte   `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_InfoRefsResponse proto.InternalMessageInfo

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

type PostUploadPackRequest struct {
	// repository should only be present in the first message of the stream
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// Raw data to be copied to stdin of 'git upload-pack'
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	// Parameters to use with git -c (key=value pairs)
	GitConfigOptions []string `protobuf:"bytes,3,rep,name=git_config_options,json=gitConfigOptions,proto3" json:"git_config_options,omitempty"`
	// Git protocol version
	GitProtocol          string   `protobuf:"bytes,4,opt,name=git_protocol,json=gitProtocol,proto3" json:"git_protocol,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PostUploadPackRequest proto.InternalMessageInfo

func (m *PostUploadPackRequest) GetRepository() *Repository {
	if m != nil {
		return m.Repository
	}
	return nil
}

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

func (m *PostUploadPackRequest) GetGitConfigOptions() []string {
	if m != nil {
		return m.GitConfigOptions
	}
	return nil
}

func (m *PostUploadPackRequest) GetGitProtocol() string {
	if m != nil {
		return m.GitProtocol
	}
	return ""
}

type PostUploadPackResponse struct {
	// Raw data from stdout of 'git upload-pack'
	Data                 []byte   `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PostUploadPackResponse proto.InternalMessageInfo

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

type PostReceivePackRequest struct {
	// repository should only be present in the first message of the stream
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// Raw data to be copied to stdin of 'git receive-pack'
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	// gl_id, gl_repository, and gl_username become env variables, used by the Git {pre,post}-receive
	// hooks. They should only be present in the first message of the stream.
	GlId         string `protobuf:"bytes,3,opt,name=gl_id,json=glId,proto3" json:"gl_id,omitempty"`
	GlRepository string `protobuf:"bytes,4,opt,name=gl_repository,json=glRepository,proto3" json:"gl_repository,omitempty"`
	GlUsername   string `protobuf:"bytes,5,opt,name=gl_username,json=glUsername,proto3" json:"gl_username,omitempty"`
	// Git protocol version
	GitProtocol string `protobuf:"bytes,6,opt,name=git_protocol,json=gitProtocol,proto3" json:"git_protocol,omitempty"`
	// Parameters to use with git -c (key=value pairs)
	GitConfigOptions     []string `protobuf:"bytes,7,rep,name=git_config_options,json=gitConfigOptions,proto3" json:"git_config_options,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PostReceivePackRequest proto.InternalMessageInfo

func (m *PostReceivePackRequest) GetRepository() *Repository {
	if m != nil {
		return m.Repository
	}
	return nil
}

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

func (m *PostReceivePackRequest) GetGlId() string {
	if m != nil {
		return m.GlId
	}
	return ""
}

func (m *PostReceivePackRequest) GetGlRepository() string {
	if m != nil {
		return m.GlRepository
	}
	return ""
}

func (m *PostReceivePackRequest) GetGlUsername() string {
	if m != nil {
		return m.GlUsername
	}
	return ""
}

func (m *PostReceivePackRequest) GetGitProtocol() string {
	if m != nil {
		return m.GitProtocol
	}
	return ""
}

func (m *PostReceivePackRequest) GetGitConfigOptions() []string {
	if m != nil {
		return m.GitConfigOptions
	}
	return nil
}

type PostReceivePackResponse struct {
	// Raw data from stdout of 'git receive-pack'
	Data                 []byte   `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PostReceivePackResponse proto.InternalMessageInfo

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

func init() {
	proto.RegisterType((*InfoRefsRequest)(nil), "gitaly.InfoRefsRequest")
	proto.RegisterType((*InfoRefsResponse)(nil), "gitaly.InfoRefsResponse")
	proto.RegisterType((*PostUploadPackRequest)(nil), "gitaly.PostUploadPackRequest")
	proto.RegisterType((*PostUploadPackResponse)(nil), "gitaly.PostUploadPackResponse")
	proto.RegisterType((*PostReceivePackRequest)(nil), "gitaly.PostReceivePackRequest")
	proto.RegisterType((*PostReceivePackResponse)(nil), "gitaly.PostReceivePackResponse")
}

func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor_7da929f3b109874f) }

var fileDescriptor_7da929f3b109874f = []byte{
	// 463 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x53, 0xcf, 0x6f, 0xd3, 0x30,
	0x14, 0x96, 0xfb, 0x0b, 0xfa, 0x5a, 0x68, 0xf5, 0x26, 0x58, 0x14, 0x09, 0x56, 0x82, 0x84, 0x72,
	0xd8, 0xda, 0x52, 0xfe, 0x03, 0xb8, 0xb0, 0x13, 0x55, 0xd6, 0x5e, 0x38, 0x10, 0xb9, 0x89, 0xeb,
	0x59, 0xb8, 0x71, 0x88, 0xbd, 0x49, 0xbb, 0x72, 0xe6, 0x0c, 0xff, 0x06, 0x7f, 0x1f, 0x27, 0xd4,
	0xb8, 0x59, 0xb6, 0x66, 0x41, 0x08, 0xb4, 0x9b, 0xfd, 0x7e, 0x7c, 0xef, 0xfb, 0x3e, 0x3f, 0xc3,
	0x40, 0x6f, 0x68, 0x66, 0xce, 0x8d, 0x49, 0xc7, 0x69, 0xa6, 0x8c, 0xc2, 0x0e, 0x17, 0x86, 0xca,
	0x2b, 0xb7, 0xaf, 0xcf, 0x69, 0xc6, 0x62, 0x1b, 0xf5, 0xbe, 0x13, 0x18, 0x9c, 0x26, 0x6b, 0x15,
	0xb0, 0xb5, 0x0e, 0xd8, 0x97, 0x0b, 0xa6, 0x0d, 0xce, 0x00, 0x32, 0x96, 0x2a, 0x2d, 0x8c, 0xca,
	0xae, 0x1c, 0x32, 0x22, 0x7e, 0x6f, 0x86, 0x63, 0xdb, 0x3e, 0x0e, 0xae, 0x33, 0xc1, 0x8d, 0x2a,
	0x3c, 0x06, 0xe4, 0xc2, 0x84, 0x91, 0x4a, 0xd6, 0x82, 0x87, 0x2a, 0x35, 0x42, 0x25, 0xda, 0x69,
	0x8c, 0x9a, 0x7e, 0x37, 0x18, 0x72, 0x61, 0xde, 0xe5, 0x89, 0x0f, 0x36, 0x8e, 0x2f, 0xa0, 0xbf,
	0xad, 0xce, 0x29, 0x44, 0x4a, 0x3a, 0xcd, 0x11, 0xf1, 0xbb, 0x41, 0x8f, 0x0b, 0x33, 0xdf, 0x85,
	0xbc, 0x57, 0x30, 0x2c, 0x79, 0xe9, 0x54, 0x25, 0x9a, 0x21, 0x42, 0x2b, 0xa6, 0x86, 0xe6, 0x94,
	0xfa, 0x41, 0x7e, 0xf6, 0x7e, 0x12, 0x78, 0x32, 0x57, 0xda, 0x2c, 0x53, 0xa9, 0x68, 0x3c, 0xa7,
	0xd1, 0xe7, 0xff, 0x91, 0x51, 0x4c, 0x68, 0x94, 0x13, 0x6a, 0xa4, 0x35, 0xff, 0x52, 0x5a, 0xab,
	0x2a, 0xed, 0x18, 0x9e, 0xee, 0x33, 0xfe, 0x83, 0xc0, 0x6f, 0x0d, 0x5b, 0x1e, 0xb0, 0x88, 0x89,
	0x4b, 0x76, 0x1f, 0x0a, 0x0f, 0xa0, 0xcd, 0x65, 0x28, 0xe2, 0xdd, 0x3b, 0xb4, 0xb8, 0x3c, 0x8d,
	0xf1, 0x25, 0x3c, 0xe2, 0x32, 0xbc, 0x81, 0x6f, 0x95, 0xf4, 0xb9, 0x2c, 0x91, 0xf1, 0x08, 0x7a,
	0x5c, 0x86, 0x17, 0x9a, 0x65, 0x09, 0xdd, 0x30, 0xa7, 0x9d, 0x97, 0x00, 0x97, 0xcb, 0x5d, 0xa4,
	0x62, 0x47, 0xa7, 0x62, 0x47, 0x8d, 0xbf, 0x0f, 0xee, 0xf6, 0xd7, 0x3b, 0x81, 0xc3, 0x8a, 0x1b,
	0xf5, 0xee, 0xcd, 0xbe, 0x36, 0x61, 0x78, 0xb6, 0xfd, 0x09, 0xef, 0x17, 0x8b, 0xf9, 0x19, 0xcb,
	0x2e, 0x45, 0xc4, 0x70, 0x01, 0x58, 0xec, 0x56, 0xf9, 0x08, 0x78, 0x58, 0x38, 0xb7, 0xf7, 0x1f,
	0x5c, 0xa7, 0x9a, 0xb0, 0x13, 0xbd, 0xee, 0xaf, 0x1f, 0x7e, 0xfb, 0x61, 0xc3, 0x25, 0xaf, 0xa7,
	0x04, 0x97, 0x70, 0x50, 0x16, 0x5c, 0xb3, 0xfb, 0x77, 0x58, 0x62, 0x61, 0x3f, 0xc1, 0xe3, 0xdb,
	0xdb, 0x82, 0xcf, 0x8a, 0xc6, 0x3b, 0xf7, 0xde, 0x7d, 0x5e, 0x97, 0xae, 0x90, 0xf6, 0xc9, 0x94,
	0x20, 0x85, 0xc1, 0x9e, 0xa1, 0x78, 0x0b, 0xa1, 0xba, 0x77, 0xee, 0x51, 0x6d, 0xbe, 0x22, 0x60,
	0x3b, 0xe2, 0xed, 0xf4, 0xe3, 0xb6, 0x41, 0xd2, 0xd5, 0x38, 0x52, 0x9b, 0x89, 0x3d, 0x9e, 0xa8,
	0x8c, 0x4f, 0x2c, 0xcc, 0x24, 0xdf, 0x8e, 0x09, 0x57, 0xbb, 0x7b, 0xba, 0x5a, 0x75, 0xf2, 0xd0,
	0x9b, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x19, 0x26, 0xb8, 0xcb, 0xc6, 0x04, 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

// SmartHTTPServiceClient is the client API for SmartHTTPService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type SmartHTTPServiceClient interface {
	// The response body for GET /info/refs?service=git-upload-pack
	// Will be invoked when the user executes a `git fetch`, meaning the server
	// will upload the packs to that user. The user doesn't upload new objects.
	InfoRefsUploadPack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTPService_InfoRefsUploadPackClient, error)
	// The response body for GET /info/refs?service=git-receive-pack
	// Will be invoked when the user executes a `git push`, meaning the server
	// will receive new objects in the pack from the user.
	InfoRefsReceivePack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTPService_InfoRefsReceivePackClient, error)
	// Request and response body for POST /upload-pack
	PostUploadPack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTPService_PostUploadPackClient, error)
	// Request and response body for POST /receive-pack
	PostReceivePack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTPService_PostReceivePackClient, error)
}

type smartHTTPServiceClient struct {
	cc *grpc.ClientConn
}

func NewSmartHTTPServiceClient(cc *grpc.ClientConn) SmartHTTPServiceClient {
	return &smartHTTPServiceClient{cc}
}

func (c *smartHTTPServiceClient) InfoRefsUploadPack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTPService_InfoRefsUploadPackClient, error) {
	stream, err := c.cc.NewStream(ctx, &_SmartHTTPService_serviceDesc.Streams[0], "/gitaly.SmartHTTPService/InfoRefsUploadPack", opts...)
	if err != nil {
		return nil, err
	}
	x := &smartHTTPServiceInfoRefsUploadPackClient{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 SmartHTTPService_InfoRefsUploadPackClient interface {
	Recv() (*InfoRefsResponse, error)
	grpc.ClientStream
}

type smartHTTPServiceInfoRefsUploadPackClient struct {
	grpc.ClientStream
}

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

func (c *smartHTTPServiceClient) InfoRefsReceivePack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTPService_InfoRefsReceivePackClient, error) {
	stream, err := c.cc.NewStream(ctx, &_SmartHTTPService_serviceDesc.Streams[1], "/gitaly.SmartHTTPService/InfoRefsReceivePack", opts...)
	if err != nil {
		return nil, err
	}
	x := &smartHTTPServiceInfoRefsReceivePackClient{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 SmartHTTPService_InfoRefsReceivePackClient interface {
	Recv() (*InfoRefsResponse, error)
	grpc.ClientStream
}

type smartHTTPServiceInfoRefsReceivePackClient struct {
	grpc.ClientStream
}

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

func (c *smartHTTPServiceClient) PostUploadPack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTPService_PostUploadPackClient, error) {
	stream, err := c.cc.NewStream(ctx, &_SmartHTTPService_serviceDesc.Streams[2], "/gitaly.SmartHTTPService/PostUploadPack", opts...)
	if err != nil {
		return nil, err
	}
	x := &smartHTTPServicePostUploadPackClient{stream}
	return x, nil
}

type SmartHTTPService_PostUploadPackClient interface {
	Send(*PostUploadPackRequest) error
	Recv() (*PostUploadPackResponse, error)
	grpc.ClientStream
}

type smartHTTPServicePostUploadPackClient struct {
	grpc.ClientStream
}

func (x *smartHTTPServicePostUploadPackClient) Send(m *PostUploadPackRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *smartHTTPServiceClient) PostReceivePack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTPService_PostReceivePackClient, error) {
	stream, err := c.cc.NewStream(ctx, &_SmartHTTPService_serviceDesc.Streams[3], "/gitaly.SmartHTTPService/PostReceivePack", opts...)
	if err != nil {
		return nil, err
	}
	x := &smartHTTPServicePostReceivePackClient{stream}
	return x, nil
}

type SmartHTTPService_PostReceivePackClient interface {
	Send(*PostReceivePackRequest) error
	Recv() (*PostReceivePackResponse, error)
	grpc.ClientStream
}

type smartHTTPServicePostReceivePackClient struct {
	grpc.ClientStream
}

func (x *smartHTTPServicePostReceivePackClient) Send(m *PostReceivePackRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

// SmartHTTPServiceServer is the server API for SmartHTTPService service.
type SmartHTTPServiceServer interface {
	// The response body for GET /info/refs?service=git-upload-pack
	// Will be invoked when the user executes a `git fetch`, meaning the server
	// will upload the packs to that user. The user doesn't upload new objects.
	InfoRefsUploadPack(*InfoRefsRequest, SmartHTTPService_InfoRefsUploadPackServer) error
	// The response body for GET /info/refs?service=git-receive-pack
	// Will be invoked when the user executes a `git push`, meaning the server
	// will receive new objects in the pack from the user.
	InfoRefsReceivePack(*InfoRefsRequest, SmartHTTPService_InfoRefsReceivePackServer) error
	// Request and response body for POST /upload-pack
	PostUploadPack(SmartHTTPService_PostUploadPackServer) error
	// Request and response body for POST /receive-pack
	PostReceivePack(SmartHTTPService_PostReceivePackServer) error
}

// UnimplementedSmartHTTPServiceServer can be embedded to have forward compatible implementations.
type UnimplementedSmartHTTPServiceServer struct {
}

func (*UnimplementedSmartHTTPServiceServer) InfoRefsUploadPack(req *InfoRefsRequest, srv SmartHTTPService_InfoRefsUploadPackServer) error {
	return status.Errorf(codes.Unimplemented, "method InfoRefsUploadPack not implemented")
}
func (*UnimplementedSmartHTTPServiceServer) InfoRefsReceivePack(req *InfoRefsRequest, srv SmartHTTPService_InfoRefsReceivePackServer) error {
	return status.Errorf(codes.Unimplemented, "method InfoRefsReceivePack not implemented")
}
func (*UnimplementedSmartHTTPServiceServer) PostUploadPack(srv SmartHTTPService_PostUploadPackServer) error {
	return status.Errorf(codes.Unimplemented, "method PostUploadPack not implemented")
}
func (*UnimplementedSmartHTTPServiceServer) PostReceivePack(srv SmartHTTPService_PostReceivePackServer) error {
	return status.Errorf(codes.Unimplemented, "method PostReceivePack not implemented")
}

func RegisterSmartHTTPServiceServer(s *grpc.Server, srv SmartHTTPServiceServer) {
	s.RegisterService(&_SmartHTTPService_serviceDesc, srv)
}

func _SmartHTTPService_InfoRefsUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InfoRefsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SmartHTTPServiceServer).InfoRefsUploadPack(m, &smartHTTPServiceInfoRefsUploadPackServer{stream})
}

type SmartHTTPService_InfoRefsUploadPackServer interface {
	Send(*InfoRefsResponse) error
	grpc.ServerStream
}

type smartHTTPServiceInfoRefsUploadPackServer struct {
	grpc.ServerStream
}

func (x *smartHTTPServiceInfoRefsUploadPackServer) Send(m *InfoRefsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _SmartHTTPService_InfoRefsReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InfoRefsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SmartHTTPServiceServer).InfoRefsReceivePack(m, &smartHTTPServiceInfoRefsReceivePackServer{stream})
}

type SmartHTTPService_InfoRefsReceivePackServer interface {
	Send(*InfoRefsResponse) error
	grpc.ServerStream
}

type smartHTTPServiceInfoRefsReceivePackServer struct {
	grpc.ServerStream
}

func (x *smartHTTPServiceInfoRefsReceivePackServer) Send(m *InfoRefsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _SmartHTTPService_PostUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(SmartHTTPServiceServer).PostUploadPack(&smartHTTPServicePostUploadPackServer{stream})
}

type SmartHTTPService_PostUploadPackServer interface {
	Send(*PostUploadPackResponse) error
	Recv() (*PostUploadPackRequest, error)
	grpc.ServerStream
}

type smartHTTPServicePostUploadPackServer struct {
	grpc.ServerStream
}

func (x *smartHTTPServicePostUploadPackServer) Send(m *PostUploadPackResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _SmartHTTPService_PostReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(SmartHTTPServiceServer).PostReceivePack(&smartHTTPServicePostReceivePackServer{stream})
}

type SmartHTTPService_PostReceivePackServer interface {
	Send(*PostReceivePackResponse) error
	Recv() (*PostReceivePackRequest, error)
	grpc.ServerStream
}

type smartHTTPServicePostReceivePackServer struct {
	grpc.ServerStream
}

func (x *smartHTTPServicePostReceivePackServer) Send(m *PostReceivePackResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

var _SmartHTTPService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "gitaly.SmartHTTPService",
	HandlerType: (*SmartHTTPServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "InfoRefsUploadPack",
			Handler:       _SmartHTTPService_InfoRefsUploadPack_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "InfoRefsReceivePack",
			Handler:       _SmartHTTPService_InfoRefsReceivePack_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "PostUploadPack",
			Handler:       _SmartHTTPService_PostUploadPack_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "PostReceivePack",
			Handler:       _SmartHTTPService_PostReceivePack_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "smarthttp.proto",
}
