// Code generated by MockGen. DO NOT EDIT.
// Source: gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/module/modagent (interfaces: API,Factory,Module,RPCAPI)
//
// Generated by this command:
//
//	mockgen -typed -destination api.go -package mock_modagent gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/module/modagent API,Factory,Module,RPCAPI
//

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

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

	api "gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/api"
	modagent "gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/module/modagent"
	retry "gitlab.com/gitlab-org/cluster-integration/tunnel/tool/retry"
	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
}

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

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

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

// Return rewrite *gomock.Call.Return
func (c *MockAPIGetAgentKeyCall) Return(arg0 api.AgentKey, arg1 error) *MockAPIGetAgentKeyCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAPIGetAgentKeyCall) Do(f func(context.Context) (api.AgentKey, error)) *MockAPIGetAgentKeyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAPIGetAgentKeyCall) DoAndReturn(f func(context.Context) (api.AgentKey, error)) *MockAPIGetAgentKeyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetGitLabExternalURL mocks base method.
func (m *MockAPI) GetGitLabExternalURL(ctx context.Context) (url.URL, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGitLabExternalURL", ctx)
	ret0, _ := ret[0].(url.URL)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// Return rewrite *gomock.Call.Return
func (c *MockAPIGetGitLabExternalURLCall) Return(arg0 url.URL, arg1 error) *MockAPIGetGitLabExternalURLCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAPIGetGitLabExternalURLCall) Do(f func(context.Context) (url.URL, error)) *MockAPIGetGitLabExternalURLCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAPIGetGitLabExternalURLCall) DoAndReturn(f func(context.Context) (url.URL, error)) *MockAPIGetGitLabExternalURLCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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
}

// MakeGitLabRequest mocks base method.
func (m *MockAPI) MakeGitLabRequest(ctx context.Context, path string, opts ...modagent.GitLabRequestOption) (*modagent.GitLabResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, path}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MakeGitLabRequest", varargs...)
	ret0, _ := ret[0].(*modagent.GitLabResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MakeGitLabRequest indicates an expected call of MakeGitLabRequest.
func (mr *MockAPIMockRecorder) MakeGitLabRequest(ctx, path any, opts ...any) *MockAPIMakeGitLabRequestCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, path}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeGitLabRequest", reflect.TypeOf((*MockAPI)(nil).MakeGitLabRequest), varargs...)
	return &MockAPIMakeGitLabRequestCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAPIMakeGitLabRequestCall) Return(arg0 *modagent.GitLabResponse, arg1 error) *MockAPIMakeGitLabRequestCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAPIMakeGitLabRequestCall) Do(f func(context.Context, string, ...modagent.GitLabRequestOption) (*modagent.GitLabResponse, error)) *MockAPIMakeGitLabRequestCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAPIMakeGitLabRequestCall) DoAndReturn(f func(context.Context, string, ...modagent.GitLabRequestOption) (*modagent.GitLabResponse, error)) *MockAPIMakeGitLabRequestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// TryGetAgentKey mocks base method.
func (m *MockAPI) TryGetAgentKey() (api.AgentKey, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TryGetAgentKey")
	ret0, _ := ret[0].(api.AgentKey)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

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

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

// Return rewrite *gomock.Call.Return
func (c *MockAPITryGetAgentKeyCall) Return(arg0 api.AgentKey, arg1 bool) *MockAPITryGetAgentKeyCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAPITryGetAgentKeyCall) Do(f func() (api.AgentKey, bool)) *MockAPITryGetAgentKeyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAPITryGetAgentKeyCall) DoAndReturn(f func() (api.AgentKey, bool)) *MockAPITryGetAgentKeyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockFactory is a mock of Factory interface.
type MockFactory[CF any, CM any] struct {
	ctrl     *gomock.Controller
	recorder *MockFactoryMockRecorder[CF, CM]
	isgomock struct{}
}

// MockFactoryMockRecorder is the mock recorder for MockFactory.
type MockFactoryMockRecorder[CF any, CM any] struct {
	mock *MockFactory[CF, CM]
}

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

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

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

// IsProducingLeaderModules indicates an expected call of IsProducingLeaderModules.
func (mr *MockFactoryMockRecorder[CF, CM]) IsProducingLeaderModules() *MockFactoryIsProducingLeaderModulesCall[CF, CM] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsProducingLeaderModules", reflect.TypeOf((*MockFactory[CF, CM])(nil).IsProducingLeaderModules))
	return &MockFactoryIsProducingLeaderModulesCall[CF, CM]{Call: call}
}

// MockFactoryIsProducingLeaderModulesCall wrap *gomock.Call
type MockFactoryIsProducingLeaderModulesCall[CF any, CM any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFactoryIsProducingLeaderModulesCall[CF, CM]) Return(arg0 bool) *MockFactoryIsProducingLeaderModulesCall[CF, CM] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFactoryIsProducingLeaderModulesCall[CF, CM]) Do(f func() bool) *MockFactoryIsProducingLeaderModulesCall[CF, CM] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFactoryIsProducingLeaderModulesCall[CF, CM]) DoAndReturn(f func() bool) *MockFactoryIsProducingLeaderModulesCall[CF, CM] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Name mocks base method.
func (m *MockFactory[CF, CM]) 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[CF, CM]) Name() *MockFactoryNameCall[CF, CM] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockFactory[CF, CM])(nil).Name))
	return &MockFactoryNameCall[CF, CM]{Call: call}
}

// MockFactoryNameCall wrap *gomock.Call
type MockFactoryNameCall[CF any, CM any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFactoryNameCall[CF, CM]) Return(arg0 string) *MockFactoryNameCall[CF, CM] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFactoryNameCall[CF, CM]) Do(f func() string) *MockFactoryNameCall[CF, CM] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFactoryNameCall[CF, CM]) DoAndReturn(f func() string) *MockFactoryNameCall[CF, CM] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

// MockFactoryNewCall wrap *gomock.Call
type MockFactoryNewCall[CF any, CM any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFactoryNewCall[CF, CM]) Return(arg0 modagent.Module[CM], arg1 error) *MockFactoryNewCall[CF, CM] {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFactoryNewCall[CF, CM]) Do(f func(CF) (modagent.Module[CM], error)) *MockFactoryNewCall[CF, CM] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFactoryNewCall[CF, CM]) DoAndReturn(f func(CF) (modagent.Module[CM], error)) *MockFactoryNewCall[CF, CM] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// MockModuleMockRecorder is the mock recorder for MockModule.
type MockModuleMockRecorder[CM any] struct {
	mock *MockModule[CM]
}

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

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

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

// DefaultAndValidateConfiguration indicates an expected call of DefaultAndValidateConfiguration.
func (mr *MockModuleMockRecorder[CM]) DefaultAndValidateConfiguration(cfg any) *MockModuleDefaultAndValidateConfigurationCall[CM] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultAndValidateConfiguration", reflect.TypeOf((*MockModule[CM])(nil).DefaultAndValidateConfiguration), cfg)
	return &MockModuleDefaultAndValidateConfigurationCall[CM]{Call: call}
}

// MockModuleDefaultAndValidateConfigurationCall wrap *gomock.Call
type MockModuleDefaultAndValidateConfigurationCall[CM any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockModuleDefaultAndValidateConfigurationCall[CM]) Return(arg0 error) *MockModuleDefaultAndValidateConfigurationCall[CM] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockModuleDefaultAndValidateConfigurationCall[CM]) Do(f func(CM) error) *MockModuleDefaultAndValidateConfigurationCall[CM] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockModuleDefaultAndValidateConfigurationCall[CM]) DoAndReturn(f func(CM) error) *MockModuleDefaultAndValidateConfigurationCall[CM] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Name mocks base method.
func (m *MockModule[CM]) 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[CM]) Name() *MockModuleNameCall[CM] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockModule[CM])(nil).Name))
	return &MockModuleNameCall[CM]{Call: call}
}

// MockModuleNameCall wrap *gomock.Call
type MockModuleNameCall[CM any] struct {
	*gomock.Call
}

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

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

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

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

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

// MockModuleRunCall wrap *gomock.Call
type MockModuleRunCall[CM any] struct {
	*gomock.Call
}

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

// Do rewrite *gomock.Call.Do
func (c *MockModuleRunCall[CM]) Do(f func(context.Context, <-chan CM) error) *MockModuleRunCall[CM] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockModuleRunCall[CM]) DoAndReturn(f func(context.Context, <-chan CM) error) *MockModuleRunCall[CM] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockRPCAPI is a mock of RPCAPI interface.
type MockRPCAPI struct {
	ctrl     *gomock.Controller
	recorder *MockRPCAPIMockRecorder
	isgomock struct{}
}

// MockRPCAPIMockRecorder is the mock recorder for MockRPCAPI.
type MockRPCAPIMockRecorder struct {
	mock *MockRPCAPI
}

// NewMockRPCAPI creates a new mock instance.
func NewMockRPCAPI(ctrl *gomock.Controller) *MockRPCAPI {
	mock := &MockRPCAPI{ctrl: ctrl}
	mock.recorder = &MockRPCAPIMockRecorder{mock}
	return mock
}

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

// HandleIOError mocks base method.
func (m *MockRPCAPI) HandleIOError(log *slog.Logger, msg string, err error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleIOError", log, msg, err)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleIOError indicates an expected call of HandleIOError.
func (mr *MockRPCAPIMockRecorder) HandleIOError(log, msg, err any) *MockRPCAPIHandleIOErrorCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleIOError", reflect.TypeOf((*MockRPCAPI)(nil).HandleIOError), log, msg, err)
	return &MockRPCAPIHandleIOErrorCall{Call: call}
}

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

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

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

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

// HandleProcessingError mocks base method.
func (m *MockRPCAPI) HandleProcessingError(log *slog.Logger, msg string, err error, fields ...slog.Attr) {
	m.ctrl.T.Helper()
	varargs := []any{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 *MockRPCAPIMockRecorder) HandleProcessingError(log, msg, err any, fields ...any) *MockRPCAPIHandleProcessingErrorCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{log, msg, err}, fields...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleProcessingError", reflect.TypeOf((*MockRPCAPI)(nil).HandleProcessingError), varargs...)
	return &MockRPCAPIHandleProcessingErrorCall{Call: call}
}

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

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

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

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

// Log mocks base method.
func (m *MockRPCAPI) Log() *slog.Logger {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Log")
	ret0, _ := ret[0].(*slog.Logger)
	return ret0
}

// Log indicates an expected call of Log.
func (mr *MockRPCAPIMockRecorder) Log() *MockRPCAPILogCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Log", reflect.TypeOf((*MockRPCAPI)(nil).Log))
	return &MockRPCAPILogCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockRPCAPILogCall) Do(f func() *slog.Logger) *MockRPCAPILogCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRPCAPILogCall) DoAndReturn(f func() *slog.Logger) *MockRPCAPILogCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PollWithBackoff mocks base method.
func (m *MockRPCAPI) PollWithBackoff(cfg retry.PollConfig, f retry.PollWithBackoffFunc, opts ...retry.PollOption) error {
	m.ctrl.T.Helper()
	varargs := []any{cfg, f}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PollWithBackoff", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// PollWithBackoff indicates an expected call of PollWithBackoff.
func (mr *MockRPCAPIMockRecorder) PollWithBackoff(cfg, f any, opts ...any) *MockRPCAPIPollWithBackoffCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{cfg, f}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PollWithBackoff", reflect.TypeOf((*MockRPCAPI)(nil).PollWithBackoff), varargs...)
	return &MockRPCAPIPollWithBackoffCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockRPCAPIPollWithBackoffCall) Do(f func(retry.PollConfig, retry.PollWithBackoffFunc, ...retry.PollOption) error) *MockRPCAPIPollWithBackoffCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRPCAPIPollWithBackoffCall) DoAndReturn(f func(retry.PollConfig, retry.PollWithBackoffFunc, ...retry.PollOption) error) *MockRPCAPIPollWithBackoffCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
