// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/rancher/steve/pkg/sqlcache/informer (interfaces: Store)
//
// Generated by this command:
//
//	mockgen --build_flags=--mod=mod -package informer -destination ./sql_mocks_test.go github.com/rancher/steve/pkg/sqlcache/informer Store
//

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

import (
	context "context"
	sql "database/sql"
	reflect "reflect"

	db "github.com/rancher/steve/pkg/sqlcache/db"
	transaction "github.com/rancher/steve/pkg/sqlcache/db/transaction"
	gomock "go.uber.org/mock/gomock"
)

// MockStore is a mock of Store interface.
type MockStore struct {
	ctrl     *gomock.Controller
	recorder *MockStoreMockRecorder
	isgomock struct{}
}

// MockStoreMockRecorder is the mock recorder for MockStore.
type MockStoreMockRecorder struct {
	mock *MockStore
}

// NewMockStore creates a new mock instance.
func NewMockStore(ctrl *gomock.Controller) *MockStore {
	mock := &MockStore{ctrl: ctrl}
	mock.recorder = &MockStoreMockRecorder{mock}
	return mock
}

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

// Add mocks base method.
func (m *MockStore) Add(obj any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Add", obj)
	ret0, _ := ret[0].(error)
	return ret0
}

// Add indicates an expected call of Add.
func (mr *MockStoreMockRecorder) Add(obj any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockStore)(nil).Add), obj)
}

// CloseStmt mocks base method.
func (m *MockStore) CloseStmt(closable db.Closable) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseStmt", closable)
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseStmt indicates an expected call of CloseStmt.
func (mr *MockStoreMockRecorder) CloseStmt(closable any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseStmt", reflect.TypeOf((*MockStore)(nil).CloseStmt), closable)
}

// Delete mocks base method.
func (m *MockStore) Delete(obj any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", obj)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// Get mocks base method.
func (m *MockStore) Get(obj any) (any, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", obj)
	ret0, _ := ret[0].(any)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockStoreMockRecorder) Get(obj any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockStore)(nil).Get), obj)
}

// GetByKey mocks base method.
func (m *MockStore) GetByKey(key string) (any, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByKey", key)
	ret0, _ := ret[0].(any)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByKey indicates an expected call of GetByKey.
func (mr *MockStoreMockRecorder) GetByKey(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByKey", reflect.TypeOf((*MockStore)(nil).GetByKey), key)
}

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

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

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

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

// GetType mocks base method.
func (m *MockStore) GetType() reflect.Type {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetType")
	ret0, _ := ret[0].(reflect.Type)
	return ret0
}

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

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

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

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

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

// NewConnection mocks base method.
func (m *MockStore) NewConnection(isTemp bool) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewConnection", isTemp)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewConnection indicates an expected call of NewConnection.
func (mr *MockStoreMockRecorder) NewConnection(isTemp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewConnection", reflect.TypeOf((*MockStore)(nil).NewConnection), isTemp)
}

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

// Prepare indicates an expected call of Prepare.
func (mr *MockStoreMockRecorder) Prepare(stmt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Prepare", reflect.TypeOf((*MockStore)(nil).Prepare), stmt)
}

// QueryForRows mocks base method.
func (m *MockStore) QueryForRows(ctx context.Context, stmt transaction.Stmt, params ...any) (*sql.Rows, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, stmt}
	for _, a := range params {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryForRows", varargs...)
	ret0, _ := ret[0].(*sql.Rows)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryForRows indicates an expected call of QueryForRows.
func (mr *MockStoreMockRecorder) QueryForRows(ctx, stmt any, params ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, stmt}, params...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryForRows", reflect.TypeOf((*MockStore)(nil).QueryForRows), varargs...)
}

// ReadInt mocks base method.
func (m *MockStore) ReadInt(rows db.Rows) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadInt", rows)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadInt indicates an expected call of ReadInt.
func (mr *MockStoreMockRecorder) ReadInt(rows any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadInt", reflect.TypeOf((*MockStore)(nil).ReadInt), rows)
}

// ReadObjects mocks base method.
func (m *MockStore) ReadObjects(rows db.Rows, typ reflect.Type, shouldDecrypt bool) ([]any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadObjects", rows, typ, shouldDecrypt)
	ret0, _ := ret[0].([]any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadObjects indicates an expected call of ReadObjects.
func (mr *MockStoreMockRecorder) ReadObjects(rows, typ, shouldDecrypt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadObjects", reflect.TypeOf((*MockStore)(nil).ReadObjects), rows, typ, shouldDecrypt)
}

// ReadStrings mocks base method.
func (m *MockStore) ReadStrings(rows db.Rows) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadStrings", rows)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadStrings indicates an expected call of ReadStrings.
func (mr *MockStoreMockRecorder) ReadStrings(rows any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadStrings", reflect.TypeOf((*MockStore)(nil).ReadStrings), rows)
}

// ReadStrings2 mocks base method.
func (m *MockStore) ReadStrings2(rows db.Rows) ([][]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadStrings2", rows)
	ret0, _ := ret[0].([][]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadStrings2 indicates an expected call of ReadStrings2.
func (mr *MockStoreMockRecorder) ReadStrings2(rows any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadStrings2", reflect.TypeOf((*MockStore)(nil).ReadStrings2), rows)
}

// RegisterAfterAdd mocks base method.
func (m *MockStore) RegisterAfterAdd(f func(string, any, transaction.Client) error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterAfterAdd", f)
}

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

// RegisterAfterDelete mocks base method.
func (m *MockStore) RegisterAfterDelete(f func(string, any, transaction.Client) error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterAfterDelete", f)
}

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

// RegisterAfterDeleteAll mocks base method.
func (m *MockStore) RegisterAfterDeleteAll(f func(transaction.Client) error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterAfterDeleteAll", f)
}

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

// RegisterAfterUpdate mocks base method.
func (m *MockStore) RegisterAfterUpdate(f func(string, any, transaction.Client) error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterAfterUpdate", f)
}

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

// Replace mocks base method.
func (m *MockStore) Replace(arg0 []any, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Replace", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Replace indicates an expected call of Replace.
func (mr *MockStoreMockRecorder) Replace(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Replace", reflect.TypeOf((*MockStore)(nil).Replace), arg0, arg1)
}

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

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

// Update mocks base method.
func (m *MockStore) Update(obj any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", obj)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockStoreMockRecorder) Update(obj any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockStore)(nil).Update), obj)
}

// Upsert mocks base method.
func (m *MockStore) Upsert(tx transaction.Client, stmt *sql.Stmt, key string, obj any, shouldEncrypt bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Upsert", tx, stmt, key, obj, shouldEncrypt)
	ret0, _ := ret[0].(error)
	return ret0
}

// Upsert indicates an expected call of Upsert.
func (mr *MockStoreMockRecorder) Upsert(tx, stmt, key, obj, shouldEncrypt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upsert", reflect.TypeOf((*MockStore)(nil).Upsert), tx, stmt, key, obj, shouldEncrypt)
}

// WithTransaction mocks base method.
func (m *MockStore) WithTransaction(ctx context.Context, forWriting bool, f db.WithTransactionFunction) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WithTransaction", ctx, forWriting, f)
	ret0, _ := ret[0].(error)
	return ret0
}

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