// Code generated by mockery v2.38.0. DO NOT EDIT.

package protocol

import (
	context "context"

	mock "github.com/stretchr/testify/mock"
	protocol "go.lsp.dev/protocol"
)

// MockClient is an autogenerated mock type for the Client type
type MockClient struct {
	mock.Mock
}

type MockClient_Expecter struct {
	mock *mock.Mock
}

func (_m *MockClient) EXPECT() *MockClient_Expecter {
	return &MockClient_Expecter{mock: &_m.Mock}
}

// ApplyEdit provides a mock function with given fields: ctx, params
func (_m *MockClient) ApplyEdit(ctx context.Context, params *protocol.ApplyWorkspaceEditParams) (bool, error) {
	ret := _m.Called(ctx, params)

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

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.ApplyWorkspaceEditParams) (bool, error)); ok {
		return rf(ctx, params)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.ApplyWorkspaceEditParams) bool); ok {
		r0 = rf(ctx, params)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, *protocol.ApplyWorkspaceEditParams) error); ok {
		r1 = rf(ctx, params)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ApplyEdit is a helper method to define mock.On call
//   - ctx context.Context
//   - params *protocol.ApplyWorkspaceEditParams
func (_e *MockClient_Expecter) ApplyEdit(ctx interface{}, params interface{}) *MockClient_ApplyEdit_Call {
	return &MockClient_ApplyEdit_Call{Call: _e.mock.On("ApplyEdit", ctx, params)}
}

func (_c *MockClient_ApplyEdit_Call) Run(run func(ctx context.Context, params *protocol.ApplyWorkspaceEditParams)) *MockClient_ApplyEdit_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*protocol.ApplyWorkspaceEditParams))
	})
	return _c
}

func (_c *MockClient_ApplyEdit_Call) Return(result bool, err error) *MockClient_ApplyEdit_Call {
	_c.Call.Return(result, err)
	return _c
}

func (_c *MockClient_ApplyEdit_Call) RunAndReturn(run func(context.Context, *protocol.ApplyWorkspaceEditParams) (bool, error)) *MockClient_ApplyEdit_Call {
	_c.Call.Return(run)
	return _c
}

// Configuration provides a mock function with given fields: ctx, params
func (_m *MockClient) Configuration(ctx context.Context, params *protocol.ConfigurationParams) ([]interface{}, error) {
	ret := _m.Called(ctx, params)

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

	var r0 []interface{}
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.ConfigurationParams) ([]interface{}, error)); ok {
		return rf(ctx, params)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.ConfigurationParams) []interface{}); ok {
		r0 = rf(ctx, params)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]interface{})
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *protocol.ConfigurationParams) error); ok {
		r1 = rf(ctx, params)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Configuration is a helper method to define mock.On call
//   - ctx context.Context
//   - params *protocol.ConfigurationParams
func (_e *MockClient_Expecter) Configuration(ctx interface{}, params interface{}) *MockClient_Configuration_Call {
	return &MockClient_Configuration_Call{Call: _e.mock.On("Configuration", ctx, params)}
}

func (_c *MockClient_Configuration_Call) Run(run func(ctx context.Context, params *protocol.ConfigurationParams)) *MockClient_Configuration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*protocol.ConfigurationParams))
	})
	return _c
}

func (_c *MockClient_Configuration_Call) Return(result []interface{}, err error) *MockClient_Configuration_Call {
	_c.Call.Return(result, err)
	return _c
}

func (_c *MockClient_Configuration_Call) RunAndReturn(run func(context.Context, *protocol.ConfigurationParams) ([]interface{}, error)) *MockClient_Configuration_Call {
	_c.Call.Return(run)
	return _c
}

// LogMessage provides a mock function with given fields: ctx, params
func (_m *MockClient) LogMessage(ctx context.Context, params *protocol.LogMessageParams) error {
	ret := _m.Called(ctx, params)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.LogMessageParams) error); ok {
		r0 = rf(ctx, params)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// LogMessage is a helper method to define mock.On call
//   - ctx context.Context
//   - params *protocol.LogMessageParams
func (_e *MockClient_Expecter) LogMessage(ctx interface{}, params interface{}) *MockClient_LogMessage_Call {
	return &MockClient_LogMessage_Call{Call: _e.mock.On("LogMessage", ctx, params)}
}

func (_c *MockClient_LogMessage_Call) Run(run func(ctx context.Context, params *protocol.LogMessageParams)) *MockClient_LogMessage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*protocol.LogMessageParams))
	})
	return _c
}

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

func (_c *MockClient_LogMessage_Call) RunAndReturn(run func(context.Context, *protocol.LogMessageParams) error) *MockClient_LogMessage_Call {
	_c.Call.Return(run)
	return _c
}

// Progress provides a mock function with given fields: ctx, params
func (_m *MockClient) Progress(ctx context.Context, params *protocol.ProgressParams) error {
	ret := _m.Called(ctx, params)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.ProgressParams) error); ok {
		r0 = rf(ctx, params)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Progress is a helper method to define mock.On call
//   - ctx context.Context
//   - params *protocol.ProgressParams
func (_e *MockClient_Expecter) Progress(ctx interface{}, params interface{}) *MockClient_Progress_Call {
	return &MockClient_Progress_Call{Call: _e.mock.On("Progress", ctx, params)}
}

func (_c *MockClient_Progress_Call) Run(run func(ctx context.Context, params *protocol.ProgressParams)) *MockClient_Progress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*protocol.ProgressParams))
	})
	return _c
}

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

func (_c *MockClient_Progress_Call) RunAndReturn(run func(context.Context, *protocol.ProgressParams) error) *MockClient_Progress_Call {
	_c.Call.Return(run)
	return _c
}

// PublishDiagnostics provides a mock function with given fields: ctx, params
func (_m *MockClient) PublishDiagnostics(ctx context.Context, params *protocol.PublishDiagnosticsParams) error {
	ret := _m.Called(ctx, params)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.PublishDiagnosticsParams) error); ok {
		r0 = rf(ctx, params)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// PublishDiagnostics is a helper method to define mock.On call
//   - ctx context.Context
//   - params *protocol.PublishDiagnosticsParams
func (_e *MockClient_Expecter) PublishDiagnostics(ctx interface{}, params interface{}) *MockClient_PublishDiagnostics_Call {
	return &MockClient_PublishDiagnostics_Call{Call: _e.mock.On("PublishDiagnostics", ctx, params)}
}

func (_c *MockClient_PublishDiagnostics_Call) Run(run func(ctx context.Context, params *protocol.PublishDiagnosticsParams)) *MockClient_PublishDiagnostics_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*protocol.PublishDiagnosticsParams))
	})
	return _c
}

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

func (_c *MockClient_PublishDiagnostics_Call) RunAndReturn(run func(context.Context, *protocol.PublishDiagnosticsParams) error) *MockClient_PublishDiagnostics_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterCapability provides a mock function with given fields: ctx, params
func (_m *MockClient) RegisterCapability(ctx context.Context, params *protocol.RegistrationParams) error {
	ret := _m.Called(ctx, params)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.RegistrationParams) error); ok {
		r0 = rf(ctx, params)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterCapability is a helper method to define mock.On call
//   - ctx context.Context
//   - params *protocol.RegistrationParams
func (_e *MockClient_Expecter) RegisterCapability(ctx interface{}, params interface{}) *MockClient_RegisterCapability_Call {
	return &MockClient_RegisterCapability_Call{Call: _e.mock.On("RegisterCapability", ctx, params)}
}

func (_c *MockClient_RegisterCapability_Call) Run(run func(ctx context.Context, params *protocol.RegistrationParams)) *MockClient_RegisterCapability_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*protocol.RegistrationParams))
	})
	return _c
}

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

func (_c *MockClient_RegisterCapability_Call) RunAndReturn(run func(context.Context, *protocol.RegistrationParams) error) *MockClient_RegisterCapability_Call {
	_c.Call.Return(run)
	return _c
}

// ShowMessage provides a mock function with given fields: ctx, params
func (_m *MockClient) ShowMessage(ctx context.Context, params *protocol.ShowMessageParams) error {
	ret := _m.Called(ctx, params)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.ShowMessageParams) error); ok {
		r0 = rf(ctx, params)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// ShowMessage is a helper method to define mock.On call
//   - ctx context.Context
//   - params *protocol.ShowMessageParams
func (_e *MockClient_Expecter) ShowMessage(ctx interface{}, params interface{}) *MockClient_ShowMessage_Call {
	return &MockClient_ShowMessage_Call{Call: _e.mock.On("ShowMessage", ctx, params)}
}

func (_c *MockClient_ShowMessage_Call) Run(run func(ctx context.Context, params *protocol.ShowMessageParams)) *MockClient_ShowMessage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*protocol.ShowMessageParams))
	})
	return _c
}

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

func (_c *MockClient_ShowMessage_Call) RunAndReturn(run func(context.Context, *protocol.ShowMessageParams) error) *MockClient_ShowMessage_Call {
	_c.Call.Return(run)
	return _c
}

// ShowMessageRequest provides a mock function with given fields: ctx, params
func (_m *MockClient) ShowMessageRequest(ctx context.Context, params *protocol.ShowMessageRequestParams) (*protocol.MessageActionItem, error) {
	ret := _m.Called(ctx, params)

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

	var r0 *protocol.MessageActionItem
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.ShowMessageRequestParams) (*protocol.MessageActionItem, error)); ok {
		return rf(ctx, params)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.ShowMessageRequestParams) *protocol.MessageActionItem); ok {
		r0 = rf(ctx, params)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*protocol.MessageActionItem)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *protocol.ShowMessageRequestParams) error); ok {
		r1 = rf(ctx, params)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ShowMessageRequest is a helper method to define mock.On call
//   - ctx context.Context
//   - params *protocol.ShowMessageRequestParams
func (_e *MockClient_Expecter) ShowMessageRequest(ctx interface{}, params interface{}) *MockClient_ShowMessageRequest_Call {
	return &MockClient_ShowMessageRequest_Call{Call: _e.mock.On("ShowMessageRequest", ctx, params)}
}

func (_c *MockClient_ShowMessageRequest_Call) Run(run func(ctx context.Context, params *protocol.ShowMessageRequestParams)) *MockClient_ShowMessageRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*protocol.ShowMessageRequestParams))
	})
	return _c
}

func (_c *MockClient_ShowMessageRequest_Call) Return(result *protocol.MessageActionItem, err error) *MockClient_ShowMessageRequest_Call {
	_c.Call.Return(result, err)
	return _c
}

func (_c *MockClient_ShowMessageRequest_Call) RunAndReturn(run func(context.Context, *protocol.ShowMessageRequestParams) (*protocol.MessageActionItem, error)) *MockClient_ShowMessageRequest_Call {
	_c.Call.Return(run)
	return _c
}

// Telemetry provides a mock function with given fields: ctx, params
func (_m *MockClient) Telemetry(ctx context.Context, params interface{}) error {
	ret := _m.Called(ctx, params)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, interface{}) error); ok {
		r0 = rf(ctx, params)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Telemetry is a helper method to define mock.On call
//   - ctx context.Context
//   - params interface{}
func (_e *MockClient_Expecter) Telemetry(ctx interface{}, params interface{}) *MockClient_Telemetry_Call {
	return &MockClient_Telemetry_Call{Call: _e.mock.On("Telemetry", ctx, params)}
}

func (_c *MockClient_Telemetry_Call) Run(run func(ctx context.Context, params interface{})) *MockClient_Telemetry_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(interface{}))
	})
	return _c
}

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

func (_c *MockClient_Telemetry_Call) RunAndReturn(run func(context.Context, interface{}) error) *MockClient_Telemetry_Call {
	_c.Call.Return(run)
	return _c
}

// UnregisterCapability provides a mock function with given fields: ctx, params
func (_m *MockClient) UnregisterCapability(ctx context.Context, params *protocol.UnregistrationParams) error {
	ret := _m.Called(ctx, params)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.UnregistrationParams) error); ok {
		r0 = rf(ctx, params)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// UnregisterCapability is a helper method to define mock.On call
//   - ctx context.Context
//   - params *protocol.UnregistrationParams
func (_e *MockClient_Expecter) UnregisterCapability(ctx interface{}, params interface{}) *MockClient_UnregisterCapability_Call {
	return &MockClient_UnregisterCapability_Call{Call: _e.mock.On("UnregisterCapability", ctx, params)}
}

func (_c *MockClient_UnregisterCapability_Call) Run(run func(ctx context.Context, params *protocol.UnregistrationParams)) *MockClient_UnregisterCapability_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*protocol.UnregistrationParams))
	})
	return _c
}

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

func (_c *MockClient_UnregisterCapability_Call) RunAndReturn(run func(context.Context, *protocol.UnregistrationParams) error) *MockClient_UnregisterCapability_Call {
	_c.Call.Return(run)
	return _c
}

// WorkDoneProgressCreate provides a mock function with given fields: ctx, params
func (_m *MockClient) WorkDoneProgressCreate(ctx context.Context, params *protocol.WorkDoneProgressCreateParams) error {
	ret := _m.Called(ctx, params)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.WorkDoneProgressCreateParams) error); ok {
		r0 = rf(ctx, params)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// WorkDoneProgressCreate is a helper method to define mock.On call
//   - ctx context.Context
//   - params *protocol.WorkDoneProgressCreateParams
func (_e *MockClient_Expecter) WorkDoneProgressCreate(ctx interface{}, params interface{}) *MockClient_WorkDoneProgressCreate_Call {
	return &MockClient_WorkDoneProgressCreate_Call{Call: _e.mock.On("WorkDoneProgressCreate", ctx, params)}
}

func (_c *MockClient_WorkDoneProgressCreate_Call) Run(run func(ctx context.Context, params *protocol.WorkDoneProgressCreateParams)) *MockClient_WorkDoneProgressCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*protocol.WorkDoneProgressCreateParams))
	})
	return _c
}

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

func (_c *MockClient_WorkDoneProgressCreate_Call) RunAndReturn(run func(context.Context, *protocol.WorkDoneProgressCreateParams) error) *MockClient_WorkDoneProgressCreate_Call {
	_c.Call.Return(run)
	return _c
}

// WorkspaceFolders provides a mock function with given fields: ctx
func (_m *MockClient) WorkspaceFolders(ctx context.Context) ([]protocol.WorkspaceFolder, error) {
	ret := _m.Called(ctx)

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

	var r0 []protocol.WorkspaceFolder
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]protocol.WorkspaceFolder, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []protocol.WorkspaceFolder); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]protocol.WorkspaceFolder)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// WorkspaceFolders is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockClient_Expecter) WorkspaceFolders(ctx interface{}) *MockClient_WorkspaceFolders_Call {
	return &MockClient_WorkspaceFolders_Call{Call: _e.mock.On("WorkspaceFolders", ctx)}
}

func (_c *MockClient_WorkspaceFolders_Call) Run(run func(ctx context.Context)) *MockClient_WorkspaceFolders_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockClient_WorkspaceFolders_Call) Return(result []protocol.WorkspaceFolder, err error) *MockClient_WorkspaceFolders_Call {
	_c.Call.Return(result, err)
	return _c
}

func (_c *MockClient_WorkspaceFolders_Call) RunAndReturn(run func(context.Context) ([]protocol.WorkspaceFolder, error)) *MockClient_WorkspaceFolders_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockClient creates a new instance of MockClient. 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 NewMockClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockClient {
	mock := &MockClient{}
	mock.Mock.Test(t)

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

	return mock
}
