// Code generated by MockGen. DO NOT EDIT.
// Source: ./gogit/repo.go

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

import (
	context "context"
	reflect "reflect"

	git "github.com/go-git/go-git/v5"
	config "github.com/go-git/go-git/v5/config"
	plumbing "github.com/go-git/go-git/v5/plumbing"
	object "github.com/go-git/go-git/v5/plumbing/object"
	storer "github.com/go-git/go-git/v5/plumbing/storer"
	gomock "github.com/golang/mock/gomock"
)

// MockRepository is a mock of Repository interface.
type MockRepository struct {
	ctrl     *gomock.Controller
	recorder *MockRepositoryMockRecorder
}

// MockRepositoryMockRecorder is the mock recorder for MockRepository.
type MockRepositoryMockRecorder struct {
	mock *MockRepository
}

// NewMockRepository creates a new mock instance.
func NewMockRepository(ctrl *gomock.Controller) *MockRepository {
	mock := &MockRepository{ctrl: ctrl}
	mock.recorder = &MockRepositoryMockRecorder{mock}
	return mock
}

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

// BlobObject mocks base method.
func (m *MockRepository) BlobObject(arg0 plumbing.Hash) (*object.Blob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BlobObject", arg0)
	ret0, _ := ret[0].(*object.Blob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BlobObject indicates an expected call of BlobObject.
func (mr *MockRepositoryMockRecorder) BlobObject(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlobObject", reflect.TypeOf((*MockRepository)(nil).BlobObject), arg0)
}

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

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

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

// Branch indicates an expected call of Branch.
func (mr *MockRepositoryMockRecorder) Branch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Branch", reflect.TypeOf((*MockRepository)(nil).Branch), arg0)
}

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

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

// CommitObject mocks base method.
func (m *MockRepository) CommitObject(arg0 plumbing.Hash) (*object.Commit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CommitObject", arg0)
	ret0, _ := ret[0].(*object.Commit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CommitObject indicates an expected call of CommitObject.
func (mr *MockRepositoryMockRecorder) CommitObject(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitObject", reflect.TypeOf((*MockRepository)(nil).CommitObject), arg0)
}

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

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

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

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

// ConfigScoped mocks base method.
func (m *MockRepository) ConfigScoped(arg0 config.Scope) (*config.Config, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConfigScoped", arg0)
	ret0, _ := ret[0].(*config.Config)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ConfigScoped indicates an expected call of ConfigScoped.
func (mr *MockRepositoryMockRecorder) ConfigScoped(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigScoped", reflect.TypeOf((*MockRepository)(nil).ConfigScoped), arg0)
}

// CreateBranch mocks base method.
func (m *MockRepository) CreateBranch(arg0 *config.Branch) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBranch", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateBranch indicates an expected call of CreateBranch.
func (mr *MockRepositoryMockRecorder) CreateBranch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBranch", reflect.TypeOf((*MockRepository)(nil).CreateBranch), arg0)
}

// CreateRemote mocks base method.
func (m *MockRepository) CreateRemote(arg0 *config.RemoteConfig) (*git.Remote, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRemote", arg0)
	ret0, _ := ret[0].(*git.Remote)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRemote indicates an expected call of CreateRemote.
func (mr *MockRepositoryMockRecorder) CreateRemote(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRemote", reflect.TypeOf((*MockRepository)(nil).CreateRemote), arg0)
}

// CreateRemoteAnonymous mocks base method.
func (m *MockRepository) CreateRemoteAnonymous(arg0 *config.RemoteConfig) (*git.Remote, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRemoteAnonymous", arg0)
	ret0, _ := ret[0].(*git.Remote)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRemoteAnonymous indicates an expected call of CreateRemoteAnonymous.
func (mr *MockRepositoryMockRecorder) CreateRemoteAnonymous(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRemoteAnonymous", reflect.TypeOf((*MockRepository)(nil).CreateRemoteAnonymous), arg0)
}

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

// CreateTag indicates an expected call of CreateTag.
func (mr *MockRepositoryMockRecorder) CreateTag(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTag", reflect.TypeOf((*MockRepository)(nil).CreateTag), arg0, arg1, arg2)
}

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

// DeleteBranch indicates an expected call of DeleteBranch.
func (mr *MockRepositoryMockRecorder) DeleteBranch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBranch", reflect.TypeOf((*MockRepository)(nil).DeleteBranch), arg0)
}

// DeleteObject mocks base method.
func (m *MockRepository) DeleteObject(arg0 plumbing.Hash) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteObject", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteObject indicates an expected call of DeleteObject.
func (mr *MockRepositoryMockRecorder) DeleteObject(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObject", reflect.TypeOf((*MockRepository)(nil).DeleteObject), arg0)
}

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

// DeleteRemote indicates an expected call of DeleteRemote.
func (mr *MockRepositoryMockRecorder) DeleteRemote(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRemote", reflect.TypeOf((*MockRepository)(nil).DeleteRemote), arg0)
}

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

// DeleteTag indicates an expected call of DeleteTag.
func (mr *MockRepositoryMockRecorder) DeleteTag(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTag", reflect.TypeOf((*MockRepository)(nil).DeleteTag), arg0)
}

// Fetch mocks base method.
func (m *MockRepository) Fetch(arg0 *git.FetchOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Fetch", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Fetch indicates an expected call of Fetch.
func (mr *MockRepositoryMockRecorder) Fetch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fetch", reflect.TypeOf((*MockRepository)(nil).Fetch), arg0)
}

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

// FetchContext indicates an expected call of FetchContext.
func (mr *MockRepositoryMockRecorder) FetchContext(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchContext", reflect.TypeOf((*MockRepository)(nil).FetchContext), arg0, arg1)
}

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

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

// Log mocks base method.
func (m *MockRepository) Log(arg0 *git.LogOptions) (object.CommitIter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Log", arg0)
	ret0, _ := ret[0].(object.CommitIter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Log indicates an expected call of Log.
func (mr *MockRepositoryMockRecorder) Log(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Log", reflect.TypeOf((*MockRepository)(nil).Log), arg0)
}

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

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

// Object mocks base method.
func (m *MockRepository) Object(arg0 plumbing.ObjectType, arg1 plumbing.Hash) (object.Object, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Object", arg0, arg1)
	ret0, _ := ret[0].(object.Object)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Object indicates an expected call of Object.
func (mr *MockRepositoryMockRecorder) Object(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Object", reflect.TypeOf((*MockRepository)(nil).Object), arg0, arg1)
}

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

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

// Prune mocks base method.
func (m *MockRepository) Prune(arg0 git.PruneOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Prune", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Prune indicates an expected call of Prune.
func (mr *MockRepositoryMockRecorder) Prune(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Prune", reflect.TypeOf((*MockRepository)(nil).Prune), arg0)
}

// Push mocks base method.
func (m *MockRepository) Push(arg0 *git.PushOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Push", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Push indicates an expected call of Push.
func (mr *MockRepositoryMockRecorder) Push(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Push", reflect.TypeOf((*MockRepository)(nil).Push), arg0)
}

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

// PushContext indicates an expected call of PushContext.
func (mr *MockRepositoryMockRecorder) PushContext(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PushContext", reflect.TypeOf((*MockRepository)(nil).PushContext), arg0, arg1)
}

// Reference mocks base method.
func (m *MockRepository) Reference(arg0 plumbing.ReferenceName, arg1 bool) (*plumbing.Reference, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Reference", arg0, arg1)
	ret0, _ := ret[0].(*plumbing.Reference)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Reference indicates an expected call of Reference.
func (mr *MockRepositoryMockRecorder) Reference(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reference", reflect.TypeOf((*MockRepository)(nil).Reference), arg0, arg1)
}

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

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

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

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

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

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

// RepackObjects mocks base method.
func (m *MockRepository) RepackObjects(arg0 *git.RepackConfig) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RepackObjects", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// RepackObjects indicates an expected call of RepackObjects.
func (mr *MockRepositoryMockRecorder) RepackObjects(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RepackObjects", reflect.TypeOf((*MockRepository)(nil).RepackObjects), arg0)
}

// ResolveRevision mocks base method.
func (m *MockRepository) ResolveRevision(arg0 plumbing.Revision) (*plumbing.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResolveRevision", arg0)
	ret0, _ := ret[0].(*plumbing.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResolveRevision indicates an expected call of ResolveRevision.
func (mr *MockRepositoryMockRecorder) ResolveRevision(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveRevision", reflect.TypeOf((*MockRepository)(nil).ResolveRevision), arg0)
}

// SetConfig mocks base method.
func (m *MockRepository) SetConfig(arg0 *config.Config) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetConfig", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetConfig indicates an expected call of SetConfig.
func (mr *MockRepositoryMockRecorder) SetConfig(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetConfig", reflect.TypeOf((*MockRepository)(nil).SetConfig), arg0)
}

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

// Tag indicates an expected call of Tag.
func (mr *MockRepositoryMockRecorder) Tag(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tag", reflect.TypeOf((*MockRepository)(nil).Tag), arg0)
}

// TagObject mocks base method.
func (m *MockRepository) TagObject(arg0 plumbing.Hash) (*object.Tag, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TagObject", arg0)
	ret0, _ := ret[0].(*object.Tag)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TagObject indicates an expected call of TagObject.
func (mr *MockRepositoryMockRecorder) TagObject(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagObject", reflect.TypeOf((*MockRepository)(nil).TagObject), arg0)
}

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

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

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

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

// TreeObject mocks base method.
func (m *MockRepository) TreeObject(arg0 plumbing.Hash) (*object.Tree, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TreeObject", arg0)
	ret0, _ := ret[0].(*object.Tree)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TreeObject indicates an expected call of TreeObject.
func (mr *MockRepositoryMockRecorder) TreeObject(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TreeObject", reflect.TypeOf((*MockRepository)(nil).TreeObject), arg0)
}

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

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

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

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