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

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

import (
	context "context"
	reflect "reflect"

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

// MockWorktree is a mock of Worktree interface.
type MockWorktree struct {
	ctrl     *gomock.Controller
	recorder *MockWorktreeMockRecorder
}

// MockWorktreeMockRecorder is the mock recorder for MockWorktree.
type MockWorktreeMockRecorder struct {
	mock *MockWorktree
}

// NewMockWorktree creates a new mock instance.
func NewMockWorktree(ctrl *gomock.Controller) *MockWorktree {
	mock := &MockWorktree{ctrl: ctrl}
	mock.recorder = &MockWorktreeMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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