// Code generated by MockGen. DO NOT EDIT.
// Source: go.abhg.dev/gs/internal/spice (interfaces: GitRepository,GitWorktree,Store)
//
// Generated by this command:
//
//	mockgen -destination=mock_service_test.go -package=spice . GitRepository,GitWorktree,Store
//

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

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

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

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

// DeleteBranch mocks base method.
func (m *MockGitRepository) DeleteBranch(arg0 context.Context, arg1 string, arg2 git.BranchDeleteOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBranch", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteBranch indicates an expected call of DeleteBranch.
func (mr *MockGitRepositoryMockRecorder) DeleteBranch(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBranch", reflect.TypeOf((*MockGitRepository)(nil).DeleteBranch), arg0, arg1, arg2)
}

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

// ForkPoint indicates an expected call of ForkPoint.
func (mr *MockGitRepositoryMockRecorder) ForkPoint(ctx, a, b any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForkPoint", reflect.TypeOf((*MockGitRepository)(nil).ForkPoint), ctx, a, b)
}

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

// HashAt indicates an expected call of HashAt.
func (mr *MockGitRepositoryMockRecorder) HashAt(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HashAt", reflect.TypeOf((*MockGitRepository)(nil).HashAt), arg0, arg1, arg2)
}

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

// IsAncestor indicates an expected call of IsAncestor.
func (mr *MockGitRepositoryMockRecorder) IsAncestor(ctx, a, b any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAncestor", reflect.TypeOf((*MockGitRepository)(nil).IsAncestor), ctx, a, b)
}

// ListRemoteRefs mocks base method.
func (m *MockGitRepository) ListRemoteRefs(ctx context.Context, remote string, opts *git.ListRemoteRefsOptions) iter.Seq2[git.RemoteRef, error] {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRemoteRefs", ctx, remote, opts)
	ret0, _ := ret[0].(iter.Seq2[git.RemoteRef, error])
	return ret0
}

// ListRemoteRefs indicates an expected call of ListRemoteRefs.
func (mr *MockGitRepositoryMockRecorder) ListRemoteRefs(ctx, remote, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRemoteRefs", reflect.TypeOf((*MockGitRepository)(nil).ListRemoteRefs), ctx, remote, opts)
}

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

// ListRemotes indicates an expected call of ListRemotes.
func (mr *MockGitRepositoryMockRecorder) ListRemotes(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRemotes", reflect.TypeOf((*MockGitRepository)(nil).ListRemotes), ctx)
}

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

// LocalBranches indicates an expected call of LocalBranches.
func (mr *MockGitRepositoryMockRecorder) LocalBranches(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LocalBranches", reflect.TypeOf((*MockGitRepository)(nil).LocalBranches), ctx, opts)
}

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

// MergeBase indicates an expected call of MergeBase.
func (mr *MockGitRepositoryMockRecorder) MergeBase(ctx, a, b any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MergeBase", reflect.TypeOf((*MockGitRepository)(nil).MergeBase), ctx, a, b)
}

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

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

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

// RemoteDefaultBranch indicates an expected call of RemoteDefaultBranch.
func (mr *MockGitRepositoryMockRecorder) RemoteDefaultBranch(ctx, remote any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteDefaultBranch", reflect.TypeOf((*MockGitRepository)(nil).RemoteDefaultBranch), ctx, remote)
}

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

// RemoteURL indicates an expected call of RemoteURL.
func (mr *MockGitRepositoryMockRecorder) RemoteURL(ctx, remote any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteURL", reflect.TypeOf((*MockGitRepository)(nil).RemoteURL), ctx, remote)
}

// RenameBranch mocks base method.
func (m *MockGitRepository) RenameBranch(arg0 context.Context, arg1 git.RenameBranchRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RenameBranch", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// RenameBranch indicates an expected call of RenameBranch.
func (mr *MockGitRepositoryMockRecorder) RenameBranch(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameBranch", reflect.TypeOf((*MockGitRepository)(nil).RenameBranch), arg0, arg1)
}

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

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

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

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

// Rebase indicates an expected call of Rebase.
func (mr *MockGitWorktreeMockRecorder) Rebase(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rebase", reflect.TypeOf((*MockGitWorktree)(nil).Rebase), arg0, arg1)
}

// MockStore is a mock of Store interface.
type MockStore struct {
	ctrl     *gomock.Controller
	recorder *MockStoreMockRecorder
	isgomock struct{}
}

// MockStoreMockRecorder is the mock recorder for MockStore.
type MockStoreMockRecorder struct {
	mock *MockStore
}

// NewMockStore creates a new mock instance.
func NewMockStore(ctrl *gomock.Controller) *MockStore {
	mock := &MockStore{ctrl: ctrl}
	mock.recorder = &MockStoreMockRecorder{mock}
	return mock
}

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

// AppendContinuations mocks base method.
func (m *MockStore) AppendContinuations(arg0 context.Context, arg1 string, arg2 ...state.Continuation) error {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AppendContinuations", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// AppendContinuations indicates an expected call of AppendContinuations.
func (mr *MockStoreMockRecorder) AppendContinuations(arg0, arg1 any, arg2 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendContinuations", reflect.TypeOf((*MockStore)(nil).AppendContinuations), varargs...)
}

// BeginBranchTx mocks base method.
func (m *MockStore) BeginBranchTx() *state.BranchTx {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BeginBranchTx")
	ret0, _ := ret[0].(*state.BranchTx)
	return ret0
}

// BeginBranchTx indicates an expected call of BeginBranchTx.
func (mr *MockStoreMockRecorder) BeginBranchTx() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginBranchTx", reflect.TypeOf((*MockStore)(nil).BeginBranchTx))
}

// CacheTemplates mocks base method.
func (m *MockStore) CacheTemplates(arg0 context.Context, arg1 string, arg2 []*state.CachedTemplate) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CacheTemplates", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// CacheTemplates indicates an expected call of CacheTemplates.
func (mr *MockStoreMockRecorder) CacheTemplates(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CacheTemplates", reflect.TypeOf((*MockStore)(nil).CacheTemplates), arg0, arg1, arg2)
}

// ListBranches mocks base method.
func (m *MockStore) ListBranches(ctx context.Context) iter.Seq2[string, error] {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBranches", ctx)
	ret0, _ := ret[0].(iter.Seq2[string, error])
	return ret0
}

// ListBranches indicates an expected call of ListBranches.
func (mr *MockStoreMockRecorder) ListBranches(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBranches", reflect.TypeOf((*MockStore)(nil).ListBranches), ctx)
}

// LoadCachedTemplates mocks base method.
func (m *MockStore) LoadCachedTemplates(arg0 context.Context) (string, []*state.CachedTemplate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadCachedTemplates", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].([]*state.CachedTemplate)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// LoadCachedTemplates indicates an expected call of LoadCachedTemplates.
func (mr *MockStoreMockRecorder) LoadCachedTemplates(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadCachedTemplates", reflect.TypeOf((*MockStore)(nil).LoadCachedTemplates), arg0)
}

// LookupBranch mocks base method.
func (m *MockStore) LookupBranch(ctx context.Context, name string) (*state.LookupResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LookupBranch", ctx, name)
	ret0, _ := ret[0].(*state.LookupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LookupBranch indicates an expected call of LookupBranch.
func (mr *MockStoreMockRecorder) LookupBranch(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookupBranch", reflect.TypeOf((*MockStore)(nil).LookupBranch), ctx, name)
}

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

// Remote indicates an expected call of Remote.
func (mr *MockStoreMockRecorder) Remote() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remote", reflect.TypeOf((*MockStore)(nil).Remote))
}

// TakeContinuations mocks base method.
func (m *MockStore) TakeContinuations(arg0 context.Context, arg1 string) ([]state.Continuation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TakeContinuations", arg0, arg1)
	ret0, _ := ret[0].([]state.Continuation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TakeContinuations indicates an expected call of TakeContinuations.
func (mr *MockStoreMockRecorder) TakeContinuations(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TakeContinuations", reflect.TypeOf((*MockStore)(nil).TakeContinuations), arg0, arg1)
}

// Trunk mocks base method.
func (m *MockStore) 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 *MockStoreMockRecorder) Trunk() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trunk", reflect.TypeOf((*MockStore)(nil).Trunk))
}
