// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"context"

	"github.com/AvengeMedia/dankcalendar/core/internal/calendar"
	mock "github.com/stretchr/testify/mock"
)

// NewMockProvider creates a new instance of MockProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockProvider(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockProvider {
	mock := &MockProvider{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockProvider is an autogenerated mock type for the Provider type
type MockProvider struct {
	mock.Mock
}

type MockProvider_Expecter struct {
	mock *mock.Mock
}

func (_m *MockProvider) EXPECT() *MockProvider_Expecter {
	return &MockProvider_Expecter{mock: &_m.Mock}
}

// Account provides a mock function for the type MockProvider
func (_mock *MockProvider) Account() calendar.Account {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for Account")
	}

	var r0 calendar.Account
	if returnFunc, ok := ret.Get(0).(func() calendar.Account); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(calendar.Account)
	}
	return r0
}

// MockProvider_Account_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Account'
type MockProvider_Account_Call struct {
	*mock.Call
}

// Account is a helper method to define mock.On call
func (_e *MockProvider_Expecter) Account() *MockProvider_Account_Call {
	return &MockProvider_Account_Call{Call: _e.mock.On("Account")}
}

func (_c *MockProvider_Account_Call) Run(run func()) *MockProvider_Account_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockProvider_Account_Call) Return(account calendar.Account) *MockProvider_Account_Call {
	_c.Call.Return(account)
	return _c
}

func (_c *MockProvider_Account_Call) RunAndReturn(run func() calendar.Account) *MockProvider_Account_Call {
	_c.Call.Return(run)
	return _c
}

// Close provides a mock function for the type MockProvider
func (_mock *MockProvider) Close() error {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for Close")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func() error); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockProvider_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
type MockProvider_Close_Call struct {
	*mock.Call
}

// Close is a helper method to define mock.On call
func (_e *MockProvider_Expecter) Close() *MockProvider_Close_Call {
	return &MockProvider_Close_Call{Call: _e.mock.On("Close")}
}

func (_c *MockProvider_Close_Call) Run(run func()) *MockProvider_Close_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockProvider_Close_Call) Return(err error) *MockProvider_Close_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockProvider_Close_Call) RunAndReturn(run func() error) *MockProvider_Close_Call {
	_c.Call.Return(run)
	return _c
}

// CreateEvent provides a mock function for the type MockProvider
func (_mock *MockProvider) CreateEvent(ctx context.Context, cal calendar.Calendar, ev *calendar.Event) (*calendar.Event, error) {
	ret := _mock.Called(ctx, cal, ev)

	if len(ret) == 0 {
		panic("no return value specified for CreateEvent")
	}

	var r0 *calendar.Event
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, calendar.Calendar, *calendar.Event) (*calendar.Event, error)); ok {
		return returnFunc(ctx, cal, ev)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, calendar.Calendar, *calendar.Event) *calendar.Event); ok {
		r0 = returnFunc(ctx, cal, ev)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*calendar.Event)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, calendar.Calendar, *calendar.Event) error); ok {
		r1 = returnFunc(ctx, cal, ev)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockProvider_CreateEvent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateEvent'
type MockProvider_CreateEvent_Call struct {
	*mock.Call
}

// CreateEvent is a helper method to define mock.On call
//   - ctx context.Context
//   - cal calendar.Calendar
//   - ev *calendar.Event
func (_e *MockProvider_Expecter) CreateEvent(ctx any, cal any, ev any) *MockProvider_CreateEvent_Call {
	return &MockProvider_CreateEvent_Call{Call: _e.mock.On("CreateEvent", ctx, cal, ev)}
}

func (_c *MockProvider_CreateEvent_Call) Run(run func(ctx context.Context, cal calendar.Calendar, ev *calendar.Event)) *MockProvider_CreateEvent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 calendar.Calendar
		if args[1] != nil {
			arg1 = args[1].(calendar.Calendar)
		}
		var arg2 *calendar.Event
		if args[2] != nil {
			arg2 = args[2].(*calendar.Event)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockProvider_CreateEvent_Call) Return(event *calendar.Event, err error) *MockProvider_CreateEvent_Call {
	_c.Call.Return(event, err)
	return _c
}

func (_c *MockProvider_CreateEvent_Call) RunAndReturn(run func(ctx context.Context, cal calendar.Calendar, ev *calendar.Event) (*calendar.Event, error)) *MockProvider_CreateEvent_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteEvent provides a mock function for the type MockProvider
func (_mock *MockProvider) DeleteEvent(ctx context.Context, cal calendar.Calendar, ev calendar.Event) error {
	ret := _mock.Called(ctx, cal, ev)

	if len(ret) == 0 {
		panic("no return value specified for DeleteEvent")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, calendar.Calendar, calendar.Event) error); ok {
		r0 = returnFunc(ctx, cal, ev)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockProvider_DeleteEvent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteEvent'
type MockProvider_DeleteEvent_Call struct {
	*mock.Call
}

// DeleteEvent is a helper method to define mock.On call
//   - ctx context.Context
//   - cal calendar.Calendar
//   - ev calendar.Event
func (_e *MockProvider_Expecter) DeleteEvent(ctx any, cal any, ev any) *MockProvider_DeleteEvent_Call {
	return &MockProvider_DeleteEvent_Call{Call: _e.mock.On("DeleteEvent", ctx, cal, ev)}
}

func (_c *MockProvider_DeleteEvent_Call) Run(run func(ctx context.Context, cal calendar.Calendar, ev calendar.Event)) *MockProvider_DeleteEvent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 calendar.Calendar
		if args[1] != nil {
			arg1 = args[1].(calendar.Calendar)
		}
		var arg2 calendar.Event
		if args[2] != nil {
			arg2 = args[2].(calendar.Event)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockProvider_DeleteEvent_Call) Return(err error) *MockProvider_DeleteEvent_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockProvider_DeleteEvent_Call) RunAndReturn(run func(ctx context.Context, cal calendar.Calendar, ev calendar.Event) error) *MockProvider_DeleteEvent_Call {
	_c.Call.Return(run)
	return _c
}

// Kind provides a mock function for the type MockProvider
func (_mock *MockProvider) Kind() calendar.AccountKind {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for Kind")
	}

	var r0 calendar.AccountKind
	if returnFunc, ok := ret.Get(0).(func() calendar.AccountKind); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(calendar.AccountKind)
	}
	return r0
}

// MockProvider_Kind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Kind'
type MockProvider_Kind_Call struct {
	*mock.Call
}

// Kind is a helper method to define mock.On call
func (_e *MockProvider_Expecter) Kind() *MockProvider_Kind_Call {
	return &MockProvider_Kind_Call{Call: _e.mock.On("Kind")}
}

func (_c *MockProvider_Kind_Call) Run(run func()) *MockProvider_Kind_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockProvider_Kind_Call) Return(accountKind calendar.AccountKind) *MockProvider_Kind_Call {
	_c.Call.Return(accountKind)
	return _c
}

func (_c *MockProvider_Kind_Call) RunAndReturn(run func() calendar.AccountKind) *MockProvider_Kind_Call {
	_c.Call.Return(run)
	return _c
}

// ListCalendars provides a mock function for the type MockProvider
func (_mock *MockProvider) ListCalendars(ctx context.Context) ([]calendar.Calendar, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for ListCalendars")
	}

	var r0 []calendar.Calendar
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]calendar.Calendar, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) []calendar.Calendar); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]calendar.Calendar)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockProvider_ListCalendars_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCalendars'
type MockProvider_ListCalendars_Call struct {
	*mock.Call
}

// ListCalendars is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockProvider_Expecter) ListCalendars(ctx any) *MockProvider_ListCalendars_Call {
	return &MockProvider_ListCalendars_Call{Call: _e.mock.On("ListCalendars", ctx)}
}

func (_c *MockProvider_ListCalendars_Call) Run(run func(ctx context.Context)) *MockProvider_ListCalendars_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockProvider_ListCalendars_Call) Return(calendars []calendar.Calendar, err error) *MockProvider_ListCalendars_Call {
	_c.Call.Return(calendars, err)
	return _c
}

func (_c *MockProvider_ListCalendars_Call) RunAndReturn(run func(ctx context.Context) ([]calendar.Calendar, error)) *MockProvider_ListCalendars_Call {
	_c.Call.Return(run)
	return _c
}

// ListEvents provides a mock function for the type MockProvider
func (_mock *MockProvider) ListEvents(ctx context.Context, cal calendar.Calendar, opts calendar.ListEventsOptions) ([]calendar.Event, error) {
	ret := _mock.Called(ctx, cal, opts)

	if len(ret) == 0 {
		panic("no return value specified for ListEvents")
	}

	var r0 []calendar.Event
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, calendar.Calendar, calendar.ListEventsOptions) ([]calendar.Event, error)); ok {
		return returnFunc(ctx, cal, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, calendar.Calendar, calendar.ListEventsOptions) []calendar.Event); ok {
		r0 = returnFunc(ctx, cal, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]calendar.Event)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, calendar.Calendar, calendar.ListEventsOptions) error); ok {
		r1 = returnFunc(ctx, cal, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockProvider_ListEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListEvents'
type MockProvider_ListEvents_Call struct {
	*mock.Call
}

// ListEvents is a helper method to define mock.On call
//   - ctx context.Context
//   - cal calendar.Calendar
//   - opts calendar.ListEventsOptions
func (_e *MockProvider_Expecter) ListEvents(ctx any, cal any, opts any) *MockProvider_ListEvents_Call {
	return &MockProvider_ListEvents_Call{Call: _e.mock.On("ListEvents", ctx, cal, opts)}
}

func (_c *MockProvider_ListEvents_Call) Run(run func(ctx context.Context, cal calendar.Calendar, opts calendar.ListEventsOptions)) *MockProvider_ListEvents_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 calendar.Calendar
		if args[1] != nil {
			arg1 = args[1].(calendar.Calendar)
		}
		var arg2 calendar.ListEventsOptions
		if args[2] != nil {
			arg2 = args[2].(calendar.ListEventsOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockProvider_ListEvents_Call) Return(events []calendar.Event, err error) *MockProvider_ListEvents_Call {
	_c.Call.Return(events, err)
	return _c
}

func (_c *MockProvider_ListEvents_Call) RunAndReturn(run func(ctx context.Context, cal calendar.Calendar, opts calendar.ListEventsOptions) ([]calendar.Event, error)) *MockProvider_ListEvents_Call {
	_c.Call.Return(run)
	return _c
}

// Sync provides a mock function for the type MockProvider
func (_mock *MockProvider) Sync(ctx context.Context, cal calendar.Calendar, cursor calendar.SyncCursor) (*calendar.SyncResult, error) {
	ret := _mock.Called(ctx, cal, cursor)

	if len(ret) == 0 {
		panic("no return value specified for Sync")
	}

	var r0 *calendar.SyncResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, calendar.Calendar, calendar.SyncCursor) (*calendar.SyncResult, error)); ok {
		return returnFunc(ctx, cal, cursor)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, calendar.Calendar, calendar.SyncCursor) *calendar.SyncResult); ok {
		r0 = returnFunc(ctx, cal, cursor)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*calendar.SyncResult)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, calendar.Calendar, calendar.SyncCursor) error); ok {
		r1 = returnFunc(ctx, cal, cursor)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockProvider_Sync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sync'
type MockProvider_Sync_Call struct {
	*mock.Call
}

// Sync is a helper method to define mock.On call
//   - ctx context.Context
//   - cal calendar.Calendar
//   - cursor calendar.SyncCursor
func (_e *MockProvider_Expecter) Sync(ctx any, cal any, cursor any) *MockProvider_Sync_Call {
	return &MockProvider_Sync_Call{Call: _e.mock.On("Sync", ctx, cal, cursor)}
}

func (_c *MockProvider_Sync_Call) Run(run func(ctx context.Context, cal calendar.Calendar, cursor calendar.SyncCursor)) *MockProvider_Sync_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 calendar.Calendar
		if args[1] != nil {
			arg1 = args[1].(calendar.Calendar)
		}
		var arg2 calendar.SyncCursor
		if args[2] != nil {
			arg2 = args[2].(calendar.SyncCursor)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockProvider_Sync_Call) Return(syncResult *calendar.SyncResult, err error) *MockProvider_Sync_Call {
	_c.Call.Return(syncResult, err)
	return _c
}

func (_c *MockProvider_Sync_Call) RunAndReturn(run func(ctx context.Context, cal calendar.Calendar, cursor calendar.SyncCursor) (*calendar.SyncResult, error)) *MockProvider_Sync_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateEvent provides a mock function for the type MockProvider
func (_mock *MockProvider) UpdateEvent(ctx context.Context, cal calendar.Calendar, ev *calendar.Event) (*calendar.Event, error) {
	ret := _mock.Called(ctx, cal, ev)

	if len(ret) == 0 {
		panic("no return value specified for UpdateEvent")
	}

	var r0 *calendar.Event
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, calendar.Calendar, *calendar.Event) (*calendar.Event, error)); ok {
		return returnFunc(ctx, cal, ev)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, calendar.Calendar, *calendar.Event) *calendar.Event); ok {
		r0 = returnFunc(ctx, cal, ev)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*calendar.Event)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, calendar.Calendar, *calendar.Event) error); ok {
		r1 = returnFunc(ctx, cal, ev)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockProvider_UpdateEvent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateEvent'
type MockProvider_UpdateEvent_Call struct {
	*mock.Call
}

// UpdateEvent is a helper method to define mock.On call
//   - ctx context.Context
//   - cal calendar.Calendar
//   - ev *calendar.Event
func (_e *MockProvider_Expecter) UpdateEvent(ctx any, cal any, ev any) *MockProvider_UpdateEvent_Call {
	return &MockProvider_UpdateEvent_Call{Call: _e.mock.On("UpdateEvent", ctx, cal, ev)}
}

func (_c *MockProvider_UpdateEvent_Call) Run(run func(ctx context.Context, cal calendar.Calendar, ev *calendar.Event)) *MockProvider_UpdateEvent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 calendar.Calendar
		if args[1] != nil {
			arg1 = args[1].(calendar.Calendar)
		}
		var arg2 *calendar.Event
		if args[2] != nil {
			arg2 = args[2].(*calendar.Event)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockProvider_UpdateEvent_Call) Return(event *calendar.Event, err error) *MockProvider_UpdateEvent_Call {
	_c.Call.Return(event, err)
	return _c
}

func (_c *MockProvider_UpdateEvent_Call) RunAndReturn(run func(ctx context.Context, cal calendar.Calendar, ev *calendar.Event) (*calendar.Event, error)) *MockProvider_UpdateEvent_Call {
	_c.Call.Return(run)
	return _c
}
