// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.5.1
// - protoc             v6.32.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.64.0 or later.
const _ = grpc.SupportPackageIsVersion9

const (
	CommitService_ListCommits_FullMethodName              = "/gitaly.CommitService/ListCommits"
	CommitService_ListAllCommits_FullMethodName           = "/gitaly.CommitService/ListAllCommits"
	CommitService_CommitIsAncestor_FullMethodName         = "/gitaly.CommitService/CommitIsAncestor"
	CommitService_TreeEntry_FullMethodName                = "/gitaly.CommitService/TreeEntry"
	CommitService_CountCommits_FullMethodName             = "/gitaly.CommitService/CountCommits"
	CommitService_CountDivergingCommits_FullMethodName    = "/gitaly.CommitService/CountDivergingCommits"
	CommitService_GetTreeEntries_FullMethodName           = "/gitaly.CommitService/GetTreeEntries"
	CommitService_ListFiles_FullMethodName                = "/gitaly.CommitService/ListFiles"
	CommitService_FindCommit_FullMethodName               = "/gitaly.CommitService/FindCommit"
	CommitService_CommitStats_FullMethodName              = "/gitaly.CommitService/CommitStats"
	CommitService_FindAllCommits_FullMethodName           = "/gitaly.CommitService/FindAllCommits"
	CommitService_FindCommits_FullMethodName              = "/gitaly.CommitService/FindCommits"
	CommitService_CommitLanguages_FullMethodName          = "/gitaly.CommitService/CommitLanguages"
	CommitService_RawBlame_FullMethodName                 = "/gitaly.CommitService/RawBlame"
	CommitService_LastCommitForPath_FullMethodName        = "/gitaly.CommitService/LastCommitForPath"
	CommitService_ListLastCommitsForTree_FullMethodName   = "/gitaly.CommitService/ListLastCommitsForTree"
	CommitService_CommitsByMessage_FullMethodName         = "/gitaly.CommitService/CommitsByMessage"
	CommitService_ListCommitsByOid_FullMethodName         = "/gitaly.CommitService/ListCommitsByOid"
	CommitService_ListCommitsByRefName_FullMethodName     = "/gitaly.CommitService/ListCommitsByRefName"
	CommitService_FilterShasWithSignatures_FullMethodName = "/gitaly.CommitService/FilterShasWithSignatures"
	CommitService_GetCommitSignatures_FullMethodName      = "/gitaly.CommitService/GetCommitSignatures"
	CommitService_GetCommitMessages_FullMethodName        = "/gitaly.CommitService/GetCommitMessages"
	CommitService_CheckObjectsExist_FullMethodName        = "/gitaly.CommitService/CheckObjectsExist"
)

// 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(ctx context.Context, in *ListCommitsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListCommitsResponse], error)
	ListAllCommits(ctx context.Context, in *ListAllCommitsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListAllCommitsResponse], error)
	CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error)
	TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[TreeEntryResponse], error)
	CountCommits(ctx context.Context, in *CountCommitsRequest, opts ...grpc.CallOption) (*CountCommitsResponse, error)
	CountDivergingCommits(ctx context.Context, in *CountDivergingCommitsRequest, opts ...grpc.CallOption) (*CountDivergingCommitsResponse, error)
	GetTreeEntries(ctx context.Context, in *GetTreeEntriesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[GetTreeEntriesResponse], error)
	ListFiles(ctx context.Context, in *ListFilesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListFilesResponse], error)
	FindCommit(ctx context.Context, in *FindCommitRequest, opts ...grpc.CallOption) (*FindCommitResponse, error)
	CommitStats(ctx context.Context, in *CommitStatsRequest, opts ...grpc.CallOption) (*CommitStatsResponse, error)
	FindAllCommits(ctx context.Context, in *FindAllCommitsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[FindAllCommitsResponse], error)
	FindCommits(ctx context.Context, in *FindCommitsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[FindCommitsResponse], error)
	CommitLanguages(ctx context.Context, in *CommitLanguagesRequest, opts ...grpc.CallOption) (*CommitLanguagesResponse, error)
	RawBlame(ctx context.Context, in *RawBlameRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[RawBlameResponse], error)
	LastCommitForPath(ctx context.Context, in *LastCommitForPathRequest, opts ...grpc.CallOption) (*LastCommitForPathResponse, error)
	ListLastCommitsForTree(ctx context.Context, in *ListLastCommitsForTreeRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListLastCommitsForTreeResponse], error)
	CommitsByMessage(ctx context.Context, in *CommitsByMessageRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[CommitsByMessageResponse], error)
	ListCommitsByOid(ctx context.Context, in *ListCommitsByOidRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListCommitsByOidResponse], error)
	ListCommitsByRefName(ctx context.Context, in *ListCommitsByRefNameRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListCommitsByRefNameResponse], error)
	FilterShasWithSignatures(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[FilterShasWithSignaturesRequest, FilterShasWithSignaturesResponse], error)
	GetCommitSignatures(ctx context.Context, in *GetCommitSignaturesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[GetCommitSignaturesResponse], error)
	GetCommitMessages(ctx context.Context, in *GetCommitMessagesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[GetCommitMessagesResponse], error)
	CheckObjectsExist(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[CheckObjectsExistRequest, CheckObjectsExistResponse], 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) (grpc.ServerStreamingClient[ListCommitsResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[0], CommitService_ListCommits_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ListCommitsRequest, ListCommitsResponse]{ClientStream: 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
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_ListCommitsClient = grpc.ServerStreamingClient[ListCommitsResponse]

func (c *commitServiceClient) ListAllCommits(ctx context.Context, in *ListAllCommitsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListAllCommitsResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[1], CommitService_ListAllCommits_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ListAllCommitsRequest, ListAllCommitsResponse]{ClientStream: 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
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_ListAllCommitsClient = grpc.ServerStreamingClient[ListAllCommitsResponse]

func (c *commitServiceClient) CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CommitIsAncestorResponse)
	err := c.cc.Invoke(ctx, CommitService_CommitIsAncestor_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[TreeEntryResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[2], CommitService_TreeEntry_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[TreeEntryRequest, TreeEntryResponse]{ClientStream: 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
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_TreeEntryClient = grpc.ServerStreamingClient[TreeEntryResponse]

func (c *commitServiceClient) CountCommits(ctx context.Context, in *CountCommitsRequest, opts ...grpc.CallOption) (*CountCommitsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CountCommitsResponse)
	err := c.cc.Invoke(ctx, CommitService_CountCommits_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) CountDivergingCommits(ctx context.Context, in *CountDivergingCommitsRequest, opts ...grpc.CallOption) (*CountDivergingCommitsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CountDivergingCommitsResponse)
	err := c.cc.Invoke(ctx, CommitService_CountDivergingCommits_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) GetTreeEntries(ctx context.Context, in *GetTreeEntriesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[GetTreeEntriesResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[3], CommitService_GetTreeEntries_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[GetTreeEntriesRequest, GetTreeEntriesResponse]{ClientStream: 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
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_GetTreeEntriesClient = grpc.ServerStreamingClient[GetTreeEntriesResponse]

func (c *commitServiceClient) ListFiles(ctx context.Context, in *ListFilesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListFilesResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[4], CommitService_ListFiles_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ListFilesRequest, ListFilesResponse]{ClientStream: 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
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_ListFilesClient = grpc.ServerStreamingClient[ListFilesResponse]

func (c *commitServiceClient) FindCommit(ctx context.Context, in *FindCommitRequest, opts ...grpc.CallOption) (*FindCommitResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(FindCommitResponse)
	err := c.cc.Invoke(ctx, CommitService_FindCommit_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) CommitStats(ctx context.Context, in *CommitStatsRequest, opts ...grpc.CallOption) (*CommitStatsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CommitStatsResponse)
	err := c.cc.Invoke(ctx, CommitService_CommitStats_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) FindAllCommits(ctx context.Context, in *FindAllCommitsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[FindAllCommitsResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[5], CommitService_FindAllCommits_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[FindAllCommitsRequest, FindAllCommitsResponse]{ClientStream: 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
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_FindAllCommitsClient = grpc.ServerStreamingClient[FindAllCommitsResponse]

func (c *commitServiceClient) FindCommits(ctx context.Context, in *FindCommitsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[FindCommitsResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[6], CommitService_FindCommits_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[FindCommitsRequest, FindCommitsResponse]{ClientStream: 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
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_FindCommitsClient = grpc.ServerStreamingClient[FindCommitsResponse]

func (c *commitServiceClient) CommitLanguages(ctx context.Context, in *CommitLanguagesRequest, opts ...grpc.CallOption) (*CommitLanguagesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CommitLanguagesResponse)
	err := c.cc.Invoke(ctx, CommitService_CommitLanguages_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) RawBlame(ctx context.Context, in *RawBlameRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[RawBlameResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[7], CommitService_RawBlame_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[RawBlameRequest, RawBlameResponse]{ClientStream: 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
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_RawBlameClient = grpc.ServerStreamingClient[RawBlameResponse]

func (c *commitServiceClient) LastCommitForPath(ctx context.Context, in *LastCommitForPathRequest, opts ...grpc.CallOption) (*LastCommitForPathResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(LastCommitForPathResponse)
	err := c.cc.Invoke(ctx, CommitService_LastCommitForPath_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) ListLastCommitsForTree(ctx context.Context, in *ListLastCommitsForTreeRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListLastCommitsForTreeResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[8], CommitService_ListLastCommitsForTree_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ListLastCommitsForTreeRequest, ListLastCommitsForTreeResponse]{ClientStream: 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
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_ListLastCommitsForTreeClient = grpc.ServerStreamingClient[ListLastCommitsForTreeResponse]

func (c *commitServiceClient) CommitsByMessage(ctx context.Context, in *CommitsByMessageRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[CommitsByMessageResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[9], CommitService_CommitsByMessage_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[CommitsByMessageRequest, CommitsByMessageResponse]{ClientStream: 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
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_CommitsByMessageClient = grpc.ServerStreamingClient[CommitsByMessageResponse]

func (c *commitServiceClient) ListCommitsByOid(ctx context.Context, in *ListCommitsByOidRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListCommitsByOidResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[10], CommitService_ListCommitsByOid_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ListCommitsByOidRequest, ListCommitsByOidResponse]{ClientStream: 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
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_ListCommitsByOidClient = grpc.ServerStreamingClient[ListCommitsByOidResponse]

func (c *commitServiceClient) ListCommitsByRefName(ctx context.Context, in *ListCommitsByRefNameRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListCommitsByRefNameResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[11], CommitService_ListCommitsByRefName_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ListCommitsByRefNameRequest, ListCommitsByRefNameResponse]{ClientStream: 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
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_ListCommitsByRefNameClient = grpc.ServerStreamingClient[ListCommitsByRefNameResponse]

func (c *commitServiceClient) FilterShasWithSignatures(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[FilterShasWithSignaturesRequest, FilterShasWithSignaturesResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[12], CommitService_FilterShasWithSignatures_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[FilterShasWithSignaturesRequest, FilterShasWithSignaturesResponse]{ClientStream: stream}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_FilterShasWithSignaturesClient = grpc.BidiStreamingClient[FilterShasWithSignaturesRequest, FilterShasWithSignaturesResponse]

func (c *commitServiceClient) GetCommitSignatures(ctx context.Context, in *GetCommitSignaturesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[GetCommitSignaturesResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[13], CommitService_GetCommitSignatures_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[GetCommitSignaturesRequest, GetCommitSignaturesResponse]{ClientStream: 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
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_GetCommitSignaturesClient = grpc.ServerStreamingClient[GetCommitSignaturesResponse]

func (c *commitServiceClient) GetCommitMessages(ctx context.Context, in *GetCommitMessagesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[GetCommitMessagesResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[14], CommitService_GetCommitMessages_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[GetCommitMessagesRequest, GetCommitMessagesResponse]{ClientStream: 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
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_GetCommitMessagesClient = grpc.ServerStreamingClient[GetCommitMessagesResponse]

func (c *commitServiceClient) CheckObjectsExist(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[CheckObjectsExistRequest, CheckObjectsExistResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CommitService_ServiceDesc.Streams[15], CommitService_CheckObjectsExist_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[CheckObjectsExistRequest, CheckObjectsExistResponse]{ClientStream: stream}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_CheckObjectsExistClient = grpc.BidiStreamingClient[CheckObjectsExistRequest, CheckObjectsExistResponse]

// CommitServiceServer is the server API for CommitService service.
// All implementations must embed UnimplementedCommitServiceServer
// for forward compatibility.
type CommitServiceServer interface {
	ListCommits(*ListCommitsRequest, grpc.ServerStreamingServer[ListCommitsResponse]) error
	ListAllCommits(*ListAllCommitsRequest, grpc.ServerStreamingServer[ListAllCommitsResponse]) error
	CommitIsAncestor(context.Context, *CommitIsAncestorRequest) (*CommitIsAncestorResponse, error)
	TreeEntry(*TreeEntryRequest, grpc.ServerStreamingServer[TreeEntryResponse]) error
	CountCommits(context.Context, *CountCommitsRequest) (*CountCommitsResponse, error)
	CountDivergingCommits(context.Context, *CountDivergingCommitsRequest) (*CountDivergingCommitsResponse, error)
	GetTreeEntries(*GetTreeEntriesRequest, grpc.ServerStreamingServer[GetTreeEntriesResponse]) error
	ListFiles(*ListFilesRequest, grpc.ServerStreamingServer[ListFilesResponse]) error
	FindCommit(context.Context, *FindCommitRequest) (*FindCommitResponse, error)
	CommitStats(context.Context, *CommitStatsRequest) (*CommitStatsResponse, error)
	FindAllCommits(*FindAllCommitsRequest, grpc.ServerStreamingServer[FindAllCommitsResponse]) error
	FindCommits(*FindCommitsRequest, grpc.ServerStreamingServer[FindCommitsResponse]) error
	CommitLanguages(context.Context, *CommitLanguagesRequest) (*CommitLanguagesResponse, error)
	RawBlame(*RawBlameRequest, grpc.ServerStreamingServer[RawBlameResponse]) error
	LastCommitForPath(context.Context, *LastCommitForPathRequest) (*LastCommitForPathResponse, error)
	ListLastCommitsForTree(*ListLastCommitsForTreeRequest, grpc.ServerStreamingServer[ListLastCommitsForTreeResponse]) error
	CommitsByMessage(*CommitsByMessageRequest, grpc.ServerStreamingServer[CommitsByMessageResponse]) error
	ListCommitsByOid(*ListCommitsByOidRequest, grpc.ServerStreamingServer[ListCommitsByOidResponse]) error
	ListCommitsByRefName(*ListCommitsByRefNameRequest, grpc.ServerStreamingServer[ListCommitsByRefNameResponse]) error
	FilterShasWithSignatures(grpc.BidiStreamingServer[FilterShasWithSignaturesRequest, FilterShasWithSignaturesResponse]) error
	GetCommitSignatures(*GetCommitSignaturesRequest, grpc.ServerStreamingServer[GetCommitSignaturesResponse]) error
	GetCommitMessages(*GetCommitMessagesRequest, grpc.ServerStreamingServer[GetCommitMessagesResponse]) error
	CheckObjectsExist(grpc.BidiStreamingServer[CheckObjectsExistRequest, CheckObjectsExistResponse]) error
	mustEmbedUnimplementedCommitServiceServer()
}

// UnimplementedCommitServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedCommitServiceServer struct{}

func (UnimplementedCommitServiceServer) ListCommits(*ListCommitsRequest, grpc.ServerStreamingServer[ListCommitsResponse]) error {
	return status.Errorf(codes.Unimplemented, "method ListCommits not implemented")
}
func (UnimplementedCommitServiceServer) ListAllCommits(*ListAllCommitsRequest, grpc.ServerStreamingServer[ListAllCommitsResponse]) 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, grpc.ServerStreamingServer[TreeEntryResponse]) 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, grpc.ServerStreamingServer[GetTreeEntriesResponse]) error {
	return status.Errorf(codes.Unimplemented, "method GetTreeEntries not implemented")
}
func (UnimplementedCommitServiceServer) ListFiles(*ListFilesRequest, grpc.ServerStreamingServer[ListFilesResponse]) 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, grpc.ServerStreamingServer[FindAllCommitsResponse]) error {
	return status.Errorf(codes.Unimplemented, "method FindAllCommits not implemented")
}
func (UnimplementedCommitServiceServer) FindCommits(*FindCommitsRequest, grpc.ServerStreamingServer[FindCommitsResponse]) 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, grpc.ServerStreamingServer[RawBlameResponse]) 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, grpc.ServerStreamingServer[ListLastCommitsForTreeResponse]) error {
	return status.Errorf(codes.Unimplemented, "method ListLastCommitsForTree not implemented")
}
func (UnimplementedCommitServiceServer) CommitsByMessage(*CommitsByMessageRequest, grpc.ServerStreamingServer[CommitsByMessageResponse]) error {
	return status.Errorf(codes.Unimplemented, "method CommitsByMessage not implemented")
}
func (UnimplementedCommitServiceServer) ListCommitsByOid(*ListCommitsByOidRequest, grpc.ServerStreamingServer[ListCommitsByOidResponse]) error {
	return status.Errorf(codes.Unimplemented, "method ListCommitsByOid not implemented")
}
func (UnimplementedCommitServiceServer) ListCommitsByRefName(*ListCommitsByRefNameRequest, grpc.ServerStreamingServer[ListCommitsByRefNameResponse]) error {
	return status.Errorf(codes.Unimplemented, "method ListCommitsByRefName not implemented")
}
func (UnimplementedCommitServiceServer) FilterShasWithSignatures(grpc.BidiStreamingServer[FilterShasWithSignaturesRequest, FilterShasWithSignaturesResponse]) error {
	return status.Errorf(codes.Unimplemented, "method FilterShasWithSignatures not implemented")
}
func (UnimplementedCommitServiceServer) GetCommitSignatures(*GetCommitSignaturesRequest, grpc.ServerStreamingServer[GetCommitSignaturesResponse]) error {
	return status.Errorf(codes.Unimplemented, "method GetCommitSignatures not implemented")
}
func (UnimplementedCommitServiceServer) GetCommitMessages(*GetCommitMessagesRequest, grpc.ServerStreamingServer[GetCommitMessagesResponse]) error {
	return status.Errorf(codes.Unimplemented, "method GetCommitMessages not implemented")
}
func (UnimplementedCommitServiceServer) CheckObjectsExist(grpc.BidiStreamingServer[CheckObjectsExistRequest, CheckObjectsExistResponse]) error {
	return status.Errorf(codes.Unimplemented, "method CheckObjectsExist not implemented")
}
func (UnimplementedCommitServiceServer) mustEmbedUnimplementedCommitServiceServer() {}
func (UnimplementedCommitServiceServer) testEmbeddedByValue()                       {}

// 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) {
	// If the following call pancis, it indicates UnimplementedCommitServiceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	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, &grpc.GenericServerStream[ListCommitsRequest, ListCommitsResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_ListCommitsServer = grpc.ServerStreamingServer[ListCommitsResponse]

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, &grpc.GenericServerStream[ListAllCommitsRequest, ListAllCommitsResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_ListAllCommitsServer = grpc.ServerStreamingServer[ListAllCommitsResponse]

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: CommitService_CommitIsAncestor_FullMethodName,
	}
	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, &grpc.GenericServerStream[TreeEntryRequest, TreeEntryResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_TreeEntryServer = grpc.ServerStreamingServer[TreeEntryResponse]

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: CommitService_CountCommits_FullMethodName,
	}
	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: CommitService_CountDivergingCommits_FullMethodName,
	}
	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, &grpc.GenericServerStream[GetTreeEntriesRequest, GetTreeEntriesResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_GetTreeEntriesServer = grpc.ServerStreamingServer[GetTreeEntriesResponse]

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, &grpc.GenericServerStream[ListFilesRequest, ListFilesResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_ListFilesServer = grpc.ServerStreamingServer[ListFilesResponse]

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: CommitService_FindCommit_FullMethodName,
	}
	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: CommitService_CommitStats_FullMethodName,
	}
	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, &grpc.GenericServerStream[FindAllCommitsRequest, FindAllCommitsResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_FindAllCommitsServer = grpc.ServerStreamingServer[FindAllCommitsResponse]

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, &grpc.GenericServerStream[FindCommitsRequest, FindCommitsResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_FindCommitsServer = grpc.ServerStreamingServer[FindCommitsResponse]

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: CommitService_CommitLanguages_FullMethodName,
	}
	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, &grpc.GenericServerStream[RawBlameRequest, RawBlameResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_RawBlameServer = grpc.ServerStreamingServer[RawBlameResponse]

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: CommitService_LastCommitForPath_FullMethodName,
	}
	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, &grpc.GenericServerStream[ListLastCommitsForTreeRequest, ListLastCommitsForTreeResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_ListLastCommitsForTreeServer = grpc.ServerStreamingServer[ListLastCommitsForTreeResponse]

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, &grpc.GenericServerStream[CommitsByMessageRequest, CommitsByMessageResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_CommitsByMessageServer = grpc.ServerStreamingServer[CommitsByMessageResponse]

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, &grpc.GenericServerStream[ListCommitsByOidRequest, ListCommitsByOidResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_ListCommitsByOidServer = grpc.ServerStreamingServer[ListCommitsByOidResponse]

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, &grpc.GenericServerStream[ListCommitsByRefNameRequest, ListCommitsByRefNameResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_ListCommitsByRefNameServer = grpc.ServerStreamingServer[ListCommitsByRefNameResponse]

func _CommitService_FilterShasWithSignatures_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CommitServiceServer).FilterShasWithSignatures(&grpc.GenericServerStream[FilterShasWithSignaturesRequest, FilterShasWithSignaturesResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_FilterShasWithSignaturesServer = grpc.BidiStreamingServer[FilterShasWithSignaturesRequest, FilterShasWithSignaturesResponse]

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, &grpc.GenericServerStream[GetCommitSignaturesRequest, GetCommitSignaturesResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_GetCommitSignaturesServer = grpc.ServerStreamingServer[GetCommitSignaturesResponse]

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, &grpc.GenericServerStream[GetCommitMessagesRequest, GetCommitMessagesResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_GetCommitMessagesServer = grpc.ServerStreamingServer[GetCommitMessagesResponse]

func _CommitService_CheckObjectsExist_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CommitServiceServer).CheckObjectsExist(&grpc.GenericServerStream[CheckObjectsExistRequest, CheckObjectsExistResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CommitService_CheckObjectsExistServer = grpc.BidiStreamingServer[CheckObjectsExistRequest, CheckObjectsExistResponse]

// 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",
}
