// Code generated by MockGen. DO NOT EDIT.
// Source: ../../../module/modserver/api.go
//
// Generated by this command:
//
//	mockgen -typed -source ../../../module/modserver/api.go -destination api.go -package mock_modserver
//

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

import (
	context "context"
	slog "log/slog"
	reflect "reflect"

	api "gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/api"
	modserver "gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/module/modserver"
	event "gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/pkg/event"
	gomock "go.uber.org/mock/gomock"
)

// MockAPI is a mock of API interface.
type MockAPI struct {
	ctrl     *gomock.Controller
	recorder *MockAPIMockRecorder
	isgomock struct{}
}

// MockAPIMockRecorder is the mock recorder for MockAPI.
type MockAPIMockRecorder struct {
	mock *MockAPI
}

// NewMockAPI creates a new mock instance.
func NewMockAPI(ctrl *gomock.Controller) *MockAPI {
	mock := &MockAPI{ctrl: ctrl}
	mock.recorder = &MockAPIMockRecorder{mock}
	return mock
}

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

// HandleProcessingError mocks base method.
func (m *MockAPI) HandleProcessingError(ctx context.Context, log *slog.Logger, msg string, err error, fields ...slog.Attr) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, log, msg, err}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "HandleProcessingError", varargs...)
}

// HandleProcessingError indicates an expected call of HandleProcessingError.
func (mr *MockAPIMockRecorder) HandleProcessingError(ctx, log, msg, err any, fields ...any) *MockAPIHandleProcessingErrorCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, log, msg, err}, fields...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleProcessingError", reflect.TypeOf((*MockAPI)(nil).HandleProcessingError), varargs...)
	return &MockAPIHandleProcessingErrorCall{Call: call}
}

// MockAPIHandleProcessingErrorCall wrap *gomock.Call
type MockAPIHandleProcessingErrorCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockAPIHandleProcessingErrorCall) Return() *MockAPIHandleProcessingErrorCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAPIHandleProcessingErrorCall) Do(f func(context.Context, *slog.Logger, string, error, ...slog.Attr)) *MockAPIHandleProcessingErrorCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAPIHandleProcessingErrorCall) DoAndReturn(f func(context.Context, *slog.Logger, string, error, ...slog.Attr)) *MockAPIHandleProcessingErrorCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// OnGitPushEvent mocks base method.
func (m *MockAPI) OnGitPushEvent(arg0 func(*event.GitPushEvent)) func() {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnGitPushEvent", arg0)
	ret0, _ := ret[0].(func())
	return ret0
}

// OnGitPushEvent indicates an expected call of OnGitPushEvent.
func (mr *MockAPIMockRecorder) OnGitPushEvent(arg0 any) *MockAPIOnGitPushEventCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnGitPushEvent", reflect.TypeOf((*MockAPI)(nil).OnGitPushEvent), arg0)
	return &MockAPIOnGitPushEventCall{Call: call}
}

// MockAPIOnGitPushEventCall wrap *gomock.Call
type MockAPIOnGitPushEventCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockAPIOnGitPushEventCall) Return(arg0 func()) *MockAPIOnGitPushEventCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAPIOnGitPushEventCall) Do(f func(func(*event.GitPushEvent)) func()) *MockAPIOnGitPushEventCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAPIOnGitPushEventCall) DoAndReturn(f func(func(*event.GitPushEvent)) func()) *MockAPIOnGitPushEventCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockAgentInfoResolver is a mock of AgentInfoResolver interface.
type MockAgentInfoResolver struct {
	ctrl     *gomock.Controller
	recorder *MockAgentInfoResolverMockRecorder
	isgomock struct{}
}

// MockAgentInfoResolverMockRecorder is the mock recorder for MockAgentInfoResolver.
type MockAgentInfoResolverMockRecorder struct {
	mock *MockAgentInfoResolver
}

// NewMockAgentInfoResolver creates a new mock instance.
func NewMockAgentInfoResolver(ctrl *gomock.Controller) *MockAgentInfoResolver {
	mock := &MockAgentInfoResolver{ctrl: ctrl}
	mock.recorder = &MockAgentInfoResolverMockRecorder{mock}
	return mock
}

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

// Get mocks base method.
func (m *MockAgentInfoResolver) Get(ctx context.Context, agentKey api.AgentKey) (map[string]any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, agentKey)
	ret0, _ := ret[0].(map[string]any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockAgentInfoResolverMockRecorder) Get(ctx, agentKey any) *MockAgentInfoResolverGetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockAgentInfoResolver)(nil).Get), ctx, agentKey)
	return &MockAgentInfoResolverGetCall{Call: call}
}

// MockAgentInfoResolverGetCall wrap *gomock.Call
type MockAgentInfoResolverGetCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockAgentInfoResolverGetCall) Return(arg0 map[string]any, arg1 error) *MockAgentInfoResolverGetCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAgentInfoResolverGetCall) Do(f func(context.Context, api.AgentKey) (map[string]any, error)) *MockAgentInfoResolverGetCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAgentInfoResolverGetCall) DoAndReturn(f func(context.Context, api.AgentKey) (map[string]any, error)) *MockAgentInfoResolverGetCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockFactory is a mock of Factory interface.
type MockFactory struct {
	ctrl     *gomock.Controller
	recorder *MockFactoryMockRecorder
	isgomock struct{}
}

// MockFactoryMockRecorder is the mock recorder for MockFactory.
type MockFactoryMockRecorder struct {
	mock *MockFactory
}

// NewMockFactory creates a new mock instance.
func NewMockFactory(ctrl *gomock.Controller) *MockFactory {
	mock := &MockFactory{ctrl: ctrl}
	mock.recorder = &MockFactoryMockRecorder{mock}
	return mock
}

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

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

// Name indicates an expected call of Name.
func (mr *MockFactoryMockRecorder) Name() *MockFactoryNameCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockFactory)(nil).Name))
	return &MockFactoryNameCall{Call: call}
}

// MockFactoryNameCall wrap *gomock.Call
type MockFactoryNameCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFactoryNameCall) Return(arg0 string) *MockFactoryNameCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFactoryNameCall) Do(f func() string) *MockFactoryNameCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFactoryNameCall) DoAndReturn(f func() string) *MockFactoryNameCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// New indicates an expected call of New.
func (mr *MockFactoryMockRecorder) New(arg0 any) *MockFactoryNewCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "New", reflect.TypeOf((*MockFactory)(nil).New), arg0)
	return &MockFactoryNewCall{Call: call}
}

// MockFactoryNewCall wrap *gomock.Call
type MockFactoryNewCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFactoryNewCall) Return(arg0 modserver.Module, arg1 error) *MockFactoryNewCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFactoryNewCall) Do(f func(*modserver.Config) (modserver.Module, error)) *MockFactoryNewCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFactoryNewCall) DoAndReturn(f func(*modserver.Config) (modserver.Module, error)) *MockFactoryNewCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockModule is a mock of Module interface.
type MockModule struct {
	ctrl     *gomock.Controller
	recorder *MockModuleMockRecorder
	isgomock struct{}
}

// MockModuleMockRecorder is the mock recorder for MockModule.
type MockModuleMockRecorder struct {
	mock *MockModule
}

// NewMockModule creates a new mock instance.
func NewMockModule(ctrl *gomock.Controller) *MockModule {
	mock := &MockModule{ctrl: ctrl}
	mock.recorder = &MockModuleMockRecorder{mock}
	return mock
}

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

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

// Name indicates an expected call of Name.
func (mr *MockModuleMockRecorder) Name() *MockModuleNameCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockModule)(nil).Name))
	return &MockModuleNameCall{Call: call}
}

// MockModuleNameCall wrap *gomock.Call
type MockModuleNameCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockModuleNameCall) Return(arg0 string) *MockModuleNameCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockModuleNameCall) Do(f func() string) *MockModuleNameCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockModuleNameCall) DoAndReturn(f func() string) *MockModuleNameCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Run indicates an expected call of Run.
func (mr *MockModuleMockRecorder) Run(arg0 any) *MockModuleRunCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockModule)(nil).Run), arg0)
	return &MockModuleRunCall{Call: call}
}

// MockModuleRunCall wrap *gomock.Call
type MockModuleRunCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockModuleRunCall) Return(arg0 error) *MockModuleRunCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockModuleRunCall) Do(f func(context.Context) error) *MockModuleRunCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockModuleRunCall) DoAndReturn(f func(context.Context) error) *MockModuleRunCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
