// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.2.0
// - protoc             v3.21.1
// source: commit.proto

package gitalypb

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

// CommitServiceClient is the client API for CommitService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type CommitServiceClient interface {
	// ListCommits lists all commits reachable via a set of references by doing a
	// graph walk. This deprecates FindAllCommits and FindCommits (except Follow
	// is not yet supported). Any unknown revisions will cause the RPC to fail.
	ListCommits(ctx context.Context, in *ListCommitsRequest, opts ...grpc.CallOption) (CommitService_ListCommitsClient, error)
	// ListAllCommits lists all commits present in the repository, including
	// those not reachable by any reference.
	ListAllCommits(ctx context.Context, in *ListAllCommitsRequest, opts ...grpc.CallOption) (CommitService_ListAllCommitsClient, error)
	// This comment is left unintentionally blank.
	CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error)
	// This comment is left unintentionally blank.
	TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (CommitService_TreeEntryClient, error)
	// This comment is left unintentionally blank.
	CountCommits(ctx context.Context, in *CountCommitsRequest, opts ...grpc.CallOption) (*CountCommitsResponse, error)
	// This comment is left unintentionally blank.
	CountDivergingCommits(ctx context.Context, in *CountDivergingCommitsRequest, opts ...grpc.CallOption) (*CountDivergingCommitsResponse, error)
	// This comment is left unintentionally blank.
	GetTreeEntries(ctx context.Context, in *GetTreeEntriesRequest, opts ...grpc.CallOption) (CommitService_GetTreeEntriesClient, error)
	// This comment is left unintentionally blank.
	ListFiles(ctx context.Context, in *ListFilesRequest, opts ...grpc.CallOption) (CommitService_ListFilesClient, error)
	// This comment is left unintentionally blank.
	FindCommit(ctx context.Context, in *FindCommitRequest, opts ...grpc.CallOption) (*FindCommitResponse, error)
	// This comment is left unintentionally blank.
	CommitStats(ctx context.Context, in *CommitStatsRequest, opts ...grpc.CallOption) (*CommitStatsResponse, error)
	// Use a stream to paginate the result set
	FindAllCommits(ctx context.Context, in *FindAllCommitsRequest, opts ...grpc.CallOption) (CommitService_FindAllCommitsClient, error)
	// This comment is left unintentionally blank.
	FindCommits(ctx context.Context, in *FindCommitsRequest, opts ...grpc.CallOption) (CommitService_FindCommitsClient, error)
	// CommitLanguages detects the source code languages of the whole tree for a
	// given commit. Returns an error in case no languages could be detected.
	CommitLanguages(ctx context.Context, in *CommitLanguagesRequest, opts ...grpc.CallOption) (*CommitLanguagesResponse, error)
	// This comment is left unintentionally blank.
	RawBlame(ctx context.Context, in *RawBlameRequest, opts ...grpc.CallOption) (CommitService_RawBlameClient, error)
	// This comment is left unintentionally blank.
	LastCommitForPath(ctx context.Context, in *LastCommitForPathRequest, opts ...grpc.CallOption) (*LastCommitForPathResponse, error)
	// This comment is left unintentionally blank.
	ListLastCommitsForTree(ctx context.Context, in *ListLastCommitsForTreeRequest, opts ...grpc.CallOption) (CommitService_ListLastCommitsForTreeClient, error)
	// This comment is left unintentionally blank.
	CommitsByMessage(ctx context.Context, in *CommitsByMessageRequest, opts ...grpc.CallOption) (CommitService_CommitsByMessageClient, error)
	// This comment is left unintentionally blank.
	ListCommitsByOid(ctx context.Context, in *ListCommitsByOidRequest, opts ...grpc.CallOption) (CommitService_ListCommitsByOidClient, error)
	// This comment is left unintentionally blank.
	ListCommitsByRefName(ctx context.Context, in *ListCommitsByRefNameRequest, opts ...grpc.CallOption) (CommitService_ListCommitsByRefNameClient, error)
	// This comment is left unintentionally blank.
	FilterShasWithSignatures(ctx context.Context, opts ...grpc.CallOption) (CommitService_FilterShasWithSignaturesClient, error)
	// This comment is left unintentionally blank.
	GetCommitSignatures(ctx context.Context, in *GetCommitSignaturesRequest, opts ...grpc.CallOption) (CommitService_GetCommitSignaturesClient, error)
	// This comment is left unintentionally blank.
	GetCommitMessages(ctx context.Context, in *GetCommitMessagesRequest, opts ...grpc.CallOption) (CommitService_GetCommitMessagesClient, error)
	// CheckObjectsExist will check for the existence of revisions against a
	// repository. It returns two sets of data. An array containing the revisions
	// fromm the input that it found on the repository, and an array that contains all
	// revisions from the input it did not find on the repository.
	CheckObjectsExist(ctx context.Context, opts ...grpc.CallOption) (CommitService_CheckObjectsExistClient, error)
}

type commitServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewCommitServiceClient(cc grpc.ClientConnInterface) CommitServiceClient {
	return &commitServiceClient{cc}
}

func (c *commitServiceClient) ListCommits(ctx context.Context, in *ListCommitsRequest, opts ...grpc.CallOption) (CommitService_ListCommitsClient, error) {
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[0], "/gitaly.CommitService/ListCommits", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceListCommitsClient{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 CommitService_ListCommitsClient interface {
	Recv() (*ListCommitsResponse, error)
	grpc.ClientStream
}

type commitServiceListCommitsClient struct {
	grpc.ClientStream
}

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

func (c *commitServiceClient) ListAllCommits(ctx context.Context, in *ListAllCommitsRequest, opts ...grpc.CallOption) (CommitService_ListAllCommitsClient, error) {
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[1], "/gitaly.CommitService/ListAllCommits", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceListAllCommitsClient{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 CommitService_ListAllCommitsClient interface {
	Recv() (*ListAllCommitsResponse, error)
	grpc.ClientStream
}

type commitServiceListAllCommitsClient struct {
	grpc.ClientStream
}

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

func (c *commitServiceClient) CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error) {
	out := new(CommitIsAncestorResponse)
	err := c.cc.Invoke(ctx, "/gitaly.CommitService/CommitIsAncestor", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (CommitService_TreeEntryClient, error) {
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[2], "/gitaly.CommitService/TreeEntry", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceTreeEntryClient{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 CommitService_TreeEntryClient interface {
	Recv() (*TreeEntryResponse, error)
	grpc.ClientStream
}

type commitServiceTreeEntryClient struct {
	grpc.ClientStream
}

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

func (c *commitServiceClient) CountCommits(ctx context.Context, in *CountCommitsRequest, opts ...grpc.CallOption) (*CountCommitsResponse, error) {
	out := new(CountCommitsResponse)
	err := c.cc.Invoke(ctx, "/gitaly.CommitService/CountCommits", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) CountDivergingCommits(ctx context.Context, in *CountDivergingCommitsRequest, opts ...grpc.CallOption) (*CountDivergingCommitsResponse, error) {
	out := new(CountDivergingCommitsResponse)
	err := c.cc.Invoke(ctx, "/gitaly.CommitService/CountDivergingCommits", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) GetTreeEntries(ctx context.Context, in *GetTreeEntriesRequest, opts ...grpc.CallOption) (CommitService_GetTreeEntriesClient, error) {
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[3], "/gitaly.CommitService/GetTreeEntries", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceGetTreeEntriesClient{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 CommitService_GetTreeEntriesClient interface {
	Recv() (*GetTreeEntriesResponse, error)
	grpc.ClientStream
}

type commitServiceGetTreeEntriesClient struct {
	grpc.ClientStream
}

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

func (c *commitServiceClient) ListFiles(ctx context.Context, in *ListFilesRequest, opts ...grpc.CallOption) (CommitService_ListFilesClient, error) {
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[4], "/gitaly.CommitService/ListFiles", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceListFilesClient{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 CommitService_ListFilesClient interface {
	Recv() (*ListFilesResponse, error)
	grpc.ClientStream
}

type commitServiceListFilesClient struct {
	grpc.ClientStream
}

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

func (c *commitServiceClient) FindCommit(ctx context.Context, in *FindCommitRequest, opts ...grpc.CallOption) (*FindCommitResponse, error) {
	out := new(FindCommitResponse)
	err := c.cc.Invoke(ctx, "/gitaly.CommitService/FindCommit", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) CommitStats(ctx context.Context, in *CommitStatsRequest, opts ...grpc.CallOption) (*CommitStatsResponse, error) {
	out := new(CommitStatsResponse)
	err := c.cc.Invoke(ctx, "/gitaly.CommitService/CommitStats", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) FindAllCommits(ctx context.Context, in *FindAllCommitsRequest, opts ...grpc.CallOption) (CommitService_FindAllCommitsClient, error) {
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[5], "/gitaly.CommitService/FindAllCommits", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceFindAllCommitsClient{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 CommitService_FindAllCommitsClient interface {
	Recv() (*FindAllCommitsResponse, error)
	grpc.ClientStream
}

type commitServiceFindAllCommitsClient struct {
	grpc.ClientStream
}

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

func (c *commitServiceClient) FindCommits(ctx context.Context, in *FindCommitsRequest, opts ...grpc.CallOption) (CommitService_FindCommitsClient, error) {
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[6], "/gitaly.CommitService/FindCommits", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceFindCommitsClient{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 CommitService_FindCommitsClient interface {
	Recv() (*FindCommitsResponse, error)
	grpc.ClientStream
}

type commitServiceFindCommitsClient struct {
	grpc.ClientStream
}

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

func (c *commitServiceClient) CommitLanguages(ctx context.Context, in *CommitLanguagesRequest, opts ...grpc.CallOption) (*CommitLanguagesResponse, error) {
	out := new(CommitLanguagesResponse)
	err := c.cc.Invoke(ctx, "/gitaly.CommitService/CommitLanguages", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) RawBlame(ctx context.Context, in *RawBlameRequest, opts ...grpc.CallOption) (CommitService_RawBlameClient, error) {
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[7], "/gitaly.CommitService/RawBlame", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceRawBlameClient{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 CommitService_RawBlameClient interface {
	Recv() (*RawBlameResponse, error)
	grpc.ClientStream
}

type commitServiceRawBlameClient struct {
	grpc.ClientStream
}

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

func (c *commitServiceClient) LastCommitForPath(ctx context.Context, in *LastCommitForPathRequest, opts ...grpc.CallOption) (*LastCommitForPathResponse, error) {
	out := new(LastCommitForPathResponse)
	err := c.cc.Invoke(ctx, "/gitaly.CommitService/LastCommitForPath", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) ListLastCommitsForTree(ctx context.Context, in *ListLastCommitsForTreeRequest, opts ...grpc.CallOption) (CommitService_ListLastCommitsForTreeClient, error) {
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[8], "/gitaly.CommitService/ListLastCommitsForTree", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceListLastCommitsForTreeClient{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 CommitService_ListLastCommitsForTreeClient interface {
	Recv() (*ListLastCommitsForTreeResponse, error)
	grpc.ClientStream
}

type commitServiceListLastCommitsForTreeClient struct {
	grpc.ClientStream
}

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

func (c *commitServiceClient) CommitsByMessage(ctx context.Context, in *CommitsByMessageRequest, opts ...grpc.CallOption) (CommitService_CommitsByMessageClient, error) {
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[9], "/gitaly.CommitService/CommitsByMessage", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceCommitsByMessageClient{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 CommitService_CommitsByMessageClient interface {
	Recv() (*CommitsByMessageResponse, error)
	grpc.ClientStream
}

type commitServiceCommitsByMessageClient struct {
	grpc.ClientStream
}

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

func (c *commitServiceClient) ListCommitsByOid(ctx context.Context, in *ListCommitsByOidRequest, opts ...grpc.CallOption) (CommitService_ListCommitsByOidClient, error) {
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[10], "/gitaly.CommitService/ListCommitsByOid", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceListCommitsByOidClient{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 CommitService_ListCommitsByOidClient interface {
	Recv() (*ListCommitsByOidResponse, error)
	grpc.ClientStream
}

type commitServiceListCommitsByOidClient struct {
	grpc.ClientStream
}

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

func (c *commitServiceClient) ListCommitsByRefName(ctx context.Context, in *ListCommitsByRefNameRequest, opts ...grpc.CallOption) (CommitService_ListCommitsByRefNameClient, error) {
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[11], "/gitaly.CommitService/ListCommitsByRefName", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceListCommitsByRefNameClient{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 CommitService_ListCommitsByRefNameClient interface {
	Recv() (*ListCommitsByRefNameResponse, error)
	grpc.ClientStream
}

type commitServiceListCommitsByRefNameClient struct {
	grpc.ClientStream
}

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

func (c *commitServiceClient) FilterShasWithSignatures(ctx context.Context, opts ...grpc.CallOption) (CommitService_FilterShasWithSignaturesClient, error) {
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[12], "/gitaly.CommitService/FilterShasWithSignatures", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceFilterShasWithSignaturesClient{stream}
	return x, nil
}

type CommitService_FilterShasWithSignaturesClient interface {
	Send(*FilterShasWithSignaturesRequest) error
	Recv() (*FilterShasWithSignaturesResponse, error)
	grpc.ClientStream
}

type commitServiceFilterShasWithSignaturesClient struct {
	grpc.ClientStream
}

func (x *commitServiceFilterShasWithSignaturesClient) Send(m *FilterShasWithSignaturesRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *commitServiceClient) GetCommitSignatures(ctx context.Context, in *GetCommitSignaturesRequest, opts ...grpc.CallOption) (CommitService_GetCommitSignaturesClient, error) {
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[13], "/gitaly.CommitService/GetCommitSignatures", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceGetCommitSignaturesClient{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 CommitService_GetCommitSignaturesClient interface {
	Recv() (*GetCommitSignaturesResponse, error)
	grpc.ClientStream
}

type commitServiceGetCommitSignaturesClient struct {
	grpc.ClientStream
}

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

func (c *commitServiceClient) GetCommitMessages(ctx context.Context, in *GetCommitMessagesRequest, opts ...grpc.CallOption) (CommitService_GetCommitMessagesClient, error) {
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[14], "/gitaly.CommitService/GetCommitMessages", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceGetCommitMessagesClient{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 CommitService_GetCommitMessagesClient interface {
	Recv() (*GetCommitMessagesResponse, error)
	grpc.ClientStream
}

type commitServiceGetCommitMessagesClient struct {
	grpc.ClientStream
}

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

func (c *commitServiceClient) CheckObjectsExist(ctx context.Context, opts ...grpc.CallOption) (CommitService_CheckObjectsExistClient, error) {
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[15], "/gitaly.CommitService/CheckObjectsExist", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceCheckObjectsExistClient{stream}
	return x, nil
}

type CommitService_CheckObjectsExistClient interface {
	Send(*CheckObjectsExistRequest) error
	Recv() (*CheckObjectsExistResponse, error)
	grpc.ClientStream
}

type commitServiceCheckObjectsExistClient struct {
	grpc.ClientStream
}

func (x *commitServiceCheckObjectsExistClient) Send(m *CheckObjectsExistRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

// CommitServiceServer is the server API for CommitService service.
// All implementations must embed UnimplementedCommitServiceServer
// for forward compatibility
type CommitServiceServer interface {
	// ListCommits lists all commits reachable via a set of references by doing a
	// graph walk. This deprecates FindAllCommits and FindCommits (except Follow
	// is not yet supported). Any unknown revisions will cause the RPC to fail.
	ListCommits(*ListCommitsRequest, CommitService_ListCommitsServer) error
	// ListAllCommits lists all commits present in the repository, including
	// those not reachable by any reference.
	ListAllCommits(*ListAllCommitsRequest, CommitService_ListAllCommitsServer) error
	// This comment is left unintentionally blank.
	CommitIsAncestor(context.Context, *CommitIsAncestorRequest) (*CommitIsAncestorResponse, error)
	// This comment is left unintentionally blank.
	TreeEntry(*TreeEntryRequest, CommitService_TreeEntryServer) error
	// This comment is left unintentionally blank.
	CountCommits(context.Context, *CountCommitsRequest) (*CountCommitsResponse, error)
	// This comment is left unintentionally blank.
	CountDivergingCommits(context.Context, *CountDivergingCommitsRequest) (*CountDivergingCommitsResponse, error)
	// This comment is left unintentionally blank.
	GetTreeEntries(*GetTreeEntriesRequest, CommitService_GetTreeEntriesServer) error
	// This comment is left unintentionally blank.
	ListFiles(*ListFilesRequest, CommitService_ListFilesServer) error
	// This comment is left unintentionally blank.
	FindCommit(context.Context, *FindCommitRequest) (*FindCommitResponse, error)
	// This comment is left unintentionally blank.
	CommitStats(context.Context, *CommitStatsRequest) (*CommitStatsResponse, error)
	// Use a stream to paginate the result set
	FindAllCommits(*FindAllCommitsRequest, CommitService_FindAllCommitsServer) error
	// This comment is left unintentionally blank.
	FindCommits(*FindCommitsRequest, CommitService_FindCommitsServer) error
	// CommitLanguages detects the source code languages of the whole tree for a
	// given commit. Returns an error in case no languages could be detected.
	CommitLanguages(context.Context, *CommitLanguagesRequest) (*CommitLanguagesResponse, error)
	// This comment is left unintentionally blank.
	RawBlame(*RawBlameRequest, CommitService_RawBlameServer) error
	// This comment is left unintentionally blank.
	LastCommitForPath(context.Context, *LastCommitForPathRequest) (*LastCommitForPathResponse, error)
	// This comment is left unintentionally blank.
	ListLastCommitsForTree(*ListLastCommitsForTreeRequest, CommitService_ListLastCommitsForTreeServer) error
	// This comment is left unintentionally blank.
	CommitsByMessage(*CommitsByMessageRequest, CommitService_CommitsByMessageServer) error
	// This comment is left unintentionally blank.
	ListCommitsByOid(*ListCommitsByOidRequest, CommitService_ListCommitsByOidServer) error
	// This comment is left unintentionally blank.
	ListCommitsByRefName(*ListCommitsByRefNameRequest, CommitService_ListCommitsByRefNameServer) error
	// This comment is left unintentionally blank.
	FilterShasWithSignatures(CommitService_FilterShasWithSignaturesServer) error
	// This comment is left unintentionally blank.
	GetCommitSignatures(*GetCommitSignaturesRequest, CommitService_GetCommitSignaturesServer) error
	// This comment is left unintentionally blank.
	GetCommitMessages(*GetCommitMessagesRequest, CommitService_GetCommitMessagesServer) error
	// CheckObjectsExist will check for the existence of revisions against a
	// repository. It returns two sets of data. An array containing the revisions
	// fromm the input that it found on the repository, and an array that contains all
	// revisions from the input it did not find on the repository.
	CheckObjectsExist(CommitService_CheckObjectsExistServer) error
	mustEmbedUnimplementedCommitServiceServer()
}

// UnimplementedCommitServiceServer must be embedded to have forward compatible implementations.
type UnimplementedCommitServiceServer struct {
}

func (UnimplementedCommitServiceServer) ListCommits(*ListCommitsRequest, CommitService_ListCommitsServer) error {
	return status.Errorf(codes.Unimplemented, "method ListCommits not implemented")
}
func (UnimplementedCommitServiceServer) ListAllCommits(*ListAllCommitsRequest, CommitService_ListAllCommitsServer) error {
	return status.Errorf(codes.Unimplemented, "method ListAllCommits not implemented")
}
func (UnimplementedCommitServiceServer) CommitIsAncestor(context.Context, *CommitIsAncestorRequest) (*CommitIsAncestorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CommitIsAncestor not implemented")
}
func (UnimplementedCommitServiceServer) TreeEntry(*TreeEntryRequest, CommitService_TreeEntryServer) error {
	return status.Errorf(codes.Unimplemented, "method TreeEntry not implemented")
}
func (UnimplementedCommitServiceServer) CountCommits(context.Context, *CountCommitsRequest) (*CountCommitsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CountCommits not implemented")
}
func (UnimplementedCommitServiceServer) CountDivergingCommits(context.Context, *CountDivergingCommitsRequest) (*CountDivergingCommitsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CountDivergingCommits not implemented")
}
func (UnimplementedCommitServiceServer) GetTreeEntries(*GetTreeEntriesRequest, CommitService_GetTreeEntriesServer) error {
	return status.Errorf(codes.Unimplemented, "method GetTreeEntries not implemented")
}
func (UnimplementedCommitServiceServer) ListFiles(*ListFilesRequest, CommitService_ListFilesServer) error {
	return status.Errorf(codes.Unimplemented, "method ListFiles not implemented")
}
func (UnimplementedCommitServiceServer) FindCommit(context.Context, *FindCommitRequest) (*FindCommitResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FindCommit not implemented")
}
func (UnimplementedCommitServiceServer) CommitStats(context.Context, *CommitStatsRequest) (*CommitStatsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CommitStats not implemented")
}
func (UnimplementedCommitServiceServer) FindAllCommits(*FindAllCommitsRequest, CommitService_FindAllCommitsServer) error {
	return status.Errorf(codes.Unimplemented, "method FindAllCommits not implemented")
}
func (UnimplementedCommitServiceServer) FindCommits(*FindCommitsRequest, CommitService_FindCommitsServer) error {
	return status.Errorf(codes.Unimplemented, "method FindCommits not implemented")
}
func (UnimplementedCommitServiceServer) CommitLanguages(context.Context, *CommitLanguagesRequest) (*CommitLanguagesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CommitLanguages not implemented")
}
func (UnimplementedCommitServiceServer) RawBlame(*RawBlameRequest, CommitService_RawBlameServer) error {
	return status.Errorf(codes.Unimplemented, "method RawBlame not implemented")
}
func (UnimplementedCommitServiceServer) LastCommitForPath(context.Context, *LastCommitForPathRequest) (*LastCommitForPathResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LastCommitForPath not implemented")
}
func (UnimplementedCommitServiceServer) ListLastCommitsForTree(*ListLastCommitsForTreeRequest, CommitService_ListLastCommitsForTreeServer) error {
	return status.Errorf(codes.Unimplemented, "method ListLastCommitsForTree not implemented")
}
func (UnimplementedCommitServiceServer) CommitsByMessage(*CommitsByMessageRequest, CommitService_CommitsByMessageServer) error {
	return status.Errorf(codes.Unimplemented, "method CommitsByMessage not implemented")
}
func (UnimplementedCommitServiceServer) ListCommitsByOid(*ListCommitsByOidRequest, CommitService_ListCommitsByOidServer) error {
	return status.Errorf(codes.Unimplemented, "method ListCommitsByOid not implemented")
}
func (UnimplementedCommitServiceServer) ListCommitsByRefName(*ListCommitsByRefNameRequest, CommitService_ListCommitsByRefNameServer) error {
	return status.Errorf(codes.Unimplemented, "method ListCommitsByRefName not implemented")
}
func (UnimplementedCommitServiceServer) FilterShasWithSignatures(CommitService_FilterShasWithSignaturesServer) error {
	return status.Errorf(codes.Unimplemented, "method FilterShasWithSignatures not implemented")
}
func (UnimplementedCommitServiceServer) GetCommitSignatures(*GetCommitSignaturesRequest, CommitService_GetCommitSignaturesServer) error {
	return status.Errorf(codes.Unimplemented, "method GetCommitSignatures not implemented")
}
func (UnimplementedCommitServiceServer) GetCommitMessages(*GetCommitMessagesRequest, CommitService_GetCommitMessagesServer) error {
	return status.Errorf(codes.Unimplemented, "method GetCommitMessages not implemented")
}
func (UnimplementedCommitServiceServer) CheckObjectsExist(CommitService_CheckObjectsExistServer) error {
	return status.Errorf(codes.Unimplemented, "method CheckObjectsExist not implemented")
}
func (UnimplementedCommitServiceServer) mustEmbedUnimplementedCommitServiceServer() {}

// UnsafeCommitServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to CommitServiceServer will
// result in compilation errors.
type UnsafeCommitServiceServer interface {
	mustEmbedUnimplementedCommitServiceServer()
}

func RegisterCommitServiceServer(s grpc.ServiceRegistrar, srv CommitServiceServer) {
	s.RegisterService(&CommitService_ServiceDesc, srv)
}

func _CommitService_ListCommits_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListCommitsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).ListCommits(m, &commitServiceListCommitsServer{stream})
}

type CommitService_ListCommitsServer interface {
	Send(*ListCommitsResponse) error
	grpc.ServerStream
}

type commitServiceListCommitsServer struct {
	grpc.ServerStream
}

func (x *commitServiceListCommitsServer) Send(m *ListCommitsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_ListAllCommits_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListAllCommitsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).ListAllCommits(m, &commitServiceListAllCommitsServer{stream})
}

type CommitService_ListAllCommitsServer interface {
	Send(*ListAllCommitsResponse) error
	grpc.ServerStream
}

type commitServiceListAllCommitsServer struct {
	grpc.ServerStream
}

func (x *commitServiceListAllCommitsServer) Send(m *ListAllCommitsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_CommitIsAncestor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CommitIsAncestorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CommitServiceServer).CommitIsAncestor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gitaly.CommitService/CommitIsAncestor",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CommitServiceServer).CommitIsAncestor(ctx, req.(*CommitIsAncestorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CommitService_TreeEntry_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TreeEntryRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).TreeEntry(m, &commitServiceTreeEntryServer{stream})
}

type CommitService_TreeEntryServer interface {
	Send(*TreeEntryResponse) error
	grpc.ServerStream
}

type commitServiceTreeEntryServer struct {
	grpc.ServerStream
}

func (x *commitServiceTreeEntryServer) Send(m *TreeEntryResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_CountCommits_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CountCommitsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CommitServiceServer).CountCommits(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gitaly.CommitService/CountCommits",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CommitServiceServer).CountCommits(ctx, req.(*CountCommitsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CommitService_CountDivergingCommits_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CountDivergingCommitsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CommitServiceServer).CountDivergingCommits(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gitaly.CommitService/CountDivergingCommits",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CommitServiceServer).CountDivergingCommits(ctx, req.(*CountDivergingCommitsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CommitService_GetTreeEntries_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetTreeEntriesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).GetTreeEntries(m, &commitServiceGetTreeEntriesServer{stream})
}

type CommitService_GetTreeEntriesServer interface {
	Send(*GetTreeEntriesResponse) error
	grpc.ServerStream
}

type commitServiceGetTreeEntriesServer struct {
	grpc.ServerStream
}

func (x *commitServiceGetTreeEntriesServer) Send(m *GetTreeEntriesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_ListFiles_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListFilesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).ListFiles(m, &commitServiceListFilesServer{stream})
}

type CommitService_ListFilesServer interface {
	Send(*ListFilesResponse) error
	grpc.ServerStream
}

type commitServiceListFilesServer struct {
	grpc.ServerStream
}

func (x *commitServiceListFilesServer) Send(m *ListFilesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_FindCommit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FindCommitRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CommitServiceServer).FindCommit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gitaly.CommitService/FindCommit",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CommitServiceServer).FindCommit(ctx, req.(*FindCommitRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CommitService_CommitStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CommitStatsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CommitServiceServer).CommitStats(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gitaly.CommitService/CommitStats",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CommitServiceServer).CommitStats(ctx, req.(*CommitStatsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CommitService_FindAllCommits_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(FindAllCommitsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).FindAllCommits(m, &commitServiceFindAllCommitsServer{stream})
}

type CommitService_FindAllCommitsServer interface {
	Send(*FindAllCommitsResponse) error
	grpc.ServerStream
}

type commitServiceFindAllCommitsServer struct {
	grpc.ServerStream
}

func (x *commitServiceFindAllCommitsServer) Send(m *FindAllCommitsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_FindCommits_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(FindCommitsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).FindCommits(m, &commitServiceFindCommitsServer{stream})
}

type CommitService_FindCommitsServer interface {
	Send(*FindCommitsResponse) error
	grpc.ServerStream
}

type commitServiceFindCommitsServer struct {
	grpc.ServerStream
}

func (x *commitServiceFindCommitsServer) Send(m *FindCommitsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_CommitLanguages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CommitLanguagesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CommitServiceServer).CommitLanguages(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gitaly.CommitService/CommitLanguages",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CommitServiceServer).CommitLanguages(ctx, req.(*CommitLanguagesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CommitService_RawBlame_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RawBlameRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).RawBlame(m, &commitServiceRawBlameServer{stream})
}

type CommitService_RawBlameServer interface {
	Send(*RawBlameResponse) error
	grpc.ServerStream
}

type commitServiceRawBlameServer struct {
	grpc.ServerStream
}

func (x *commitServiceRawBlameServer) Send(m *RawBlameResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_LastCommitForPath_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LastCommitForPathRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CommitServiceServer).LastCommitForPath(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gitaly.CommitService/LastCommitForPath",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CommitServiceServer).LastCommitForPath(ctx, req.(*LastCommitForPathRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CommitService_ListLastCommitsForTree_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListLastCommitsForTreeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).ListLastCommitsForTree(m, &commitServiceListLastCommitsForTreeServer{stream})
}

type CommitService_ListLastCommitsForTreeServer interface {
	Send(*ListLastCommitsForTreeResponse) error
	grpc.ServerStream
}

type commitServiceListLastCommitsForTreeServer struct {
	grpc.ServerStream
}

func (x *commitServiceListLastCommitsForTreeServer) Send(m *ListLastCommitsForTreeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_CommitsByMessage_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(CommitsByMessageRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).CommitsByMessage(m, &commitServiceCommitsByMessageServer{stream})
}

type CommitService_CommitsByMessageServer interface {
	Send(*CommitsByMessageResponse) error
	grpc.ServerStream
}

type commitServiceCommitsByMessageServer struct {
	grpc.ServerStream
}

func (x *commitServiceCommitsByMessageServer) Send(m *CommitsByMessageResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_ListCommitsByOid_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListCommitsByOidRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).ListCommitsByOid(m, &commitServiceListCommitsByOidServer{stream})
}

type CommitService_ListCommitsByOidServer interface {
	Send(*ListCommitsByOidResponse) error
	grpc.ServerStream
}

type commitServiceListCommitsByOidServer struct {
	grpc.ServerStream
}

func (x *commitServiceListCommitsByOidServer) Send(m *ListCommitsByOidResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_ListCommitsByRefName_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListCommitsByRefNameRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).ListCommitsByRefName(m, &commitServiceListCommitsByRefNameServer{stream})
}

type CommitService_ListCommitsByRefNameServer interface {
	Send(*ListCommitsByRefNameResponse) error
	grpc.ServerStream
}

type commitServiceListCommitsByRefNameServer struct {
	grpc.ServerStream
}

func (x *commitServiceListCommitsByRefNameServer) Send(m *ListCommitsByRefNameResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_FilterShasWithSignatures_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CommitServiceServer).FilterShasWithSignatures(&commitServiceFilterShasWithSignaturesServer{stream})
}

type CommitService_FilterShasWithSignaturesServer interface {
	Send(*FilterShasWithSignaturesResponse) error
	Recv() (*FilterShasWithSignaturesRequest, error)
	grpc.ServerStream
}

type commitServiceFilterShasWithSignaturesServer struct {
	grpc.ServerStream
}

func (x *commitServiceFilterShasWithSignaturesServer) Send(m *FilterShasWithSignaturesResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _CommitService_GetCommitSignatures_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetCommitSignaturesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).GetCommitSignatures(m, &commitServiceGetCommitSignaturesServer{stream})
}

type CommitService_GetCommitSignaturesServer interface {
	Send(*GetCommitSignaturesResponse) error
	grpc.ServerStream
}

type commitServiceGetCommitSignaturesServer struct {
	grpc.ServerStream
}

func (x *commitServiceGetCommitSignaturesServer) Send(m *GetCommitSignaturesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_GetCommitMessages_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetCommitMessagesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).GetCommitMessages(m, &commitServiceGetCommitMessagesServer{stream})
}

type CommitService_GetCommitMessagesServer interface {
	Send(*GetCommitMessagesResponse) error
	grpc.ServerStream
}

type commitServiceGetCommitMessagesServer struct {
	grpc.ServerStream
}

func (x *commitServiceGetCommitMessagesServer) Send(m *GetCommitMessagesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_CheckObjectsExist_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CommitServiceServer).CheckObjectsExist(&commitServiceCheckObjectsExistServer{stream})
}

type CommitService_CheckObjectsExistServer interface {
	Send(*CheckObjectsExistResponse) error
	Recv() (*CheckObjectsExistRequest, error)
	grpc.ServerStream
}

type commitServiceCheckObjectsExistServer struct {
	grpc.ServerStream
}

func (x *commitServiceCheckObjectsExistServer) Send(m *CheckObjectsExistResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

// CommitService_ServiceDesc is the grpc.ServiceDesc for CommitService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var CommitService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "gitaly.CommitService",
	HandlerType: (*CommitServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CommitIsAncestor",
			Handler:    _CommitService_CommitIsAncestor_Handler,
		},
		{
			MethodName: "CountCommits",
			Handler:    _CommitService_CountCommits_Handler,
		},
		{
			MethodName: "CountDivergingCommits",
			Handler:    _CommitService_CountDivergingCommits_Handler,
		},
		{
			MethodName: "FindCommit",
			Handler:    _CommitService_FindCommit_Handler,
		},
		{
			MethodName: "CommitStats",
			Handler:    _CommitService_CommitStats_Handler,
		},
		{
			MethodName: "CommitLanguages",
			Handler:    _CommitService_CommitLanguages_Handler,
		},
		{
			MethodName: "LastCommitForPath",
			Handler:    _CommitService_LastCommitForPath_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ListCommits",
			Handler:       _CommitService_ListCommits_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListAllCommits",
			Handler:       _CommitService_ListAllCommits_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "TreeEntry",
			Handler:       _CommitService_TreeEntry_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetTreeEntries",
			Handler:       _CommitService_GetTreeEntries_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListFiles",
			Handler:       _CommitService_ListFiles_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "FindAllCommits",
			Handler:       _CommitService_FindAllCommits_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "FindCommits",
			Handler:       _CommitService_FindCommits_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "RawBlame",
			Handler:       _CommitService_RawBlame_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListLastCommitsForTree",
			Handler:       _CommitService_ListLastCommitsForTree_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CommitsByMessage",
			Handler:       _CommitService_CommitsByMessage_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListCommitsByOid",
			Handler:       _CommitService_ListCommitsByOid_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListCommitsByRefName",
			Handler:       _CommitService_ListCommitsByRefName_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "FilterShasWithSignatures",
			Handler:       _CommitService_FilterShasWithSignatures_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "GetCommitSignatures",
			Handler:       _CommitService_GetCommitSignatures_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetCommitMessages",
			Handler:       _CommitService_GetCommitMessages_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CheckObjectsExist",
			Handler:       _CommitService_CheckObjectsExist_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "commit.proto",
}
