// Code generated by MockGen. DO NOT EDIT.
// Source: go.abhg.dev/gs/internal/handler/fixup (interfaces: RestackHandler,GitWorktree,GitRepository,Service)
//
// Generated by this command:
//
//	mockgen -package fixup -typed -destination mocks_test.go . RestackHandler,GitWorktree,GitRepository,Service
//

// Package fixup is a generated GoMock package.
package fixup

import (
	context "context"
	iter "iter"
	reflect "reflect"

	git "go.abhg.dev/gs/internal/git"
	restack "go.abhg.dev/gs/internal/handler/restack"
	spice "go.abhg.dev/gs/internal/spice"
	gomock "go.uber.org/mock/gomock"
)

// MockRestackHandler is a mock of RestackHandler interface.
type MockRestackHandler struct {
	ctrl     *gomock.Controller
	recorder *MockRestackHandlerMockRecorder
	isgomock struct{}
}

// MockRestackHandlerMockRecorder is the mock recorder for MockRestackHandler.
type MockRestackHandlerMockRecorder struct {
	mock *MockRestackHandler
}

// NewMockRestackHandler creates a new mock instance.
func NewMockRestackHandler(ctrl *gomock.Controller) *MockRestackHandler {
	mock := &MockRestackHandler{ctrl: ctrl}
	mock.recorder = &MockRestackHandlerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRestackHandler) EXPECT() *MockRestackHandlerMockRecorder {
	return m.recorder
}

// RestackUpstack mocks base method.
func (m *MockRestackHandler) RestackUpstack(ctx context.Context, branch string, opts *restack.UpstackOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestackUpstack", ctx, branch, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// RestackUpstack indicates an expected call of RestackUpstack.
func (mr *MockRestackHandlerMockRecorder) RestackUpstack(ctx, branch, opts any) *MockRestackHandlerRestackUpstackCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestackUpstack", reflect.TypeOf((*MockRestackHandler)(nil).RestackUpstack), ctx, branch, opts)
	return &MockRestackHandlerRestackUpstackCall{Call: call}
}

// MockRestackHandlerRestackUpstackCall wrap *gomock.Call
type MockRestackHandlerRestackUpstackCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRestackHandlerRestackUpstackCall) Return(arg0 error) *MockRestackHandlerRestackUpstackCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRestackHandlerRestackUpstackCall) Do(f func(context.Context, string, *restack.UpstackOptions) error) *MockRestackHandlerRestackUpstackCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRestackHandlerRestackUpstackCall) DoAndReturn(f func(context.Context, string, *restack.UpstackOptions) error) *MockRestackHandlerRestackUpstackCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGitWorktree is a mock of GitWorktree interface.
type MockGitWorktree struct {
	ctrl     *gomock.Controller
	recorder *MockGitWorktreeMockRecorder
	isgomock struct{}
}

// MockGitWorktreeMockRecorder is the mock recorder for MockGitWorktree.
type MockGitWorktreeMockRecorder struct {
	mock *MockGitWorktree
}

// NewMockGitWorktree creates a new mock instance.
func NewMockGitWorktree(ctrl *gomock.Controller) *MockGitWorktree {
	mock := &MockGitWorktree{ctrl: ctrl}
	mock.recorder = &MockGitWorktreeMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockGitWorktree) EXPECT() *MockGitWorktreeMockRecorder {
	return m.recorder
}

// DiffIndex mocks base method.
func (m *MockGitWorktree) DiffIndex(ctx context.Context, treeish string) ([]git.FileStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DiffIndex", ctx, treeish)
	ret0, _ := ret[0].([]git.FileStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DiffIndex indicates an expected call of DiffIndex.
func (mr *MockGitWorktreeMockRecorder) DiffIndex(ctx, treeish any) *MockGitWorktreeDiffIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiffIndex", reflect.TypeOf((*MockGitWorktree)(nil).DiffIndex), ctx, treeish)
	return &MockGitWorktreeDiffIndexCall{Call: call}
}

// MockGitWorktreeDiffIndexCall wrap *gomock.Call
type MockGitWorktreeDiffIndexCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGitWorktreeDiffIndexCall) Return(arg0 []git.FileStatus, arg1 error) *MockGitWorktreeDiffIndexCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitWorktreeDiffIndexCall) Do(f func(context.Context, string) ([]git.FileStatus, error)) *MockGitWorktreeDiffIndexCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitWorktreeDiffIndexCall) DoAndReturn(f func(context.Context, string) ([]git.FileStatus, error)) *MockGitWorktreeDiffIndexCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Head mocks base method.
func (m *MockGitWorktree) Head(ctx context.Context) (git.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Head", ctx)
	ret0, _ := ret[0].(git.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Head indicates an expected call of Head.
func (mr *MockGitWorktreeMockRecorder) Head(ctx any) *MockGitWorktreeHeadCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Head", reflect.TypeOf((*MockGitWorktree)(nil).Head), ctx)
	return &MockGitWorktreeHeadCall{Call: call}
}

// MockGitWorktreeHeadCall wrap *gomock.Call
type MockGitWorktreeHeadCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGitWorktreeHeadCall) Return(arg0 git.Hash, arg1 error) *MockGitWorktreeHeadCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitWorktreeHeadCall) Do(f func(context.Context) (git.Hash, error)) *MockGitWorktreeHeadCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitWorktreeHeadCall) DoAndReturn(f func(context.Context) (git.Hash, error)) *MockGitWorktreeHeadCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Rebase mocks base method.
func (m *MockGitWorktree) Rebase(ctx context.Context, req git.RebaseRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Rebase", ctx, req)
	ret0, _ := ret[0].(error)
	return ret0
}

// Rebase indicates an expected call of Rebase.
func (mr *MockGitWorktreeMockRecorder) Rebase(ctx, req any) *MockGitWorktreeRebaseCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rebase", reflect.TypeOf((*MockGitWorktree)(nil).Rebase), ctx, req)
	return &MockGitWorktreeRebaseCall{Call: call}
}

// MockGitWorktreeRebaseCall wrap *gomock.Call
type MockGitWorktreeRebaseCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGitWorktreeRebaseCall) Return(err error) *MockGitWorktreeRebaseCall {
	c.Call = c.Call.Return(err)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitWorktreeRebaseCall) Do(f func(context.Context, git.RebaseRequest) error) *MockGitWorktreeRebaseCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitWorktreeRebaseCall) DoAndReturn(f func(context.Context, git.RebaseRequest) error) *MockGitWorktreeRebaseCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Reset mocks base method.
func (m *MockGitWorktree) Reset(ctx context.Context, commit string, opts git.ResetOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Reset", ctx, commit, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// Reset indicates an expected call of Reset.
func (mr *MockGitWorktreeMockRecorder) Reset(ctx, commit, opts any) *MockGitWorktreeResetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockGitWorktree)(nil).Reset), ctx, commit, opts)
	return &MockGitWorktreeResetCall{Call: call}
}

// MockGitWorktreeResetCall wrap *gomock.Call
type MockGitWorktreeResetCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGitWorktreeResetCall) Return(arg0 error) *MockGitWorktreeResetCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitWorktreeResetCall) Do(f func(context.Context, string, git.ResetOptions) error) *MockGitWorktreeResetCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitWorktreeResetCall) DoAndReturn(f func(context.Context, string, git.ResetOptions) error) *MockGitWorktreeResetCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// WriteIndexTree mocks base method.
func (m *MockGitWorktree) WriteIndexTree(ctx context.Context) (git.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteIndexTree", ctx)
	ret0, _ := ret[0].(git.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WriteIndexTree indicates an expected call of WriteIndexTree.
func (mr *MockGitWorktreeMockRecorder) WriteIndexTree(ctx any) *MockGitWorktreeWriteIndexTreeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteIndexTree", reflect.TypeOf((*MockGitWorktree)(nil).WriteIndexTree), ctx)
	return &MockGitWorktreeWriteIndexTreeCall{Call: call}
}

// MockGitWorktreeWriteIndexTreeCall wrap *gomock.Call
type MockGitWorktreeWriteIndexTreeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGitWorktreeWriteIndexTreeCall) Return(arg0 git.Hash, arg1 error) *MockGitWorktreeWriteIndexTreeCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitWorktreeWriteIndexTreeCall) Do(f func(context.Context) (git.Hash, error)) *MockGitWorktreeWriteIndexTreeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitWorktreeWriteIndexTreeCall) DoAndReturn(f func(context.Context) (git.Hash, error)) *MockGitWorktreeWriteIndexTreeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGitRepository is a mock of GitRepository interface.
type MockGitRepository struct {
	ctrl     *gomock.Controller
	recorder *MockGitRepositoryMockRecorder
	isgomock struct{}
}

// MockGitRepositoryMockRecorder is the mock recorder for MockGitRepository.
type MockGitRepositoryMockRecorder struct {
	mock *MockGitRepository
}

// NewMockGitRepository creates a new mock instance.
func NewMockGitRepository(ctrl *gomock.Controller) *MockGitRepository {
	mock := &MockGitRepository{ctrl: ctrl}
	mock.recorder = &MockGitRepositoryMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockGitRepository) EXPECT() *MockGitRepositoryMockRecorder {
	return m.recorder
}

// CommitTree mocks base method.
func (m *MockGitRepository) CommitTree(ctx context.Context, req git.CommitTreeRequest) (git.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CommitTree", ctx, req)
	ret0, _ := ret[0].(git.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CommitTree indicates an expected call of CommitTree.
func (mr *MockGitRepositoryMockRecorder) CommitTree(ctx, req any) *MockGitRepositoryCommitTreeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitTree", reflect.TypeOf((*MockGitRepository)(nil).CommitTree), ctx, req)
	return &MockGitRepositoryCommitTreeCall{Call: call}
}

// MockGitRepositoryCommitTreeCall wrap *gomock.Call
type MockGitRepositoryCommitTreeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGitRepositoryCommitTreeCall) Return(arg0 git.Hash, arg1 error) *MockGitRepositoryCommitTreeCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitRepositoryCommitTreeCall) Do(f func(context.Context, git.CommitTreeRequest) (git.Hash, error)) *MockGitRepositoryCommitTreeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitRepositoryCommitTreeCall) DoAndReturn(f func(context.Context, git.CommitTreeRequest) (git.Hash, error)) *MockGitRepositoryCommitTreeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// IsAncestor mocks base method.
func (m *MockGitRepository) IsAncestor(ctx context.Context, ancestor, descendant git.Hash) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsAncestor", ctx, ancestor, descendant)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsAncestor indicates an expected call of IsAncestor.
func (mr *MockGitRepositoryMockRecorder) IsAncestor(ctx, ancestor, descendant any) *MockGitRepositoryIsAncestorCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAncestor", reflect.TypeOf((*MockGitRepository)(nil).IsAncestor), ctx, ancestor, descendant)
	return &MockGitRepositoryIsAncestorCall{Call: call}
}

// MockGitRepositoryIsAncestorCall wrap *gomock.Call
type MockGitRepositoryIsAncestorCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGitRepositoryIsAncestorCall) Return(arg0 bool) *MockGitRepositoryIsAncestorCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitRepositoryIsAncestorCall) Do(f func(context.Context, git.Hash, git.Hash) bool) *MockGitRepositoryIsAncestorCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitRepositoryIsAncestorCall) DoAndReturn(f func(context.Context, git.Hash, git.Hash) bool) *MockGitRepositoryIsAncestorCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListCommits mocks base method.
func (m *MockGitRepository) ListCommits(ctx context.Context, commits git.CommitRange) iter.Seq2[git.Hash, error] {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCommits", ctx, commits)
	ret0, _ := ret[0].(iter.Seq2[git.Hash, error])
	return ret0
}

// ListCommits indicates an expected call of ListCommits.
func (mr *MockGitRepositoryMockRecorder) ListCommits(ctx, commits any) *MockGitRepositoryListCommitsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommits", reflect.TypeOf((*MockGitRepository)(nil).ListCommits), ctx, commits)
	return &MockGitRepositoryListCommitsCall{Call: call}
}

// MockGitRepositoryListCommitsCall wrap *gomock.Call
type MockGitRepositoryListCommitsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGitRepositoryListCommitsCall) Return(arg0 iter.Seq2[git.Hash, error]) *MockGitRepositoryListCommitsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitRepositoryListCommitsCall) Do(f func(context.Context, git.CommitRange) iter.Seq2[git.Hash, error]) *MockGitRepositoryListCommitsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitRepositoryListCommitsCall) DoAndReturn(f func(context.Context, git.CommitRange) iter.Seq2[git.Hash, error]) *MockGitRepositoryListCommitsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MergeTree mocks base method.
func (m *MockGitRepository) MergeTree(ctx context.Context, req git.MergeTreeRequest) (git.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MergeTree", ctx, req)
	ret0, _ := ret[0].(git.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MergeTree indicates an expected call of MergeTree.
func (mr *MockGitRepositoryMockRecorder) MergeTree(ctx, req any) *MockGitRepositoryMergeTreeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MergeTree", reflect.TypeOf((*MockGitRepository)(nil).MergeTree), ctx, req)
	return &MockGitRepositoryMergeTreeCall{Call: call}
}

// MockGitRepositoryMergeTreeCall wrap *gomock.Call
type MockGitRepositoryMergeTreeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGitRepositoryMergeTreeCall) Return(arg0 git.Hash, arg1 error) *MockGitRepositoryMergeTreeCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitRepositoryMergeTreeCall) Do(f func(context.Context, git.MergeTreeRequest) (git.Hash, error)) *MockGitRepositoryMergeTreeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitRepositoryMergeTreeCall) DoAndReturn(f func(context.Context, git.MergeTreeRequest) (git.Hash, error)) *MockGitRepositoryMergeTreeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PeelToCommit mocks base method.
func (m *MockGitRepository) PeelToCommit(ctx context.Context, rev string) (git.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PeelToCommit", ctx, rev)
	ret0, _ := ret[0].(git.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PeelToCommit indicates an expected call of PeelToCommit.
func (mr *MockGitRepositoryMockRecorder) PeelToCommit(ctx, rev any) *MockGitRepositoryPeelToCommitCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeelToCommit", reflect.TypeOf((*MockGitRepository)(nil).PeelToCommit), ctx, rev)
	return &MockGitRepositoryPeelToCommitCall{Call: call}
}

// MockGitRepositoryPeelToCommitCall wrap *gomock.Call
type MockGitRepositoryPeelToCommitCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGitRepositoryPeelToCommitCall) Return(arg0 git.Hash, arg1 error) *MockGitRepositoryPeelToCommitCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitRepositoryPeelToCommitCall) Do(f func(context.Context, string) (git.Hash, error)) *MockGitRepositoryPeelToCommitCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitRepositoryPeelToCommitCall) DoAndReturn(f func(context.Context, string) (git.Hash, error)) *MockGitRepositoryPeelToCommitCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ReadCommit mocks base method.
func (m *MockGitRepository) ReadCommit(ctx context.Context, commitish string) (*git.CommitObject, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadCommit", ctx, commitish)
	ret0, _ := ret[0].(*git.CommitObject)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadCommit indicates an expected call of ReadCommit.
func (mr *MockGitRepositoryMockRecorder) ReadCommit(ctx, commitish any) *MockGitRepositoryReadCommitCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadCommit", reflect.TypeOf((*MockGitRepository)(nil).ReadCommit), ctx, commitish)
	return &MockGitRepositoryReadCommitCall{Call: call}
}

// MockGitRepositoryReadCommitCall wrap *gomock.Call
type MockGitRepositoryReadCommitCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGitRepositoryReadCommitCall) Return(arg0 *git.CommitObject, arg1 error) *MockGitRepositoryReadCommitCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitRepositoryReadCommitCall) Do(f func(context.Context, string) (*git.CommitObject, error)) *MockGitRepositoryReadCommitCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitRepositoryReadCommitCall) DoAndReturn(f func(context.Context, string) (*git.CommitObject, error)) *MockGitRepositoryReadCommitCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockService is a mock of Service interface.
type MockService struct {
	ctrl     *gomock.Controller
	recorder *MockServiceMockRecorder
	isgomock struct{}
}

// MockServiceMockRecorder is the mock recorder for MockService.
type MockServiceMockRecorder struct {
	mock *MockService
}

// NewMockService creates a new mock instance.
func NewMockService(ctrl *gomock.Controller) *MockService {
	mock := &MockService{ctrl: ctrl}
	mock.recorder = &MockServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockService) EXPECT() *MockServiceMockRecorder {
	return m.recorder
}

// BranchGraph mocks base method.
func (m *MockService) BranchGraph(ctx context.Context, opts *spice.BranchGraphOptions) (*spice.BranchGraph, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BranchGraph", ctx, opts)
	ret0, _ := ret[0].(*spice.BranchGraph)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BranchGraph indicates an expected call of BranchGraph.
func (mr *MockServiceMockRecorder) BranchGraph(ctx, opts any) *MockServiceBranchGraphCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BranchGraph", reflect.TypeOf((*MockService)(nil).BranchGraph), ctx, opts)
	return &MockServiceBranchGraphCall{Call: call}
}

// MockServiceBranchGraphCall wrap *gomock.Call
type MockServiceBranchGraphCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockServiceBranchGraphCall) Return(arg0 *spice.BranchGraph, arg1 error) *MockServiceBranchGraphCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockServiceBranchGraphCall) Do(f func(context.Context, *spice.BranchGraphOptions) (*spice.BranchGraph, error)) *MockServiceBranchGraphCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockServiceBranchGraphCall) DoAndReturn(f func(context.Context, *spice.BranchGraphOptions) (*spice.BranchGraph, error)) *MockServiceBranchGraphCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RebaseRescue mocks base method.
func (m *MockService) RebaseRescue(ctx context.Context, req spice.RebaseRescueRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RebaseRescue", ctx, req)
	ret0, _ := ret[0].(error)
	return ret0
}

// RebaseRescue indicates an expected call of RebaseRescue.
func (mr *MockServiceMockRecorder) RebaseRescue(ctx, req any) *MockServiceRebaseRescueCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebaseRescue", reflect.TypeOf((*MockService)(nil).RebaseRescue), ctx, req)
	return &MockServiceRebaseRescueCall{Call: call}
}

// MockServiceRebaseRescueCall wrap *gomock.Call
type MockServiceRebaseRescueCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockServiceRebaseRescueCall) Return(arg0 error) *MockServiceRebaseRescueCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockServiceRebaseRescueCall) Do(f func(context.Context, spice.RebaseRescueRequest) error) *MockServiceRebaseRescueCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockServiceRebaseRescueCall) DoAndReturn(f func(context.Context, spice.RebaseRescueRequest) error) *MockServiceRebaseRescueCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Trunk mocks base method.
func (m *MockService) Trunk() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trunk")
	ret0, _ := ret[0].(string)
	return ret0
}

// Trunk indicates an expected call of Trunk.
func (mr *MockServiceMockRecorder) Trunk() *MockServiceTrunkCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trunk", reflect.TypeOf((*MockService)(nil).Trunk))
	return &MockServiceTrunkCall{Call: call}
}

// MockServiceTrunkCall wrap *gomock.Call
type MockServiceTrunkCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockServiceTrunkCall) Return(arg0 string) *MockServiceTrunkCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockServiceTrunkCall) Do(f func() string) *MockServiceTrunkCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockServiceTrunkCall) DoAndReturn(f func() string) *MockServiceTrunkCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
