// Code generated by MockGen. DO NOT EDIT.
// Source: internal/dal/repository/st_category.go
//
// Generated by this command:
//
//	mockgen -source=internal/dal/repository/st_category.go -destination internal/dal/repository/st_category.mockgen.go -package=repository
//

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

import (
	context "context"
	reflect "reflect"
	time "time"

	model "github.com/ch3nnn/webstack-go/internal/dal/model"
	gomock "go.uber.org/mock/gomock"
	gen "gorm.io/gen"
	field "gorm.io/gen/field"
)

// MockIStCategoryDao is a mock of IStCategoryDao interface.
type MockIStCategoryDao struct {
	ctrl     *gomock.Controller
	recorder *MockIStCategoryDaoMockRecorder
	isgomock struct{}
}

// MockIStCategoryDaoMockRecorder is the mock recorder for MockIStCategoryDao.
type MockIStCategoryDaoMockRecorder struct {
	mock *MockIStCategoryDao
}

// NewMockIStCategoryDao creates a new mock instance.
func NewMockIStCategoryDao(ctrl *gomock.Controller) *MockIStCategoryDao {
	mock := &MockIStCategoryDao{ctrl: ctrl}
	mock.recorder = &MockIStCategoryDaoMockRecorder{mock}
	return mock
}

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

// WhereByCreatedAt mocks base method.
func (m *MockIStCategoryDao) WhereByCreatedAt(createdAt time.Time) func(gen.Dao) gen.Dao {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WhereByCreatedAt", createdAt)
	ret0, _ := ret[0].(func(gen.Dao) gen.Dao)
	return ret0
}

// WhereByCreatedAt indicates an expected call of WhereByCreatedAt.
func (mr *MockIStCategoryDaoMockRecorder) WhereByCreatedAt(createdAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WhereByCreatedAt", reflect.TypeOf((*MockIStCategoryDao)(nil).WhereByCreatedAt), createdAt)
}

// WhereByDeletedAt mocks base method.
func (m *MockIStCategoryDao) WhereByDeletedAt(deletedAt time.Time) func(gen.Dao) gen.Dao {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WhereByDeletedAt", deletedAt)
	ret0, _ := ret[0].(func(gen.Dao) gen.Dao)
	return ret0
}

// WhereByDeletedAt indicates an expected call of WhereByDeletedAt.
func (mr *MockIStCategoryDaoMockRecorder) WhereByDeletedAt(deletedAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WhereByDeletedAt", reflect.TypeOf((*MockIStCategoryDao)(nil).WhereByDeletedAt), deletedAt)
}

// WhereByID mocks base method.
func (m *MockIStCategoryDao) WhereByID(id int) func(gen.Dao) gen.Dao {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WhereByID", id)
	ret0, _ := ret[0].(func(gen.Dao) gen.Dao)
	return ret0
}

// WhereByID indicates an expected call of WhereByID.
func (mr *MockIStCategoryDaoMockRecorder) WhereByID(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WhereByID", reflect.TypeOf((*MockIStCategoryDao)(nil).WhereByID), id)
}

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

// WhereByIcon indicates an expected call of WhereByIcon.
func (mr *MockIStCategoryDaoMockRecorder) WhereByIcon(icon any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WhereByIcon", reflect.TypeOf((*MockIStCategoryDao)(nil).WhereByIcon), icon)
}

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

// WhereByIsUsed indicates an expected call of WhereByIsUsed.
func (mr *MockIStCategoryDaoMockRecorder) WhereByIsUsed(isUsed any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WhereByIsUsed", reflect.TypeOf((*MockIStCategoryDao)(nil).WhereByIsUsed), isUsed)
}

// WhereByLevel mocks base method.
func (m *MockIStCategoryDao) WhereByLevel(level int32) func(gen.Dao) gen.Dao {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WhereByLevel", level)
	ret0, _ := ret[0].(func(gen.Dao) gen.Dao)
	return ret0
}

// WhereByLevel indicates an expected call of WhereByLevel.
func (mr *MockIStCategoryDaoMockRecorder) WhereByLevel(level any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WhereByLevel", reflect.TypeOf((*MockIStCategoryDao)(nil).WhereByLevel), level)
}

// WhereByParentID mocks base method.
func (m *MockIStCategoryDao) WhereByParentID(parentId int) func(gen.Dao) gen.Dao {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WhereByParentID", parentId)
	ret0, _ := ret[0].(func(gen.Dao) gen.Dao)
	return ret0
}

// WhereByParentID indicates an expected call of WhereByParentID.
func (mr *MockIStCategoryDaoMockRecorder) WhereByParentID(parentId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WhereByParentID", reflect.TypeOf((*MockIStCategoryDao)(nil).WhereByParentID), parentId)
}

// WhereBySort mocks base method.
func (m *MockIStCategoryDao) WhereBySort(sort int) func(gen.Dao) gen.Dao {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WhereBySort", sort)
	ret0, _ := ret[0].(func(gen.Dao) gen.Dao)
	return ret0
}

// WhereBySort indicates an expected call of WhereBySort.
func (mr *MockIStCategoryDaoMockRecorder) WhereBySort(sort any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WhereBySort", reflect.TypeOf((*MockIStCategoryDao)(nil).WhereBySort), sort)
}

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

// WhereByTitle indicates an expected call of WhereByTitle.
func (mr *MockIStCategoryDaoMockRecorder) WhereByTitle(title any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WhereByTitle", reflect.TypeOf((*MockIStCategoryDao)(nil).WhereByTitle), title)
}

// WhereByUpdatedAt mocks base method.
func (m *MockIStCategoryDao) WhereByUpdatedAt(updatedAt time.Time) func(gen.Dao) gen.Dao {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WhereByUpdatedAt", updatedAt)
	ret0, _ := ret[0].(func(gen.Dao) gen.Dao)
	return ret0
}

// WhereByUpdatedAt indicates an expected call of WhereByUpdatedAt.
func (mr *MockIStCategoryDaoMockRecorder) WhereByUpdatedAt(updatedAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WhereByUpdatedAt", reflect.TypeOf((*MockIStCategoryDao)(nil).WhereByUpdatedAt), updatedAt)
}

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

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

// MockiCustomGenStCategoryFunc is a mock of iCustomGenStCategoryFunc interface.
type MockiCustomGenStCategoryFunc struct {
	ctrl     *gomock.Controller
	recorder *MockiCustomGenStCategoryFuncMockRecorder
	isgomock struct{}
}

// MockiCustomGenStCategoryFuncMockRecorder is the mock recorder for MockiCustomGenStCategoryFunc.
type MockiCustomGenStCategoryFuncMockRecorder struct {
	mock *MockiCustomGenStCategoryFunc
}

// NewMockiCustomGenStCategoryFunc creates a new mock instance.
func NewMockiCustomGenStCategoryFunc(ctrl *gomock.Controller) *MockiCustomGenStCategoryFunc {
	mock := &MockiCustomGenStCategoryFunc{ctrl: ctrl}
	mock.recorder = &MockiCustomGenStCategoryFuncMockRecorder{mock}
	return mock
}

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

// Create mocks base method.
func (m_2 *MockiCustomGenStCategoryFunc) Create(m *model.StCategory) (*model.StCategory, error) {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "Create", m)
	ret0, _ := ret[0].(*model.StCategory)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Create indicates an expected call of Create.
func (mr *MockiCustomGenStCategoryFuncMockRecorder) Create(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockiCustomGenStCategoryFunc)(nil).Create), m)
}

// Delete mocks base method.
func (m *MockiCustomGenStCategoryFunc) Delete(whereFunc ...func(gen.Dao) gen.Dao) error {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range whereFunc {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Delete", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockiCustomGenStCategoryFuncMockRecorder) Delete(whereFunc ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockiCustomGenStCategoryFunc)(nil).Delete), whereFunc...)
}

// DeletePhysical mocks base method.
func (m *MockiCustomGenStCategoryFunc) DeletePhysical(whereFunc ...func(gen.Dao) gen.Dao) error {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range whereFunc {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePhysical", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeletePhysical indicates an expected call of DeletePhysical.
func (mr *MockiCustomGenStCategoryFuncMockRecorder) DeletePhysical(whereFunc ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePhysical", reflect.TypeOf((*MockiCustomGenStCategoryFunc)(nil).DeletePhysical), whereFunc...)
}

// FindAll mocks base method.
func (m *MockiCustomGenStCategoryFunc) FindAll(whereFunc ...func(gen.Dao) gen.Dao) ([]*model.StCategory, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range whereFunc {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FindAll", varargs...)
	ret0, _ := ret[0].([]*model.StCategory)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindAll indicates an expected call of FindAll.
func (mr *MockiCustomGenStCategoryFuncMockRecorder) FindAll(whereFunc ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindAll", reflect.TypeOf((*MockiCustomGenStCategoryFunc)(nil).FindAll), whereFunc...)
}

// FindAllOrderBySort mocks base method.
func (m *MockiCustomGenStCategoryFunc) FindAllOrderBySort(orderColumn field.Expr, whereFunc ...func(gen.Dao) gen.Dao) ([]*model.StCategory, error) {
	m.ctrl.T.Helper()
	varargs := []any{orderColumn}
	for _, a := range whereFunc {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FindAllOrderBySort", varargs...)
	ret0, _ := ret[0].([]*model.StCategory)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindAllOrderBySort indicates an expected call of FindAllOrderBySort.
func (mr *MockiCustomGenStCategoryFuncMockRecorder) FindAllOrderBySort(orderColumn any, whereFunc ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{orderColumn}, whereFunc...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindAllOrderBySort", reflect.TypeOf((*MockiCustomGenStCategoryFunc)(nil).FindAllOrderBySort), varargs...)
}

// FindCount mocks base method.
func (m *MockiCustomGenStCategoryFunc) FindCount(whereFunc ...func(gen.Dao) gen.Dao) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range whereFunc {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FindCount", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindCount indicates an expected call of FindCount.
func (mr *MockiCustomGenStCategoryFuncMockRecorder) FindCount(whereFunc ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindCount", reflect.TypeOf((*MockiCustomGenStCategoryFunc)(nil).FindCount), whereFunc...)
}

// FindOne mocks base method.
func (m *MockiCustomGenStCategoryFunc) FindOne(whereFunc ...func(gen.Dao) gen.Dao) (*model.StCategory, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range whereFunc {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FindOne", varargs...)
	ret0, _ := ret[0].(*model.StCategory)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindOne indicates an expected call of FindOne.
func (mr *MockiCustomGenStCategoryFuncMockRecorder) FindOne(whereFunc ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOne", reflect.TypeOf((*MockiCustomGenStCategoryFunc)(nil).FindOne), whereFunc...)
}

// FindPage mocks base method.
func (m *MockiCustomGenStCategoryFunc) FindPage(page, pageSize int, orderColumns []field.Expr, whereFunc ...func(gen.Dao) gen.Dao) ([]*model.StCategory, int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{page, pageSize, orderColumns}
	for _, a := range whereFunc {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FindPage", varargs...)
	ret0, _ := ret[0].([]*model.StCategory)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FindPage indicates an expected call of FindPage.
func (mr *MockiCustomGenStCategoryFuncMockRecorder) FindPage(page, pageSize, orderColumns any, whereFunc ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{page, pageSize, orderColumns}, whereFunc...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindPage", reflect.TypeOf((*MockiCustomGenStCategoryFunc)(nil).FindPage), varargs...)
}

// Scan mocks base method.
func (m *MockiCustomGenStCategoryFunc) Scan(result any, whereFunc ...func(gen.Dao) gen.Dao) error {
	m.ctrl.T.Helper()
	varargs := []any{result}
	for _, a := range whereFunc {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Scan", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Scan indicates an expected call of Scan.
func (mr *MockiCustomGenStCategoryFuncMockRecorder) Scan(result any, whereFunc ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{result}, whereFunc...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockiCustomGenStCategoryFunc)(nil).Scan), varargs...)
}

// ScanPage mocks base method.
func (m *MockiCustomGenStCategoryFunc) ScanPage(page, pageSize int, orderColumns []field.Expr, result any, whereFunc ...func(gen.Dao) gen.Dao) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{page, pageSize, orderColumns, result}
	for _, a := range whereFunc {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ScanPage", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ScanPage indicates an expected call of ScanPage.
func (mr *MockiCustomGenStCategoryFuncMockRecorder) ScanPage(page, pageSize, orderColumns, result any, whereFunc ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{page, pageSize, orderColumns, result}, whereFunc...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanPage", reflect.TypeOf((*MockiCustomGenStCategoryFunc)(nil).ScanPage), varargs...)
}

// Update mocks base method.
func (m *MockiCustomGenStCategoryFunc) Update(v any, whereFunc ...func(gen.Dao) gen.Dao) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{v}
	for _, a := range whereFunc {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Update", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Update indicates an expected call of Update.
func (mr *MockiCustomGenStCategoryFuncMockRecorder) Update(v any, whereFunc ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{v}, whereFunc...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockiCustomGenStCategoryFunc)(nil).Update), varargs...)
}
