package mock_models

import (
	context "context"
	reflect "reflect"

	models "github.com/cloudfoundry/go-cf-api/internal/storage/db/models"
	gomock "github.com/golang/mock/gomock"
	boil "github.com/volatiletech/sqlboiler/v4/boil"
)

type MockServiceKeyOperationUpserter struct {
	ctrl     *gomock.Controller
	recorder *MockServiceKeyOperationUpserterMockRecorder
}

type MockServiceKeyOperationUpserterMockRecorder struct {
	mock *MockServiceKeyOperationUpserter
}

func NewMockServiceKeyOperationUpserter(ctrl *gomock.Controller) *MockServiceKeyOperationUpserter {
	mock := &MockServiceKeyOperationUpserter{ctrl: ctrl}
	mock.recorder = &MockServiceKeyOperationUpserterMockRecorder{mock}
	return mock
}

func (m *MockServiceKeyOperationUpserter) EXPECT() *MockServiceKeyOperationUpserterMockRecorder {
	return m.recorder
}

func (m *MockServiceKeyOperationUpserter) Upsert(o *models.ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Upsert", o, ctx, exec, updateColumns, insertColumns)
	ret0, _ := ret[0].(error)
	return ret0
}

func (mr *MockServiceKeyOperationUpserterMockRecorder) Upsert(o, ctx, exec, updateColumns, insertColumns interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upsert", reflect.TypeOf((*MockServiceKeyOperationUpserter)(nil).Upsert), o, ctx, exec, updateColumns, insertColumns)
}

type MockServiceKeyOperationFinisher struct {
	ctrl     *gomock.Controller
	recorder *MockServiceKeyOperationFinisherMockRecorder
}

type MockServiceKeyOperationFinisherMockRecorder struct {
	mock *MockServiceKeyOperationFinisher
}

func NewMockServiceKeyOperationFinisher(ctrl *gomock.Controller) *MockServiceKeyOperationFinisher {
	mock := &MockServiceKeyOperationFinisher{ctrl: ctrl}
	mock.recorder = &MockServiceKeyOperationFinisherMockRecorder{mock}
	return mock
}

func (m *MockServiceKeyOperationFinisher) EXPECT() *MockServiceKeyOperationFinisherMockRecorder {
	return m.recorder
}

func (m *MockServiceKeyOperationFinisher) All(ctx context.Context, exec boil.ContextExecutor) (models.ServiceKeyOperationSlice, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx, exec)
	ret0, _ := ret[0].(models.ServiceKeyOperationSlice)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (mr *MockServiceKeyOperationFinisherMockRecorder) All(ctx, exec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockServiceKeyOperationFinisher)(nil).All), ctx, exec)
}

func (m *MockServiceKeyOperationFinisher) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Count", ctx, exec)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (mr *MockServiceKeyOperationFinisherMockRecorder) Count(ctx, exec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Count", reflect.TypeOf((*MockServiceKeyOperationFinisher)(nil).Count), ctx, exec)
}

func (m *MockServiceKeyOperationFinisher) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Exists", ctx, exec)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (mr *MockServiceKeyOperationFinisherMockRecorder) Exists(ctx, exec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockServiceKeyOperationFinisher)(nil).Exists), ctx, exec)
}

func (m *MockServiceKeyOperationFinisher) One(ctx context.Context, exec boil.ContextExecutor) (*models.ServiceKeyOperation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "One", ctx, exec)
	ret0, _ := ret[0].(*models.ServiceKeyOperation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (mr *MockServiceKeyOperationFinisherMockRecorder) One(ctx, exec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "One", reflect.TypeOf((*MockServiceKeyOperationFinisher)(nil).One), ctx, exec)
}

type MockServiceKeyOperationFinder struct {
	ctrl     *gomock.Controller
	recorder *MockServiceKeyOperationFinderMockRecorder
}

type MockServiceKeyOperationFinderMockRecorder struct {
	mock *MockServiceKeyOperationFinder
}

func NewMockServiceKeyOperationFinder(ctrl *gomock.Controller) *MockServiceKeyOperationFinder {
	mock := &MockServiceKeyOperationFinder{ctrl: ctrl}
	mock.recorder = &MockServiceKeyOperationFinderMockRecorder{mock}
	return mock
}

func (m *MockServiceKeyOperationFinder) EXPECT() *MockServiceKeyOperationFinderMockRecorder {
	return m.recorder
}

func (m *MockServiceKeyOperationFinder) FindServiceKeyOperation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*models.ServiceKeyOperation, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, exec, iD}
	for _, a := range selectCols {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FindServiceKeyOperation", varargs...)
	ret0, _ := ret[0].(*models.ServiceKeyOperation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (mr *MockServiceKeyOperationFinderMockRecorder) FindServiceKeyOperation(ctx, exec, iD interface{}, selectCols ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, exec, iD}, selectCols...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindServiceKeyOperation", reflect.TypeOf((*MockServiceKeyOperationFinder)(nil).FindServiceKeyOperation), varargs...)
}

type MockServiceKeyOperationInserter struct {
	ctrl     *gomock.Controller
	recorder *MockServiceKeyOperationInserterMockRecorder
}

type MockServiceKeyOperationInserterMockRecorder struct {
	mock *MockServiceKeyOperationInserter
}

func NewMockServiceKeyOperationInserter(ctrl *gomock.Controller) *MockServiceKeyOperationInserter {
	mock := &MockServiceKeyOperationInserter{ctrl: ctrl}
	mock.recorder = &MockServiceKeyOperationInserterMockRecorder{mock}
	return mock
}

func (m *MockServiceKeyOperationInserter) EXPECT() *MockServiceKeyOperationInserterMockRecorder {
	return m.recorder
}

func (m *MockServiceKeyOperationInserter) Insert(o *models.ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Insert", o, ctx, exec, columns)
	ret0, _ := ret[0].(error)
	return ret0
}

func (mr *MockServiceKeyOperationInserterMockRecorder) Insert(o, ctx, exec, columns interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Insert", reflect.TypeOf((*MockServiceKeyOperationInserter)(nil).Insert), o, ctx, exec, columns)
}

type MockServiceKeyOperationUpdater struct {
	ctrl     *gomock.Controller
	recorder *MockServiceKeyOperationUpdaterMockRecorder
}

type MockServiceKeyOperationUpdaterMockRecorder struct {
	mock *MockServiceKeyOperationUpdater
}

func NewMockServiceKeyOperationUpdater(ctrl *gomock.Controller) *MockServiceKeyOperationUpdater {
	mock := &MockServiceKeyOperationUpdater{ctrl: ctrl}
	mock.recorder = &MockServiceKeyOperationUpdaterMockRecorder{mock}
	return mock
}

func (m *MockServiceKeyOperationUpdater) EXPECT() *MockServiceKeyOperationUpdaterMockRecorder {
	return m.recorder
}

func (m *MockServiceKeyOperationUpdater) Update(o *models.ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", o, ctx, exec, columns)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (mr *MockServiceKeyOperationUpdaterMockRecorder) Update(o, ctx, exec, columns interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockServiceKeyOperationUpdater)(nil).Update), o, ctx, exec, columns)
}

func (m *MockServiceKeyOperationUpdater) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols models.M) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAll", ctx, exec, cols)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (mr *MockServiceKeyOperationUpdaterMockRecorder) UpdateAll(ctx, exec, cols interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAll", reflect.TypeOf((*MockServiceKeyOperationUpdater)(nil).UpdateAll), ctx, exec, cols)
}

func (m *MockServiceKeyOperationUpdater) UpdateAllSlice(o models.ServiceKeyOperationSlice, ctx context.Context, exec boil.ContextExecutor, cols models.M) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAllSlice", o, ctx, exec, cols)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (mr *MockServiceKeyOperationUpdaterMockRecorder) UpdateAllSlice(o, ctx, exec, cols interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAllSlice", reflect.TypeOf((*MockServiceKeyOperationUpdater)(nil).UpdateAllSlice), o, ctx, exec, cols)
}

type MockServiceKeyOperationDeleter struct {
	ctrl     *gomock.Controller
	recorder *MockServiceKeyOperationDeleterMockRecorder
}

type MockServiceKeyOperationDeleterMockRecorder struct {
	mock *MockServiceKeyOperationDeleter
}

func NewMockServiceKeyOperationDeleter(ctrl *gomock.Controller) *MockServiceKeyOperationDeleter {
	mock := &MockServiceKeyOperationDeleter{ctrl: ctrl}
	mock.recorder = &MockServiceKeyOperationDeleterMockRecorder{mock}
	return mock
}

func (m *MockServiceKeyOperationDeleter) EXPECT() *MockServiceKeyOperationDeleterMockRecorder {
	return m.recorder
}

func (m *MockServiceKeyOperationDeleter) Delete(o *models.ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", o, ctx, exec)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (mr *MockServiceKeyOperationDeleterMockRecorder) Delete(o, ctx, exec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockServiceKeyOperationDeleter)(nil).Delete), o, ctx, exec)
}

func (m *MockServiceKeyOperationDeleter) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAll", ctx, exec)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (mr *MockServiceKeyOperationDeleterMockRecorder) DeleteAll(ctx, exec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAll", reflect.TypeOf((*MockServiceKeyOperationDeleter)(nil).DeleteAll), ctx, exec)
}

func (m *MockServiceKeyOperationDeleter) DeleteAllSlice(o models.ServiceKeyOperationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAllSlice", o, ctx, exec)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (mr *MockServiceKeyOperationDeleterMockRecorder) DeleteAllSlice(o, ctx, exec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllSlice", reflect.TypeOf((*MockServiceKeyOperationDeleter)(nil).DeleteAllSlice), o, ctx, exec)
}

type MockServiceKeyOperationReloader struct {
	ctrl     *gomock.Controller
	recorder *MockServiceKeyOperationReloaderMockRecorder
}

type MockServiceKeyOperationReloaderMockRecorder struct {
	mock *MockServiceKeyOperationReloader
}

func NewMockServiceKeyOperationReloader(ctrl *gomock.Controller) *MockServiceKeyOperationReloader {
	mock := &MockServiceKeyOperationReloader{ctrl: ctrl}
	mock.recorder = &MockServiceKeyOperationReloaderMockRecorder{mock}
	return mock
}

func (m *MockServiceKeyOperationReloader) EXPECT() *MockServiceKeyOperationReloaderMockRecorder {
	return m.recorder
}

func (m *MockServiceKeyOperationReloader) Reload(o *models.ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Reload", o, ctx, exec)
	ret0, _ := ret[0].(error)
	return ret0
}

func (mr *MockServiceKeyOperationReloaderMockRecorder) Reload(o, ctx, exec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reload", reflect.TypeOf((*MockServiceKeyOperationReloader)(nil).Reload), o, ctx, exec)
}

func (m *MockServiceKeyOperationReloader) ReloadAll(o *models.ServiceKeyOperationSlice, ctx context.Context, exec boil.ContextExecutor) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReloadAll", o, ctx, exec)
	ret0, _ := ret[0].(error)
	return ret0
}

func (mr *MockServiceKeyOperationReloaderMockRecorder) ReloadAll(o, ctx, exec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReloadAll", reflect.TypeOf((*MockServiceKeyOperationReloader)(nil).ReloadAll), o, ctx, exec)
}
//go:build unit
// +build unit

//

// Code generated by MockGen. DO NOT EDIT.
// Source: psql_service_key_operations.go

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

import (
	context "context"
	reflect "reflect"

	models "github.com/cloudfoundry/go-cf-api/internal/storage/db/models"
	gomock "github.com/golang/mock/gomock"
	boil "github.com/volatiletech/sqlboiler/v4/boil"
)

// MockServiceKeyOperationUpserter is a mock of ServiceKeyOperationUpserter interface.
type MockServiceKeyOperationUpserter struct {
	ctrl     *gomock.Controller
	recorder *MockServiceKeyOperationUpserterMockRecorder
}

// MockServiceKeyOperationUpserterMockRecorder is the mock recorder for MockServiceKeyOperationUpserter.
type MockServiceKeyOperationUpserterMockRecorder struct {
	mock *MockServiceKeyOperationUpserter
}

// NewMockServiceKeyOperationUpserter creates a new mock instance.
func NewMockServiceKeyOperationUpserter(ctrl *gomock.Controller) *MockServiceKeyOperationUpserter {
	mock := &MockServiceKeyOperationUpserter{ctrl: ctrl}
	mock.recorder = &MockServiceKeyOperationUpserterMockRecorder{mock}
	return mock
}

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

// Upsert mocks base method.
func (m *MockServiceKeyOperationUpserter) Upsert(o *models.ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Upsert", o, ctx, exec, updateColumns, insertColumns)
	ret0, _ := ret[0].(error)
	return ret0
}

// Upsert indicates an expected call of Upsert.
func (mr *MockServiceKeyOperationUpserterMockRecorder) Upsert(o, ctx, exec, updateColumns, insertColumns interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upsert", reflect.TypeOf((*MockServiceKeyOperationUpserter)(nil).Upsert), o, ctx, exec, updateColumns, insertColumns)
}

// MockServiceKeyOperationFinisher is a mock of ServiceKeyOperationFinisher interface.
type MockServiceKeyOperationFinisher struct {
	ctrl     *gomock.Controller
	recorder *MockServiceKeyOperationFinisherMockRecorder
}

// MockServiceKeyOperationFinisherMockRecorder is the mock recorder for MockServiceKeyOperationFinisher.
type MockServiceKeyOperationFinisherMockRecorder struct {
	mock *MockServiceKeyOperationFinisher
}

// NewMockServiceKeyOperationFinisher creates a new mock instance.
func NewMockServiceKeyOperationFinisher(ctrl *gomock.Controller) *MockServiceKeyOperationFinisher {
	mock := &MockServiceKeyOperationFinisher{ctrl: ctrl}
	mock.recorder = &MockServiceKeyOperationFinisherMockRecorder{mock}
	return mock
}

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

// All mocks base method.
func (m *MockServiceKeyOperationFinisher) All(ctx context.Context, exec boil.ContextExecutor) (models.ServiceKeyOperationSlice, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx, exec)
	ret0, _ := ret[0].(models.ServiceKeyOperationSlice)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockServiceKeyOperationFinisherMockRecorder) All(ctx, exec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockServiceKeyOperationFinisher)(nil).All), ctx, exec)
}

// Count mocks base method.
func (m *MockServiceKeyOperationFinisher) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Count", ctx, exec)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Count indicates an expected call of Count.
func (mr *MockServiceKeyOperationFinisherMockRecorder) Count(ctx, exec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Count", reflect.TypeOf((*MockServiceKeyOperationFinisher)(nil).Count), ctx, exec)
}

// Exists mocks base method.
func (m *MockServiceKeyOperationFinisher) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Exists", ctx, exec)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Exists indicates an expected call of Exists.
func (mr *MockServiceKeyOperationFinisherMockRecorder) Exists(ctx, exec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockServiceKeyOperationFinisher)(nil).Exists), ctx, exec)
}

// One mocks base method.
func (m *MockServiceKeyOperationFinisher) One(ctx context.Context, exec boil.ContextExecutor) (*models.ServiceKeyOperation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "One", ctx, exec)
	ret0, _ := ret[0].(*models.ServiceKeyOperation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// One indicates an expected call of One.
func (mr *MockServiceKeyOperationFinisherMockRecorder) One(ctx, exec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "One", reflect.TypeOf((*MockServiceKeyOperationFinisher)(nil).One), ctx, exec)
}

// MockServiceKeyOperationFinder is a mock of ServiceKeyOperationFinder interface.
type MockServiceKeyOperationFinder struct {
	ctrl     *gomock.Controller
	recorder *MockServiceKeyOperationFinderMockRecorder
}

// MockServiceKeyOperationFinderMockRecorder is the mock recorder for MockServiceKeyOperationFinder.
type MockServiceKeyOperationFinderMockRecorder struct {
	mock *MockServiceKeyOperationFinder
}

// NewMockServiceKeyOperationFinder creates a new mock instance.
func NewMockServiceKeyOperationFinder(ctrl *gomock.Controller) *MockServiceKeyOperationFinder {
	mock := &MockServiceKeyOperationFinder{ctrl: ctrl}
	mock.recorder = &MockServiceKeyOperationFinderMockRecorder{mock}
	return mock
}

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

// FindServiceKeyOperation mocks base method.
func (m *MockServiceKeyOperationFinder) FindServiceKeyOperation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*models.ServiceKeyOperation, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, exec, iD}
	for _, a := range selectCols {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FindServiceKeyOperation", varargs...)
	ret0, _ := ret[0].(*models.ServiceKeyOperation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindServiceKeyOperation indicates an expected call of FindServiceKeyOperation.
func (mr *MockServiceKeyOperationFinderMockRecorder) FindServiceKeyOperation(ctx, exec, iD interface{}, selectCols ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, exec, iD}, selectCols...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindServiceKeyOperation", reflect.TypeOf((*MockServiceKeyOperationFinder)(nil).FindServiceKeyOperation), varargs...)
}

// MockServiceKeyOperationInserter is a mock of ServiceKeyOperationInserter interface.
type MockServiceKeyOperationInserter struct {
	ctrl     *gomock.Controller
	recorder *MockServiceKeyOperationInserterMockRecorder
}

// MockServiceKeyOperationInserterMockRecorder is the mock recorder for MockServiceKeyOperationInserter.
type MockServiceKeyOperationInserterMockRecorder struct {
	mock *MockServiceKeyOperationInserter
}

// NewMockServiceKeyOperationInserter creates a new mock instance.
func NewMockServiceKeyOperationInserter(ctrl *gomock.Controller) *MockServiceKeyOperationInserter {
	mock := &MockServiceKeyOperationInserter{ctrl: ctrl}
	mock.recorder = &MockServiceKeyOperationInserterMockRecorder{mock}
	return mock
}

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

// Insert mocks base method.
func (m *MockServiceKeyOperationInserter) Insert(o *models.ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Insert", o, ctx, exec, columns)
	ret0, _ := ret[0].(error)
	return ret0
}

// Insert indicates an expected call of Insert.
func (mr *MockServiceKeyOperationInserterMockRecorder) Insert(o, ctx, exec, columns interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Insert", reflect.TypeOf((*MockServiceKeyOperationInserter)(nil).Insert), o, ctx, exec, columns)
}

// MockServiceKeyOperationUpdater is a mock of ServiceKeyOperationUpdater interface.
type MockServiceKeyOperationUpdater struct {
	ctrl     *gomock.Controller
	recorder *MockServiceKeyOperationUpdaterMockRecorder
}

// MockServiceKeyOperationUpdaterMockRecorder is the mock recorder for MockServiceKeyOperationUpdater.
type MockServiceKeyOperationUpdaterMockRecorder struct {
	mock *MockServiceKeyOperationUpdater
}

// NewMockServiceKeyOperationUpdater creates a new mock instance.
func NewMockServiceKeyOperationUpdater(ctrl *gomock.Controller) *MockServiceKeyOperationUpdater {
	mock := &MockServiceKeyOperationUpdater{ctrl: ctrl}
	mock.recorder = &MockServiceKeyOperationUpdaterMockRecorder{mock}
	return mock
}

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

// Update mocks base method.
func (m *MockServiceKeyOperationUpdater) Update(o *models.ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", o, ctx, exec, columns)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Update indicates an expected call of Update.
func (mr *MockServiceKeyOperationUpdaterMockRecorder) Update(o, ctx, exec, columns interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockServiceKeyOperationUpdater)(nil).Update), o, ctx, exec, columns)
}

// UpdateAll mocks base method.
func (m *MockServiceKeyOperationUpdater) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols models.M) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAll", ctx, exec, cols)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateAll indicates an expected call of UpdateAll.
func (mr *MockServiceKeyOperationUpdaterMockRecorder) UpdateAll(ctx, exec, cols interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAll", reflect.TypeOf((*MockServiceKeyOperationUpdater)(nil).UpdateAll), ctx, exec, cols)
}

// UpdateAllSlice mocks base method.
func (m *MockServiceKeyOperationUpdater) UpdateAllSlice(o models.ServiceKeyOperationSlice, ctx context.Context, exec boil.ContextExecutor, cols models.M) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAllSlice", o, ctx, exec, cols)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateAllSlice indicates an expected call of UpdateAllSlice.
func (mr *MockServiceKeyOperationUpdaterMockRecorder) UpdateAllSlice(o, ctx, exec, cols interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAllSlice", reflect.TypeOf((*MockServiceKeyOperationUpdater)(nil).UpdateAllSlice), o, ctx, exec, cols)
}

// MockServiceKeyOperationDeleter is a mock of ServiceKeyOperationDeleter interface.
type MockServiceKeyOperationDeleter struct {
	ctrl     *gomock.Controller
	recorder *MockServiceKeyOperationDeleterMockRecorder
}

// MockServiceKeyOperationDeleterMockRecorder is the mock recorder for MockServiceKeyOperationDeleter.
type MockServiceKeyOperationDeleterMockRecorder struct {
	mock *MockServiceKeyOperationDeleter
}

// NewMockServiceKeyOperationDeleter creates a new mock instance.
func NewMockServiceKeyOperationDeleter(ctrl *gomock.Controller) *MockServiceKeyOperationDeleter {
	mock := &MockServiceKeyOperationDeleter{ctrl: ctrl}
	mock.recorder = &MockServiceKeyOperationDeleterMockRecorder{mock}
	return mock
}

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

// Delete mocks base method.
func (m *MockServiceKeyOperationDeleter) Delete(o *models.ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", o, ctx, exec)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockServiceKeyOperationDeleterMockRecorder) Delete(o, ctx, exec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockServiceKeyOperationDeleter)(nil).Delete), o, ctx, exec)
}

// DeleteAll mocks base method.
func (m *MockServiceKeyOperationDeleter) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAll", ctx, exec)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteAll indicates an expected call of DeleteAll.
func (mr *MockServiceKeyOperationDeleterMockRecorder) DeleteAll(ctx, exec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAll", reflect.TypeOf((*MockServiceKeyOperationDeleter)(nil).DeleteAll), ctx, exec)
}

// DeleteAllSlice mocks base method.
func (m *MockServiceKeyOperationDeleter) DeleteAllSlice(o models.ServiceKeyOperationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAllSlice", o, ctx, exec)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteAllSlice indicates an expected call of DeleteAllSlice.
func (mr *MockServiceKeyOperationDeleterMockRecorder) DeleteAllSlice(o, ctx, exec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllSlice", reflect.TypeOf((*MockServiceKeyOperationDeleter)(nil).DeleteAllSlice), o, ctx, exec)
}

// MockServiceKeyOperationReloader is a mock of ServiceKeyOperationReloader interface.
type MockServiceKeyOperationReloader struct {
	ctrl     *gomock.Controller
	recorder *MockServiceKeyOperationReloaderMockRecorder
}

// MockServiceKeyOperationReloaderMockRecorder is the mock recorder for MockServiceKeyOperationReloader.
type MockServiceKeyOperationReloaderMockRecorder struct {
	mock *MockServiceKeyOperationReloader
}

// NewMockServiceKeyOperationReloader creates a new mock instance.
func NewMockServiceKeyOperationReloader(ctrl *gomock.Controller) *MockServiceKeyOperationReloader {
	mock := &MockServiceKeyOperationReloader{ctrl: ctrl}
	mock.recorder = &MockServiceKeyOperationReloaderMockRecorder{mock}
	return mock
}

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

// Reload mocks base method.
func (m *MockServiceKeyOperationReloader) Reload(o *models.ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Reload", o, ctx, exec)
	ret0, _ := ret[0].(error)
	return ret0
}

// Reload indicates an expected call of Reload.
func (mr *MockServiceKeyOperationReloaderMockRecorder) Reload(o, ctx, exec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reload", reflect.TypeOf((*MockServiceKeyOperationReloader)(nil).Reload), o, ctx, exec)
}

// ReloadAll mocks base method.
func (m *MockServiceKeyOperationReloader) ReloadAll(o *models.ServiceKeyOperationSlice, ctx context.Context, exec boil.ContextExecutor) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReloadAll", o, ctx, exec)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReloadAll indicates an expected call of ReloadAll.
func (mr *MockServiceKeyOperationReloaderMockRecorder) ReloadAll(o, ctx, exec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReloadAll", reflect.TypeOf((*MockServiceKeyOperationReloader)(nil).ReloadAll), o, ctx, exec)
}
