// Code generated by MockGen. DO NOT EDIT.
// Source: pkg/zcore/model/model.go
//
// Generated by this command:
//
//	mockgen -source pkg/zcore/model/model.go -destination pkg/zcore/model/mock_gen.go -package model
//

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

import (
	context "context"
	querier "myexampleapp/pkg/zgen/querier"
	reflect "reflect"

	pgx "github.com/jackc/pgx/v5"
	gomock "go.uber.org/mock/gomock"
)

// MockModelInterface is a mock of ModelInterface interface.
type MockModelInterface struct {
	ctrl     *gomock.Controller
	recorder *MockModelInterfaceMockRecorder
	isgomock struct{}
}

// MockModelInterfaceMockRecorder is the mock recorder for MockModelInterface.
type MockModelInterfaceMockRecorder struct {
	mock *MockModelInterface
}

// NewMockModelInterface creates a new mock instance.
func NewMockModelInterface(ctrl *gomock.Controller) *MockModelInterface {
	mock := &MockModelInterface{ctrl: ctrl}
	mock.recorder = &MockModelInterfaceMockRecorder{mock}
	return mock
}

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

// Close mocks base method.
func (m *MockModelInterface) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

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

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

// GetCounter indicates an expected call of GetCounter.
func (mr *MockModelInterfaceMockRecorder) GetCounter(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCounter", reflect.TypeOf((*MockModelInterface)(nil).GetCounter), ctx)
}

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

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

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

// IncrementCounter indicates an expected call of IncrementCounter.
func (mr *MockModelInterfaceMockRecorder) IncrementCounter(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrementCounter", reflect.TypeOf((*MockModelInterface)(nil).IncrementCounter), ctx)
}

// RunTransaction mocks base method.
func (m *MockModelInterface) RunTransaction(ctx context.Context, f func(ModelInterface) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RunTransaction", ctx, f)
	ret0, _ := ret[0].(error)
	return ret0
}

// RunTransaction indicates an expected call of RunTransaction.
func (mr *MockModelInterfaceMockRecorder) RunTransaction(ctx, f any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunTransaction", reflect.TypeOf((*MockModelInterface)(nil).RunTransaction), ctx, f)
}

// RunTransactionWithTx mocks base method.
func (m *MockModelInterface) RunTransactionWithTx(ctx context.Context, f func(pgx.Tx, ModelInterface) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RunTransactionWithTx", ctx, f)
	ret0, _ := ret[0].(error)
	return ret0
}

// RunTransactionWithTx indicates an expected call of RunTransactionWithTx.
func (mr *MockModelInterfaceMockRecorder) RunTransactionWithTx(ctx, f any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunTransactionWithTx", reflect.TypeOf((*MockModelInterface)(nil).RunTransactionWithTx), ctx, f)
}

// SpawnWithTx mocks base method.
func (m *MockModelInterface) SpawnWithTx(tx pgx.Tx) ModelInterface {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SpawnWithTx", tx)
	ret0, _ := ret[0].(ModelInterface)
	return ret0
}

// SpawnWithTx indicates an expected call of SpawnWithTx.
func (mr *MockModelInterfaceMockRecorder) SpawnWithTx(tx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpawnWithTx", reflect.TypeOf((*MockModelInterface)(nil).SpawnWithTx), tx)
}
