mock_querier.go

// Code generated by mockery. DO NOT EDIT.

package gensql

import (
	context "context"

	pgtype "github.com/jackc/pgx/v5/pgtype"
	mock "github.com/stretchr/testify/mock"

	slug "github.com/nais/api/internal/slug"

	uuid "github.com/google/uuid"
)

// MockQuerier is an autogenerated mock type for the Querier type
type MockQuerier struct {
	mock.Mock
}

type MockQuerier_Expecter struct {
	mock *mock.Mock
}

func (_m *MockQuerier) EXPECT() *MockQuerier_Expecter {
	return &MockQuerier_Expecter{mock: &_m.Mock}
}

// AddReconcilerOptOut provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) AddReconcilerOptOut(ctx context.Context, arg AddReconcilerOptOutParams) error {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for AddReconcilerOptOut")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, AddReconcilerOptOutParams) error); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_AddReconcilerOptOut_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddReconcilerOptOut'
type MockQuerier_AddReconcilerOptOut_Call struct {
	*mock.Call
}

// AddReconcilerOptOut is a helper method to define mock.On call
//   - ctx context.Context
//   - arg AddReconcilerOptOutParams
func (_e *MockQuerier_Expecter) AddReconcilerOptOut(ctx interface{}, arg interface{}) *MockQuerier_AddReconcilerOptOut_Call {
	return &MockQuerier_AddReconcilerOptOut_Call{Call: _e.mock.On("AddReconcilerOptOut", ctx, arg)}
}

func (_c *MockQuerier_AddReconcilerOptOut_Call) Run(run func(ctx context.Context, arg AddReconcilerOptOutParams)) *MockQuerier_AddReconcilerOptOut_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(AddReconcilerOptOutParams))
	})
	return _c
}

func (_c *MockQuerier_AddReconcilerOptOut_Call) Return(_a0 error) *MockQuerier_AddReconcilerOptOut_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_AddReconcilerOptOut_Call) RunAndReturn(run func(context.Context, AddReconcilerOptOutParams) error) *MockQuerier_AddReconcilerOptOut_Call {
	_c.Call.Return(run)
	return _c
}

// AssignGlobalRoleToServiceAccount provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) AssignGlobalRoleToServiceAccount(ctx context.Context, arg AssignGlobalRoleToServiceAccountParams) error {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for AssignGlobalRoleToServiceAccount")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, AssignGlobalRoleToServiceAccountParams) error); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_AssignGlobalRoleToServiceAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssignGlobalRoleToServiceAccount'
type MockQuerier_AssignGlobalRoleToServiceAccount_Call struct {
	*mock.Call
}

// AssignGlobalRoleToServiceAccount is a helper method to define mock.On call
//   - ctx context.Context
//   - arg AssignGlobalRoleToServiceAccountParams
func (_e *MockQuerier_Expecter) AssignGlobalRoleToServiceAccount(ctx interface{}, arg interface{}) *MockQuerier_AssignGlobalRoleToServiceAccount_Call {
	return &MockQuerier_AssignGlobalRoleToServiceAccount_Call{Call: _e.mock.On("AssignGlobalRoleToServiceAccount", ctx, arg)}
}

func (_c *MockQuerier_AssignGlobalRoleToServiceAccount_Call) Run(run func(ctx context.Context, arg AssignGlobalRoleToServiceAccountParams)) *MockQuerier_AssignGlobalRoleToServiceAccount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(AssignGlobalRoleToServiceAccountParams))
	})
	return _c
}

func (_c *MockQuerier_AssignGlobalRoleToServiceAccount_Call) Return(_a0 error) *MockQuerier_AssignGlobalRoleToServiceAccount_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_AssignGlobalRoleToServiceAccount_Call) RunAndReturn(run func(context.Context, AssignGlobalRoleToServiceAccountParams) error) *MockQuerier_AssignGlobalRoleToServiceAccount_Call {
	_c.Call.Return(run)
	return _c
}

// AssignGlobalRoleToUser provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) AssignGlobalRoleToUser(ctx context.Context, arg AssignGlobalRoleToUserParams) error {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for AssignGlobalRoleToUser")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, AssignGlobalRoleToUserParams) error); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_AssignGlobalRoleToUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssignGlobalRoleToUser'
type MockQuerier_AssignGlobalRoleToUser_Call struct {
	*mock.Call
}

// AssignGlobalRoleToUser is a helper method to define mock.On call
//   - ctx context.Context
//   - arg AssignGlobalRoleToUserParams
func (_e *MockQuerier_Expecter) AssignGlobalRoleToUser(ctx interface{}, arg interface{}) *MockQuerier_AssignGlobalRoleToUser_Call {
	return &MockQuerier_AssignGlobalRoleToUser_Call{Call: _e.mock.On("AssignGlobalRoleToUser", ctx, arg)}
}

func (_c *MockQuerier_AssignGlobalRoleToUser_Call) Run(run func(ctx context.Context, arg AssignGlobalRoleToUserParams)) *MockQuerier_AssignGlobalRoleToUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(AssignGlobalRoleToUserParams))
	})
	return _c
}

func (_c *MockQuerier_AssignGlobalRoleToUser_Call) Return(_a0 error) *MockQuerier_AssignGlobalRoleToUser_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_AssignGlobalRoleToUser_Call) RunAndReturn(run func(context.Context, AssignGlobalRoleToUserParams) error) *MockQuerier_AssignGlobalRoleToUser_Call {
	_c.Call.Return(run)
	return _c
}

// AssignTeamRoleToServiceAccount provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) AssignTeamRoleToServiceAccount(ctx context.Context, arg AssignTeamRoleToServiceAccountParams) error {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for AssignTeamRoleToServiceAccount")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, AssignTeamRoleToServiceAccountParams) error); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_AssignTeamRoleToServiceAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssignTeamRoleToServiceAccount'
type MockQuerier_AssignTeamRoleToServiceAccount_Call struct {
	*mock.Call
}

// AssignTeamRoleToServiceAccount is a helper method to define mock.On call
//   - ctx context.Context
//   - arg AssignTeamRoleToServiceAccountParams
func (_e *MockQuerier_Expecter) AssignTeamRoleToServiceAccount(ctx interface{}, arg interface{}) *MockQuerier_AssignTeamRoleToServiceAccount_Call {
	return &MockQuerier_AssignTeamRoleToServiceAccount_Call{Call: _e.mock.On("AssignTeamRoleToServiceAccount", ctx, arg)}
}

func (_c *MockQuerier_AssignTeamRoleToServiceAccount_Call) Run(run func(ctx context.Context, arg AssignTeamRoleToServiceAccountParams)) *MockQuerier_AssignTeamRoleToServiceAccount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(AssignTeamRoleToServiceAccountParams))
	})
	return _c
}

func (_c *MockQuerier_AssignTeamRoleToServiceAccount_Call) Return(_a0 error) *MockQuerier_AssignTeamRoleToServiceAccount_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_AssignTeamRoleToServiceAccount_Call) RunAndReturn(run func(context.Context, AssignTeamRoleToServiceAccountParams) error) *MockQuerier_AssignTeamRoleToServiceAccount_Call {
	_c.Call.Return(run)
	return _c
}

// AssignTeamRoleToUser provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) AssignTeamRoleToUser(ctx context.Context, arg AssignTeamRoleToUserParams) error {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for AssignTeamRoleToUser")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, AssignTeamRoleToUserParams) error); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_AssignTeamRoleToUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssignTeamRoleToUser'
type MockQuerier_AssignTeamRoleToUser_Call struct {
	*mock.Call
}

// AssignTeamRoleToUser is a helper method to define mock.On call
//   - ctx context.Context
//   - arg AssignTeamRoleToUserParams
func (_e *MockQuerier_Expecter) AssignTeamRoleToUser(ctx interface{}, arg interface{}) *MockQuerier_AssignTeamRoleToUser_Call {
	return &MockQuerier_AssignTeamRoleToUser_Call{Call: _e.mock.On("AssignTeamRoleToUser", ctx, arg)}
}

func (_c *MockQuerier_AssignTeamRoleToUser_Call) Run(run func(ctx context.Context, arg AssignTeamRoleToUserParams)) *MockQuerier_AssignTeamRoleToUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(AssignTeamRoleToUserParams))
	})
	return _c
}

func (_c *MockQuerier_AssignTeamRoleToUser_Call) Return(_a0 error) *MockQuerier_AssignTeamRoleToUser_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_AssignTeamRoleToUser_Call) RunAndReturn(run func(context.Context, AssignTeamRoleToUserParams) error) *MockQuerier_AssignTeamRoleToUser_Call {
	_c.Call.Return(run)
	return _c
}

// AverageResourceUtilizationForTeam provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) AverageResourceUtilizationForTeam(ctx context.Context, arg AverageResourceUtilizationForTeamParams) (*AverageResourceUtilizationForTeamRow, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for AverageResourceUtilizationForTeam")
	}

	var r0 *AverageResourceUtilizationForTeamRow
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, AverageResourceUtilizationForTeamParams) (*AverageResourceUtilizationForTeamRow, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, AverageResourceUtilizationForTeamParams) *AverageResourceUtilizationForTeamRow); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*AverageResourceUtilizationForTeamRow)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, AverageResourceUtilizationForTeamParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_AverageResourceUtilizationForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AverageResourceUtilizationForTeam'
type MockQuerier_AverageResourceUtilizationForTeam_Call struct {
	*mock.Call
}

// AverageResourceUtilizationForTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - arg AverageResourceUtilizationForTeamParams
func (_e *MockQuerier_Expecter) AverageResourceUtilizationForTeam(ctx interface{}, arg interface{}) *MockQuerier_AverageResourceUtilizationForTeam_Call {
	return &MockQuerier_AverageResourceUtilizationForTeam_Call{Call: _e.mock.On("AverageResourceUtilizationForTeam", ctx, arg)}
}

func (_c *MockQuerier_AverageResourceUtilizationForTeam_Call) Run(run func(ctx context.Context, arg AverageResourceUtilizationForTeamParams)) *MockQuerier_AverageResourceUtilizationForTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(AverageResourceUtilizationForTeamParams))
	})
	return _c
}

func (_c *MockQuerier_AverageResourceUtilizationForTeam_Call) Return(_a0 *AverageResourceUtilizationForTeamRow, _a1 error) *MockQuerier_AverageResourceUtilizationForTeam_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_AverageResourceUtilizationForTeam_Call) RunAndReturn(run func(context.Context, AverageResourceUtilizationForTeamParams) (*AverageResourceUtilizationForTeamRow, error)) *MockQuerier_AverageResourceUtilizationForTeam_Call {
	_c.Call.Return(run)
	return _c
}

// ClearReconcilerErrorsForTeam provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) ClearReconcilerErrorsForTeam(ctx context.Context, arg ClearReconcilerErrorsForTeamParams) error {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for ClearReconcilerErrorsForTeam")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, ClearReconcilerErrorsForTeamParams) error); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_ClearReconcilerErrorsForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearReconcilerErrorsForTeam'
type MockQuerier_ClearReconcilerErrorsForTeam_Call struct {
	*mock.Call
}

// ClearReconcilerErrorsForTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - arg ClearReconcilerErrorsForTeamParams
func (_e *MockQuerier_Expecter) ClearReconcilerErrorsForTeam(ctx interface{}, arg interface{}) *MockQuerier_ClearReconcilerErrorsForTeam_Call {
	return &MockQuerier_ClearReconcilerErrorsForTeam_Call{Call: _e.mock.On("ClearReconcilerErrorsForTeam", ctx, arg)}
}

func (_c *MockQuerier_ClearReconcilerErrorsForTeam_Call) Run(run func(ctx context.Context, arg ClearReconcilerErrorsForTeamParams)) *MockQuerier_ClearReconcilerErrorsForTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ClearReconcilerErrorsForTeamParams))
	})
	return _c
}

func (_c *MockQuerier_ClearReconcilerErrorsForTeam_Call) Return(_a0 error) *MockQuerier_ClearReconcilerErrorsForTeam_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_ClearReconcilerErrorsForTeam_Call) RunAndReturn(run func(context.Context, ClearReconcilerErrorsForTeamParams) error) *MockQuerier_ClearReconcilerErrorsForTeam_Call {
	_c.Call.Return(run)
	return _c
}

// ConfigureReconciler provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) ConfigureReconciler(ctx context.Context, arg ConfigureReconcilerParams) error {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for ConfigureReconciler")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, ConfigureReconcilerParams) error); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_ConfigureReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigureReconciler'
type MockQuerier_ConfigureReconciler_Call struct {
	*mock.Call
}

// ConfigureReconciler is a helper method to define mock.On call
//   - ctx context.Context
//   - arg ConfigureReconcilerParams
func (_e *MockQuerier_Expecter) ConfigureReconciler(ctx interface{}, arg interface{}) *MockQuerier_ConfigureReconciler_Call {
	return &MockQuerier_ConfigureReconciler_Call{Call: _e.mock.On("ConfigureReconciler", ctx, arg)}
}

func (_c *MockQuerier_ConfigureReconciler_Call) Run(run func(ctx context.Context, arg ConfigureReconcilerParams)) *MockQuerier_ConfigureReconciler_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ConfigureReconcilerParams))
	})
	return _c
}

func (_c *MockQuerier_ConfigureReconciler_Call) Return(_a0 error) *MockQuerier_ConfigureReconciler_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_ConfigureReconciler_Call) RunAndReturn(run func(context.Context, ConfigureReconcilerParams) error) *MockQuerier_ConfigureReconciler_Call {
	_c.Call.Return(run)
	return _c
}

// ConfirmTeamDeleteKey provides a mock function with given fields: ctx, key
func (_m *MockQuerier) ConfirmTeamDeleteKey(ctx context.Context, key uuid.UUID) error {
	ret := _m.Called(ctx, key)

	if len(ret) == 0 {
		panic("no return value specified for ConfirmTeamDeleteKey")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) error); ok {
		r0 = rf(ctx, key)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_ConfirmTeamDeleteKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfirmTeamDeleteKey'
type MockQuerier_ConfirmTeamDeleteKey_Call struct {
	*mock.Call
}

// ConfirmTeamDeleteKey is a helper method to define mock.On call
//   - ctx context.Context
//   - key uuid.UUID
func (_e *MockQuerier_Expecter) ConfirmTeamDeleteKey(ctx interface{}, key interface{}) *MockQuerier_ConfirmTeamDeleteKey_Call {
	return &MockQuerier_ConfirmTeamDeleteKey_Call{Call: _e.mock.On("ConfirmTeamDeleteKey", ctx, key)}
}

func (_c *MockQuerier_ConfirmTeamDeleteKey_Call) Run(run func(ctx context.Context, key uuid.UUID)) *MockQuerier_ConfirmTeamDeleteKey_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uuid.UUID))
	})
	return _c
}

func (_c *MockQuerier_ConfirmTeamDeleteKey_Call) Return(_a0 error) *MockQuerier_ConfirmTeamDeleteKey_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_ConfirmTeamDeleteKey_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *MockQuerier_ConfirmTeamDeleteKey_Call {
	_c.Call.Return(run)
	return _c
}

// CostForSqlInstance provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) CostForSqlInstance(ctx context.Context, arg CostForSqlInstanceParams) (float32, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for CostForSqlInstance")
	}

	var r0 float32
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, CostForSqlInstanceParams) (float32, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, CostForSqlInstanceParams) float32); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Get(0).(float32)
	}

	if rf, ok := ret.Get(1).(func(context.Context, CostForSqlInstanceParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_CostForSqlInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CostForSqlInstance'
type MockQuerier_CostForSqlInstance_Call struct {
	*mock.Call
}

// CostForSqlInstance is a helper method to define mock.On call
//   - ctx context.Context
//   - arg CostForSqlInstanceParams
func (_e *MockQuerier_Expecter) CostForSqlInstance(ctx interface{}, arg interface{}) *MockQuerier_CostForSqlInstance_Call {
	return &MockQuerier_CostForSqlInstance_Call{Call: _e.mock.On("CostForSqlInstance", ctx, arg)}
}

func (_c *MockQuerier_CostForSqlInstance_Call) Run(run func(ctx context.Context, arg CostForSqlInstanceParams)) *MockQuerier_CostForSqlInstance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(CostForSqlInstanceParams))
	})
	return _c
}

func (_c *MockQuerier_CostForSqlInstance_Call) Return(_a0 float32, _a1 error) *MockQuerier_CostForSqlInstance_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_CostForSqlInstance_Call) RunAndReturn(run func(context.Context, CostForSqlInstanceParams) (float32, error)) *MockQuerier_CostForSqlInstance_Call {
	_c.Call.Return(run)
	return _c
}

// CostUpsert provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) CostUpsert(ctx context.Context, arg []CostUpsertParams) *CostUpsertBatchResults {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for CostUpsert")
	}

	var r0 *CostUpsertBatchResults
	if rf, ok := ret.Get(0).(func(context.Context, []CostUpsertParams) *CostUpsertBatchResults); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*CostUpsertBatchResults)
		}
	}

	return r0
}

// MockQuerier_CostUpsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CostUpsert'
type MockQuerier_CostUpsert_Call struct {
	*mock.Call
}

// CostUpsert is a helper method to define mock.On call
//   - ctx context.Context
//   - arg []CostUpsertParams
func (_e *MockQuerier_Expecter) CostUpsert(ctx interface{}, arg interface{}) *MockQuerier_CostUpsert_Call {
	return &MockQuerier_CostUpsert_Call{Call: _e.mock.On("CostUpsert", ctx, arg)}
}

func (_c *MockQuerier_CostUpsert_Call) Run(run func(ctx context.Context, arg []CostUpsertParams)) *MockQuerier_CostUpsert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]CostUpsertParams))
	})
	return _c
}

func (_c *MockQuerier_CostUpsert_Call) Return(_a0 *CostUpsertBatchResults) *MockQuerier_CostUpsert_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_CostUpsert_Call) RunAndReturn(run func(context.Context, []CostUpsertParams) *CostUpsertBatchResults) *MockQuerier_CostUpsert_Call {
	_c.Call.Return(run)
	return _c
}

// CreateAPIKey provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) CreateAPIKey(ctx context.Context, arg CreateAPIKeyParams) error {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for CreateAPIKey")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, CreateAPIKeyParams) error); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_CreateAPIKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAPIKey'
type MockQuerier_CreateAPIKey_Call struct {
	*mock.Call
}

// CreateAPIKey is a helper method to define mock.On call
//   - ctx context.Context
//   - arg CreateAPIKeyParams
func (_e *MockQuerier_Expecter) CreateAPIKey(ctx interface{}, arg interface{}) *MockQuerier_CreateAPIKey_Call {
	return &MockQuerier_CreateAPIKey_Call{Call: _e.mock.On("CreateAPIKey", ctx, arg)}
}

func (_c *MockQuerier_CreateAPIKey_Call) Run(run func(ctx context.Context, arg CreateAPIKeyParams)) *MockQuerier_CreateAPIKey_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(CreateAPIKeyParams))
	})
	return _c
}

func (_c *MockQuerier_CreateAPIKey_Call) Return(_a0 error) *MockQuerier_CreateAPIKey_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_CreateAPIKey_Call) RunAndReturn(run func(context.Context, CreateAPIKeyParams) error) *MockQuerier_CreateAPIKey_Call {
	_c.Call.Return(run)
	return _c
}

// CreateAuditLog provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) CreateAuditLog(ctx context.Context, arg CreateAuditLogParams) error {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for CreateAuditLog")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, CreateAuditLogParams) error); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_CreateAuditLog_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAuditLog'
type MockQuerier_CreateAuditLog_Call struct {
	*mock.Call
}

// CreateAuditLog is a helper method to define mock.On call
//   - ctx context.Context
//   - arg CreateAuditLogParams
func (_e *MockQuerier_Expecter) CreateAuditLog(ctx interface{}, arg interface{}) *MockQuerier_CreateAuditLog_Call {
	return &MockQuerier_CreateAuditLog_Call{Call: _e.mock.On("CreateAuditLog", ctx, arg)}
}

func (_c *MockQuerier_CreateAuditLog_Call) Run(run func(ctx context.Context, arg CreateAuditLogParams)) *MockQuerier_CreateAuditLog_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(CreateAuditLogParams))
	})
	return _c
}

func (_c *MockQuerier_CreateAuditLog_Call) Return(_a0 error) *MockQuerier_CreateAuditLog_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_CreateAuditLog_Call) RunAndReturn(run func(context.Context, CreateAuditLogParams) error) *MockQuerier_CreateAuditLog_Call {
	_c.Call.Return(run)
	return _c
}

// CreateDependencytrackProject provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) CreateDependencytrackProject(ctx context.Context, arg CreateDependencytrackProjectParams) error {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for CreateDependencytrackProject")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, CreateDependencytrackProjectParams) error); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_CreateDependencytrackProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDependencytrackProject'
type MockQuerier_CreateDependencytrackProject_Call struct {
	*mock.Call
}

// CreateDependencytrackProject is a helper method to define mock.On call
//   - ctx context.Context
//   - arg CreateDependencytrackProjectParams
func (_e *MockQuerier_Expecter) CreateDependencytrackProject(ctx interface{}, arg interface{}) *MockQuerier_CreateDependencytrackProject_Call {
	return &MockQuerier_CreateDependencytrackProject_Call{Call: _e.mock.On("CreateDependencytrackProject", ctx, arg)}
}

func (_c *MockQuerier_CreateDependencytrackProject_Call) Run(run func(ctx context.Context, arg CreateDependencytrackProjectParams)) *MockQuerier_CreateDependencytrackProject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(CreateDependencytrackProjectParams))
	})
	return _c
}

func (_c *MockQuerier_CreateDependencytrackProject_Call) Return(_a0 error) *MockQuerier_CreateDependencytrackProject_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_CreateDependencytrackProject_Call) RunAndReturn(run func(context.Context, CreateDependencytrackProjectParams) error) *MockQuerier_CreateDependencytrackProject_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRepositoryAuthorization provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) CreateRepositoryAuthorization(ctx context.Context, arg CreateRepositoryAuthorizationParams) error {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for CreateRepositoryAuthorization")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, CreateRepositoryAuthorizationParams) error); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_CreateRepositoryAuthorization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRepositoryAuthorization'
type MockQuerier_CreateRepositoryAuthorization_Call struct {
	*mock.Call
}

// CreateRepositoryAuthorization is a helper method to define mock.On call
//   - ctx context.Context
//   - arg CreateRepositoryAuthorizationParams
func (_e *MockQuerier_Expecter) CreateRepositoryAuthorization(ctx interface{}, arg interface{}) *MockQuerier_CreateRepositoryAuthorization_Call {
	return &MockQuerier_CreateRepositoryAuthorization_Call{Call: _e.mock.On("CreateRepositoryAuthorization", ctx, arg)}
}

func (_c *MockQuerier_CreateRepositoryAuthorization_Call) Run(run func(ctx context.Context, arg CreateRepositoryAuthorizationParams)) *MockQuerier_CreateRepositoryAuthorization_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(CreateRepositoryAuthorizationParams))
	})
	return _c
}

func (_c *MockQuerier_CreateRepositoryAuthorization_Call) Return(_a0 error) *MockQuerier_CreateRepositoryAuthorization_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_CreateRepositoryAuthorization_Call) RunAndReturn(run func(context.Context, CreateRepositoryAuthorizationParams) error) *MockQuerier_CreateRepositoryAuthorization_Call {
	_c.Call.Return(run)
	return _c
}

// CreateServiceAccount provides a mock function with given fields: ctx, name
func (_m *MockQuerier) CreateServiceAccount(ctx context.Context, name string) (*ServiceAccount, error) {
	ret := _m.Called(ctx, name)

	if len(ret) == 0 {
		panic("no return value specified for CreateServiceAccount")
	}

	var r0 *ServiceAccount
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*ServiceAccount, error)); ok {
		return rf(ctx, name)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *ServiceAccount); ok {
		r0 = rf(ctx, name)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ServiceAccount)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, name)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_CreateServiceAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateServiceAccount'
type MockQuerier_CreateServiceAccount_Call struct {
	*mock.Call
}

// CreateServiceAccount is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
func (_e *MockQuerier_Expecter) CreateServiceAccount(ctx interface{}, name interface{}) *MockQuerier_CreateServiceAccount_Call {
	return &MockQuerier_CreateServiceAccount_Call{Call: _e.mock.On("CreateServiceAccount", ctx, name)}
}

func (_c *MockQuerier_CreateServiceAccount_Call) Run(run func(ctx context.Context, name string)) *MockQuerier_CreateServiceAccount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockQuerier_CreateServiceAccount_Call) Return(_a0 *ServiceAccount, _a1 error) *MockQuerier_CreateServiceAccount_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_CreateServiceAccount_Call) RunAndReturn(run func(context.Context, string) (*ServiceAccount, error)) *MockQuerier_CreateServiceAccount_Call {
	_c.Call.Return(run)
	return _c
}

// CreateSession provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) CreateSession(ctx context.Context, arg CreateSessionParams) (*Session, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for CreateSession")
	}

	var r0 *Session
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, CreateSessionParams) (*Session, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, CreateSessionParams) *Session); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*Session)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, CreateSessionParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_CreateSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSession'
type MockQuerier_CreateSession_Call struct {
	*mock.Call
}

// CreateSession is a helper method to define mock.On call
//   - ctx context.Context
//   - arg CreateSessionParams
func (_e *MockQuerier_Expecter) CreateSession(ctx interface{}, arg interface{}) *MockQuerier_CreateSession_Call {
	return &MockQuerier_CreateSession_Call{Call: _e.mock.On("CreateSession", ctx, arg)}
}

func (_c *MockQuerier_CreateSession_Call) Run(run func(ctx context.Context, arg CreateSessionParams)) *MockQuerier_CreateSession_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(CreateSessionParams))
	})
	return _c
}

func (_c *MockQuerier_CreateSession_Call) Return(_a0 *Session, _a1 error) *MockQuerier_CreateSession_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_CreateSession_Call) RunAndReturn(run func(context.Context, CreateSessionParams) (*Session, error)) *MockQuerier_CreateSession_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTeam provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) CreateTeam(ctx context.Context, arg CreateTeamParams) (*Team, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for CreateTeam")
	}

	var r0 *Team
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, CreateTeamParams) (*Team, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, CreateTeamParams) *Team); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*Team)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, CreateTeamParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_CreateTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTeam'
type MockQuerier_CreateTeam_Call struct {
	*mock.Call
}

// CreateTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - arg CreateTeamParams
func (_e *MockQuerier_Expecter) CreateTeam(ctx interface{}, arg interface{}) *MockQuerier_CreateTeam_Call {
	return &MockQuerier_CreateTeam_Call{Call: _e.mock.On("CreateTeam", ctx, arg)}
}

func (_c *MockQuerier_CreateTeam_Call) Run(run func(ctx context.Context, arg CreateTeamParams)) *MockQuerier_CreateTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(CreateTeamParams))
	})
	return _c
}

func (_c *MockQuerier_CreateTeam_Call) Return(_a0 *Team, _a1 error) *MockQuerier_CreateTeam_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_CreateTeam_Call) RunAndReturn(run func(context.Context, CreateTeamParams) (*Team, error)) *MockQuerier_CreateTeam_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTeamDeleteKey provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) CreateTeamDeleteKey(ctx context.Context, arg CreateTeamDeleteKeyParams) (*TeamDeleteKey, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for CreateTeamDeleteKey")
	}

	var r0 *TeamDeleteKey
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, CreateTeamDeleteKeyParams) (*TeamDeleteKey, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, CreateTeamDeleteKeyParams) *TeamDeleteKey); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*TeamDeleteKey)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, CreateTeamDeleteKeyParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_CreateTeamDeleteKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTeamDeleteKey'
type MockQuerier_CreateTeamDeleteKey_Call struct {
	*mock.Call
}

// CreateTeamDeleteKey is a helper method to define mock.On call
//   - ctx context.Context
//   - arg CreateTeamDeleteKeyParams
func (_e *MockQuerier_Expecter) CreateTeamDeleteKey(ctx interface{}, arg interface{}) *MockQuerier_CreateTeamDeleteKey_Call {
	return &MockQuerier_CreateTeamDeleteKey_Call{Call: _e.mock.On("CreateTeamDeleteKey", ctx, arg)}
}

func (_c *MockQuerier_CreateTeamDeleteKey_Call) Run(run func(ctx context.Context, arg CreateTeamDeleteKeyParams)) *MockQuerier_CreateTeamDeleteKey_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(CreateTeamDeleteKeyParams))
	})
	return _c
}

func (_c *MockQuerier_CreateTeamDeleteKey_Call) Return(_a0 *TeamDeleteKey, _a1 error) *MockQuerier_CreateTeamDeleteKey_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_CreateTeamDeleteKey_Call) RunAndReturn(run func(context.Context, CreateTeamDeleteKeyParams) (*TeamDeleteKey, error)) *MockQuerier_CreateTeamDeleteKey_Call {
	_c.Call.Return(run)
	return _c
}

// CreateUser provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) CreateUser(ctx context.Context, arg CreateUserParams) (*User, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for CreateUser")
	}

	var r0 *User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, CreateUserParams) (*User, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, CreateUserParams) *User); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*User)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, CreateUserParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_CreateUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateUser'
type MockQuerier_CreateUser_Call struct {
	*mock.Call
}

// CreateUser is a helper method to define mock.On call
//   - ctx context.Context
//   - arg CreateUserParams
func (_e *MockQuerier_Expecter) CreateUser(ctx interface{}, arg interface{}) *MockQuerier_CreateUser_Call {
	return &MockQuerier_CreateUser_Call{Call: _e.mock.On("CreateUser", ctx, arg)}
}

func (_c *MockQuerier_CreateUser_Call) Run(run func(ctx context.Context, arg CreateUserParams)) *MockQuerier_CreateUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(CreateUserParams))
	})
	return _c
}

func (_c *MockQuerier_CreateUser_Call) Return(_a0 *User, _a1 error) *MockQuerier_CreateUser_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_CreateUser_Call) RunAndReturn(run func(context.Context, CreateUserParams) (*User, error)) *MockQuerier_CreateUser_Call {
	_c.Call.Return(run)
	return _c
}

// CurrentSqlInstancesCostForTeam provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) CurrentSqlInstancesCostForTeam(ctx context.Context, arg CurrentSqlInstancesCostForTeamParams) (float32, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for CurrentSqlInstancesCostForTeam")
	}

	var r0 float32
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, CurrentSqlInstancesCostForTeamParams) (float32, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, CurrentSqlInstancesCostForTeamParams) float32); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Get(0).(float32)
	}

	if rf, ok := ret.Get(1).(func(context.Context, CurrentSqlInstancesCostForTeamParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_CurrentSqlInstancesCostForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CurrentSqlInstancesCostForTeam'
type MockQuerier_CurrentSqlInstancesCostForTeam_Call struct {
	*mock.Call
}

// CurrentSqlInstancesCostForTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - arg CurrentSqlInstancesCostForTeamParams
func (_e *MockQuerier_Expecter) CurrentSqlInstancesCostForTeam(ctx interface{}, arg interface{}) *MockQuerier_CurrentSqlInstancesCostForTeam_Call {
	return &MockQuerier_CurrentSqlInstancesCostForTeam_Call{Call: _e.mock.On("CurrentSqlInstancesCostForTeam", ctx, arg)}
}

func (_c *MockQuerier_CurrentSqlInstancesCostForTeam_Call) Run(run func(ctx context.Context, arg CurrentSqlInstancesCostForTeamParams)) *MockQuerier_CurrentSqlInstancesCostForTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(CurrentSqlInstancesCostForTeamParams))
	})
	return _c
}

func (_c *MockQuerier_CurrentSqlInstancesCostForTeam_Call) Return(_a0 float32, _a1 error) *MockQuerier_CurrentSqlInstancesCostForTeam_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_CurrentSqlInstancesCostForTeam_Call) RunAndReturn(run func(context.Context, CurrentSqlInstancesCostForTeamParams) (float32, error)) *MockQuerier_CurrentSqlInstancesCostForTeam_Call {
	_c.Call.Return(run)
	return _c
}

// DailyCostForApp provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) DailyCostForApp(ctx context.Context, arg DailyCostForAppParams) ([]*Cost, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for DailyCostForApp")
	}

	var r0 []*Cost
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, DailyCostForAppParams) ([]*Cost, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, DailyCostForAppParams) []*Cost); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*Cost)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, DailyCostForAppParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_DailyCostForApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DailyCostForApp'
type MockQuerier_DailyCostForApp_Call struct {
	*mock.Call
}

// DailyCostForApp is a helper method to define mock.On call
//   - ctx context.Context
//   - arg DailyCostForAppParams
func (_e *MockQuerier_Expecter) DailyCostForApp(ctx interface{}, arg interface{}) *MockQuerier_DailyCostForApp_Call {
	return &MockQuerier_DailyCostForApp_Call{Call: _e.mock.On("DailyCostForApp", ctx, arg)}
}

func (_c *MockQuerier_DailyCostForApp_Call) Run(run func(ctx context.Context, arg DailyCostForAppParams)) *MockQuerier_DailyCostForApp_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(DailyCostForAppParams))
	})
	return _c
}

func (_c *MockQuerier_DailyCostForApp_Call) Return(_a0 []*Cost, _a1 error) *MockQuerier_DailyCostForApp_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_DailyCostForApp_Call) RunAndReturn(run func(context.Context, DailyCostForAppParams) ([]*Cost, error)) *MockQuerier_DailyCostForApp_Call {
	_c.Call.Return(run)
	return _c
}

// DailyCostForTeam provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) DailyCostForTeam(ctx context.Context, arg DailyCostForTeamParams) ([]*Cost, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for DailyCostForTeam")
	}

	var r0 []*Cost
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, DailyCostForTeamParams) ([]*Cost, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, DailyCostForTeamParams) []*Cost); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*Cost)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, DailyCostForTeamParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_DailyCostForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DailyCostForTeam'
type MockQuerier_DailyCostForTeam_Call struct {
	*mock.Call
}

// DailyCostForTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - arg DailyCostForTeamParams
func (_e *MockQuerier_Expecter) DailyCostForTeam(ctx interface{}, arg interface{}) *MockQuerier_DailyCostForTeam_Call {
	return &MockQuerier_DailyCostForTeam_Call{Call: _e.mock.On("DailyCostForTeam", ctx, arg)}
}

func (_c *MockQuerier_DailyCostForTeam_Call) Run(run func(ctx context.Context, arg DailyCostForTeamParams)) *MockQuerier_DailyCostForTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(DailyCostForTeamParams))
	})
	return _c
}

func (_c *MockQuerier_DailyCostForTeam_Call) Return(_a0 []*Cost, _a1 error) *MockQuerier_DailyCostForTeam_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_DailyCostForTeam_Call) RunAndReturn(run func(context.Context, DailyCostForTeamParams) ([]*Cost, error)) *MockQuerier_DailyCostForTeam_Call {
	_c.Call.Return(run)
	return _c
}

// DailyEnvCostForTeam provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) DailyEnvCostForTeam(ctx context.Context, arg DailyEnvCostForTeamParams) ([]*DailyEnvCostForTeamRow, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for DailyEnvCostForTeam")
	}

	var r0 []*DailyEnvCostForTeamRow
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, DailyEnvCostForTeamParams) ([]*DailyEnvCostForTeamRow, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, DailyEnvCostForTeamParams) []*DailyEnvCostForTeamRow); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*DailyEnvCostForTeamRow)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, DailyEnvCostForTeamParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_DailyEnvCostForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DailyEnvCostForTeam'
type MockQuerier_DailyEnvCostForTeam_Call struct {
	*mock.Call
}

// DailyEnvCostForTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - arg DailyEnvCostForTeamParams
func (_e *MockQuerier_Expecter) DailyEnvCostForTeam(ctx interface{}, arg interface{}) *MockQuerier_DailyEnvCostForTeam_Call {
	return &MockQuerier_DailyEnvCostForTeam_Call{Call: _e.mock.On("DailyEnvCostForTeam", ctx, arg)}
}

func (_c *MockQuerier_DailyEnvCostForTeam_Call) Run(run func(ctx context.Context, arg DailyEnvCostForTeamParams)) *MockQuerier_DailyEnvCostForTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(DailyEnvCostForTeamParams))
	})
	return _c
}

func (_c *MockQuerier_DailyEnvCostForTeam_Call) Return(_a0 []*DailyEnvCostForTeamRow, _a1 error) *MockQuerier_DailyEnvCostForTeam_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_DailyEnvCostForTeam_Call) RunAndReturn(run func(context.Context, DailyEnvCostForTeamParams) ([]*DailyEnvCostForTeamRow, error)) *MockQuerier_DailyEnvCostForTeam_Call {
	_c.Call.Return(run)
	return _c
}

// DailyVulnerabilityForTeam provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) DailyVulnerabilityForTeam(ctx context.Context, arg DailyVulnerabilityForTeamParams) ([]*DailyVulnerabilityForTeamRow, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for DailyVulnerabilityForTeam")
	}

	var r0 []*DailyVulnerabilityForTeamRow
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, DailyVulnerabilityForTeamParams) ([]*DailyVulnerabilityForTeamRow, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, DailyVulnerabilityForTeamParams) []*DailyVulnerabilityForTeamRow); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*DailyVulnerabilityForTeamRow)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, DailyVulnerabilityForTeamParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_DailyVulnerabilityForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DailyVulnerabilityForTeam'
type MockQuerier_DailyVulnerabilityForTeam_Call struct {
	*mock.Call
}

// DailyVulnerabilityForTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - arg DailyVulnerabilityForTeamParams
func (_e *MockQuerier_Expecter) DailyVulnerabilityForTeam(ctx interface{}, arg interface{}) *MockQuerier_DailyVulnerabilityForTeam_Call {
	return &MockQuerier_DailyVulnerabilityForTeam_Call{Call: _e.mock.On("DailyVulnerabilityForTeam", ctx, arg)}
}

func (_c *MockQuerier_DailyVulnerabilityForTeam_Call) Run(run func(ctx context.Context, arg DailyVulnerabilityForTeamParams)) *MockQuerier_DailyVulnerabilityForTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(DailyVulnerabilityForTeamParams))
	})
	return _c
}

func (_c *MockQuerier_DailyVulnerabilityForTeam_Call) Return(_a0 []*DailyVulnerabilityForTeamRow, _a1 error) *MockQuerier_DailyVulnerabilityForTeam_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_DailyVulnerabilityForTeam_Call) RunAndReturn(run func(context.Context, DailyVulnerabilityForTeamParams) ([]*DailyVulnerabilityForTeamRow, error)) *MockQuerier_DailyVulnerabilityForTeam_Call {
	_c.Call.Return(run)
	return _c
}

// DailyVulnerabilityForTeamAndEnvironment provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) DailyVulnerabilityForTeamAndEnvironment(ctx context.Context, arg DailyVulnerabilityForTeamAndEnvironmentParams) ([]*DailyVulnerabilityForTeamAndEnvironmentRow, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for DailyVulnerabilityForTeamAndEnvironment")
	}

	var r0 []*DailyVulnerabilityForTeamAndEnvironmentRow
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, DailyVulnerabilityForTeamAndEnvironmentParams) ([]*DailyVulnerabilityForTeamAndEnvironmentRow, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, DailyVulnerabilityForTeamAndEnvironmentParams) []*DailyVulnerabilityForTeamAndEnvironmentRow); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*DailyVulnerabilityForTeamAndEnvironmentRow)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, DailyVulnerabilityForTeamAndEnvironmentParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DailyVulnerabilityForTeamAndEnvironment'
type MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call struct {
	*mock.Call
}

// DailyVulnerabilityForTeamAndEnvironment is a helper method to define mock.On call
//   - ctx context.Context
//   - arg DailyVulnerabilityForTeamAndEnvironmentParams
func (_e *MockQuerier_Expecter) DailyVulnerabilityForTeamAndEnvironment(ctx interface{}, arg interface{}) *MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call {
	return &MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call{Call: _e.mock.On("DailyVulnerabilityForTeamAndEnvironment", ctx, arg)}
}

func (_c *MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call) Run(run func(ctx context.Context, arg DailyVulnerabilityForTeamAndEnvironmentParams)) *MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(DailyVulnerabilityForTeamAndEnvironmentParams))
	})
	return _c
}

func (_c *MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call) Return(_a0 []*DailyVulnerabilityForTeamAndEnvironmentRow, _a1 error) *MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call) RunAndReturn(run func(context.Context, DailyVulnerabilityForTeamAndEnvironmentParams) ([]*DailyVulnerabilityForTeamAndEnvironmentRow, error)) *MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteAllEnvironments provides a mock function with given fields: ctx
func (_m *MockQuerier) DeleteAllEnvironments(ctx context.Context) error {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for DeleteAllEnvironments")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_DeleteAllEnvironments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAllEnvironments'
type MockQuerier_DeleteAllEnvironments_Call struct {
	*mock.Call
}

// DeleteAllEnvironments is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockQuerier_Expecter) DeleteAllEnvironments(ctx interface{}) *MockQuerier_DeleteAllEnvironments_Call {
	return &MockQuerier_DeleteAllEnvironments_Call{Call: _e.mock.On("DeleteAllEnvironments", ctx)}
}

func (_c *MockQuerier_DeleteAllEnvironments_Call) Run(run func(ctx context.Context)) *MockQuerier_DeleteAllEnvironments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockQuerier_DeleteAllEnvironments_Call) Return(_a0 error) *MockQuerier_DeleteAllEnvironments_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_DeleteAllEnvironments_Call) RunAndReturn(run func(context.Context) error) *MockQuerier_DeleteAllEnvironments_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteReconcilerConfig provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) DeleteReconcilerConfig(ctx context.Context, arg DeleteReconcilerConfigParams) error {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for DeleteReconcilerConfig")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, DeleteReconcilerConfigParams) error); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_DeleteReconcilerConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteReconcilerConfig'
type MockQuerier_DeleteReconcilerConfig_Call struct {
	*mock.Call
}

// DeleteReconcilerConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - arg DeleteReconcilerConfigParams
func (_e *MockQuerier_Expecter) DeleteReconcilerConfig(ctx interface{}, arg interface{}) *MockQuerier_DeleteReconcilerConfig_Call {
	return &MockQuerier_DeleteReconcilerConfig_Call{Call: _e.mock.On("DeleteReconcilerConfig", ctx, arg)}
}

func (_c *MockQuerier_DeleteReconcilerConfig_Call) Run(run func(ctx context.Context, arg DeleteReconcilerConfigParams)) *MockQuerier_DeleteReconcilerConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(DeleteReconcilerConfigParams))
	})
	return _c
}

func (_c *MockQuerier_DeleteReconcilerConfig_Call) Return(_a0 error) *MockQuerier_DeleteReconcilerConfig_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_DeleteReconcilerConfig_Call) RunAndReturn(run func(context.Context, DeleteReconcilerConfigParams) error) *MockQuerier_DeleteReconcilerConfig_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteReconcilerStateForTeam provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) DeleteReconcilerStateForTeam(ctx context.Context, arg DeleteReconcilerStateForTeamParams) error {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for DeleteReconcilerStateForTeam")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, DeleteReconcilerStateForTeamParams) error); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_DeleteReconcilerStateForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteReconcilerStateForTeam'
type MockQuerier_DeleteReconcilerStateForTeam_Call struct {
	*mock.Call
}

// DeleteReconcilerStateForTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - arg DeleteReconcilerStateForTeamParams
func (_e *MockQuerier_Expecter) DeleteReconcilerStateForTeam(ctx interface{}, arg interface{}) *MockQuerier_DeleteReconcilerStateForTeam_Call {
	return &MockQuerier_DeleteReconcilerStateForTeam_Call{Call: _e.mock.On("DeleteReconcilerStateForTeam", ctx, arg)}
}

func (_c *MockQuerier_DeleteReconcilerStateForTeam_Call) Run(run func(ctx context.Context, arg DeleteReconcilerStateForTeamParams)) *MockQuerier_DeleteReconcilerStateForTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(DeleteReconcilerStateForTeamParams))
	})
	return _c
}

func (_c *MockQuerier_DeleteReconcilerStateForTeam_Call) Return(_a0 error) *MockQuerier_DeleteReconcilerStateForTeam_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_DeleteReconcilerStateForTeam_Call) RunAndReturn(run func(context.Context, DeleteReconcilerStateForTeamParams) error) *MockQuerier_DeleteReconcilerStateForTeam_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteServiceAccount provides a mock function with given fields: ctx, id
func (_m *MockQuerier) DeleteServiceAccount(ctx context.Context, id uuid.UUID) error {
	ret := _m.Called(ctx, id)

	if len(ret) == 0 {
		panic("no return value specified for DeleteServiceAccount")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) error); ok {
		r0 = rf(ctx, id)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_DeleteServiceAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteServiceAccount'
type MockQuerier_DeleteServiceAccount_Call struct {
	*mock.Call
}

// DeleteServiceAccount is a helper method to define mock.On call
//   - ctx context.Context
//   - id uuid.UUID
func (_e *MockQuerier_Expecter) DeleteServiceAccount(ctx interface{}, id interface{}) *MockQuerier_DeleteServiceAccount_Call {
	return &MockQuerier_DeleteServiceAccount_Call{Call: _e.mock.On("DeleteServiceAccount", ctx, id)}
}

func (_c *MockQuerier_DeleteServiceAccount_Call) Run(run func(ctx context.Context, id uuid.UUID)) *MockQuerier_DeleteServiceAccount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uuid.UUID))
	})
	return _c
}

func (_c *MockQuerier_DeleteServiceAccount_Call) Return(_a0 error) *MockQuerier_DeleteServiceAccount_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_DeleteServiceAccount_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *MockQuerier_DeleteServiceAccount_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteSession provides a mock function with given fields: ctx, id
func (_m *MockQuerier) DeleteSession(ctx context.Context, id uuid.UUID) error {
	ret := _m.Called(ctx, id)

	if len(ret) == 0 {
		panic("no return value specified for DeleteSession")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) error); ok {
		r0 = rf(ctx, id)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_DeleteSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSession'
type MockQuerier_DeleteSession_Call struct {
	*mock.Call
}

// DeleteSession is a helper method to define mock.On call
//   - ctx context.Context
//   - id uuid.UUID
func (_e *MockQuerier_Expecter) DeleteSession(ctx interface{}, id interface{}) *MockQuerier_DeleteSession_Call {
	return &MockQuerier_DeleteSession_Call{Call: _e.mock.On("DeleteSession", ctx, id)}
}

func (_c *MockQuerier_DeleteSession_Call) Run(run func(ctx context.Context, id uuid.UUID)) *MockQuerier_DeleteSession_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uuid.UUID))
	})
	return _c
}

func (_c *MockQuerier_DeleteSession_Call) Return(_a0 error) *MockQuerier_DeleteSession_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_DeleteSession_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *MockQuerier_DeleteSession_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTeam provides a mock function with given fields: ctx, argSlug
func (_m *MockQuerier) DeleteTeam(ctx context.Context, argSlug slug.Slug) error {
	ret := _m.Called(ctx, argSlug)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTeam")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, slug.Slug) error); ok {
		r0 = rf(ctx, argSlug)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_DeleteTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTeam'
type MockQuerier_DeleteTeam_Call struct {
	*mock.Call
}

// DeleteTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - argSlug slug.Slug
func (_e *MockQuerier_Expecter) DeleteTeam(ctx interface{}, argSlug interface{}) *MockQuerier_DeleteTeam_Call {
	return &MockQuerier_DeleteTeam_Call{Call: _e.mock.On("DeleteTeam", ctx, argSlug)}
}

func (_c *MockQuerier_DeleteTeam_Call) Run(run func(ctx context.Context, argSlug slug.Slug)) *MockQuerier_DeleteTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(slug.Slug))
	})
	return _c
}

func (_c *MockQuerier_DeleteTeam_Call) Return(_a0 error) *MockQuerier_DeleteTeam_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_DeleteTeam_Call) RunAndReturn(run func(context.Context, slug.Slug) error) *MockQuerier_DeleteTeam_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteUser provides a mock function with given fields: ctx, id
func (_m *MockQuerier) DeleteUser(ctx context.Context, id uuid.UUID) error {
	ret := _m.Called(ctx, id)

	if len(ret) == 0 {
		panic("no return value specified for DeleteUser")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) error); ok {
		r0 = rf(ctx, id)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_DeleteUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUser'
type MockQuerier_DeleteUser_Call struct {
	*mock.Call
}

// DeleteUser is a helper method to define mock.On call
//   - ctx context.Context
//   - id uuid.UUID
func (_e *MockQuerier_Expecter) DeleteUser(ctx interface{}, id interface{}) *MockQuerier_DeleteUser_Call {
	return &MockQuerier_DeleteUser_Call{Call: _e.mock.On("DeleteUser", ctx, id)}
}

func (_c *MockQuerier_DeleteUser_Call) Run(run func(ctx context.Context, id uuid.UUID)) *MockQuerier_DeleteUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uuid.UUID))
	})
	return _c
}

func (_c *MockQuerier_DeleteUser_Call) Return(_a0 error) *MockQuerier_DeleteUser_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_DeleteUser_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *MockQuerier_DeleteUser_Call {
	_c.Call.Return(run)
	return _c
}

// DisableReconciler provides a mock function with given fields: ctx, name
func (_m *MockQuerier) DisableReconciler(ctx context.Context, name string) (*Reconciler, error) {
	ret := _m.Called(ctx, name)

	if len(ret) == 0 {
		panic("no return value specified for DisableReconciler")
	}

	var r0 *Reconciler
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*Reconciler, error)); ok {
		return rf(ctx, name)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *Reconciler); ok {
		r0 = rf(ctx, name)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*Reconciler)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, name)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_DisableReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableReconciler'
type MockQuerier_DisableReconciler_Call struct {
	*mock.Call
}

// DisableReconciler is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
func (_e *MockQuerier_Expecter) DisableReconciler(ctx interface{}, name interface{}) *MockQuerier_DisableReconciler_Call {
	return &MockQuerier_DisableReconciler_Call{Call: _e.mock.On("DisableReconciler", ctx, name)}
}

func (_c *MockQuerier_DisableReconciler_Call) Run(run func(ctx context.Context, name string)) *MockQuerier_DisableReconciler_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockQuerier_DisableReconciler_Call) Return(_a0 *Reconciler, _a1 error) *MockQuerier_DisableReconciler_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_DisableReconciler_Call) RunAndReturn(run func(context.Context, string) (*Reconciler, error)) *MockQuerier_DisableReconciler_Call {
	_c.Call.Return(run)
	return _c
}

// EnableReconciler provides a mock function with given fields: ctx, name
func (_m *MockQuerier) EnableReconciler(ctx context.Context, name string) (*Reconciler, error) {
	ret := _m.Called(ctx, name)

	if len(ret) == 0 {
		panic("no return value specified for EnableReconciler")
	}

	var r0 *Reconciler
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*Reconciler, error)); ok {
		return rf(ctx, name)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *Reconciler); ok {
		r0 = rf(ctx, name)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*Reconciler)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, name)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_EnableReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableReconciler'
type MockQuerier_EnableReconciler_Call struct {
	*mock.Call
}

// EnableReconciler is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
func (_e *MockQuerier_Expecter) EnableReconciler(ctx interface{}, name interface{}) *MockQuerier_EnableReconciler_Call {
	return &MockQuerier_EnableReconciler_Call{Call: _e.mock.On("EnableReconciler", ctx, name)}
}

func (_c *MockQuerier_EnableReconciler_Call) Run(run func(ctx context.Context, name string)) *MockQuerier_EnableReconciler_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockQuerier_EnableReconciler_Call) Return(_a0 *Reconciler, _a1 error) *MockQuerier_EnableReconciler_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_EnableReconciler_Call) RunAndReturn(run func(context.Context, string) (*Reconciler, error)) *MockQuerier_EnableReconciler_Call {
	_c.Call.Return(run)
	return _c
}

// GetActiveTeamBySlug provides a mock function with given fields: ctx, argSlug
func (_m *MockQuerier) GetActiveTeamBySlug(ctx context.Context, argSlug slug.Slug) (*Team, error) {
	ret := _m.Called(ctx, argSlug)

	if len(ret) == 0 {
		panic("no return value specified for GetActiveTeamBySlug")
	}

	var r0 *Team
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, slug.Slug) (*Team, error)); ok {
		return rf(ctx, argSlug)
	}
	if rf, ok := ret.Get(0).(func(context.Context, slug.Slug) *Team); ok {
		r0 = rf(ctx, argSlug)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*Team)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, slug.Slug) error); ok {
		r1 = rf(ctx, argSlug)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetActiveTeamBySlug_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActiveTeamBySlug'
type MockQuerier_GetActiveTeamBySlug_Call struct {
	*mock.Call
}

// GetActiveTeamBySlug is a helper method to define mock.On call
//   - ctx context.Context
//   - argSlug slug.Slug
func (_e *MockQuerier_Expecter) GetActiveTeamBySlug(ctx interface{}, argSlug interface{}) *MockQuerier_GetActiveTeamBySlug_Call {
	return &MockQuerier_GetActiveTeamBySlug_Call{Call: _e.mock.On("GetActiveTeamBySlug", ctx, argSlug)}
}

func (_c *MockQuerier_GetActiveTeamBySlug_Call) Run(run func(ctx context.Context, argSlug slug.Slug)) *MockQuerier_GetActiveTeamBySlug_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(slug.Slug))
	})
	return _c
}

func (_c *MockQuerier_GetActiveTeamBySlug_Call) Return(_a0 *Team, _a1 error) *MockQuerier_GetActiveTeamBySlug_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetActiveTeamBySlug_Call) RunAndReturn(run func(context.Context, slug.Slug) (*Team, error)) *MockQuerier_GetActiveTeamBySlug_Call {
	_c.Call.Return(run)
	return _c
}

// GetActiveTeams provides a mock function with given fields: ctx
func (_m *MockQuerier) GetActiveTeams(ctx context.Context) ([]*Team, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetActiveTeams")
	}

	var r0 []*Team
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]*Team, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []*Team); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*Team)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetActiveTeams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActiveTeams'
type MockQuerier_GetActiveTeams_Call struct {
	*mock.Call
}

// GetActiveTeams is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockQuerier_Expecter) GetActiveTeams(ctx interface{}) *MockQuerier_GetActiveTeams_Call {
	return &MockQuerier_GetActiveTeams_Call{Call: _e.mock.On("GetActiveTeams", ctx)}
}

func (_c *MockQuerier_GetActiveTeams_Call) Run(run func(ctx context.Context)) *MockQuerier_GetActiveTeams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockQuerier_GetActiveTeams_Call) Return(_a0 []*Team, _a1 error) *MockQuerier_GetActiveTeams_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetActiveTeams_Call) RunAndReturn(run func(context.Context) ([]*Team, error)) *MockQuerier_GetActiveTeams_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllTeamMembers provides a mock function with given fields: ctx, teamSlug
func (_m *MockQuerier) GetAllTeamMembers(ctx context.Context, teamSlug *slug.Slug) ([]*User, error) {
	ret := _m.Called(ctx, teamSlug)

	if len(ret) == 0 {
		panic("no return value specified for GetAllTeamMembers")
	}

	var r0 []*User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *slug.Slug) ([]*User, error)); ok {
		return rf(ctx, teamSlug)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *slug.Slug) []*User); ok {
		r0 = rf(ctx, teamSlug)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*User)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *slug.Slug) error); ok {
		r1 = rf(ctx, teamSlug)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetAllTeamMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllTeamMembers'
type MockQuerier_GetAllTeamMembers_Call struct {
	*mock.Call
}

// GetAllTeamMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - teamSlug *slug.Slug
func (_e *MockQuerier_Expecter) GetAllTeamMembers(ctx interface{}, teamSlug interface{}) *MockQuerier_GetAllTeamMembers_Call {
	return &MockQuerier_GetAllTeamMembers_Call{Call: _e.mock.On("GetAllTeamMembers", ctx, teamSlug)}
}

func (_c *MockQuerier_GetAllTeamMembers_Call) Run(run func(ctx context.Context, teamSlug *slug.Slug)) *MockQuerier_GetAllTeamMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*slug.Slug))
	})
	return _c
}

func (_c *MockQuerier_GetAllTeamMembers_Call) Return(_a0 []*User, _a1 error) *MockQuerier_GetAllTeamMembers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetAllTeamMembers_Call) RunAndReturn(run func(context.Context, *slug.Slug) ([]*User, error)) *MockQuerier_GetAllTeamMembers_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllTeamSlugs provides a mock function with given fields: ctx
func (_m *MockQuerier) GetAllTeamSlugs(ctx context.Context) ([]slug.Slug, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetAllTeamSlugs")
	}

	var r0 []slug.Slug
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]slug.Slug, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []slug.Slug); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]slug.Slug)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetAllTeamSlugs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllTeamSlugs'
type MockQuerier_GetAllTeamSlugs_Call struct {
	*mock.Call
}

// GetAllTeamSlugs is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockQuerier_Expecter) GetAllTeamSlugs(ctx interface{}) *MockQuerier_GetAllTeamSlugs_Call {
	return &MockQuerier_GetAllTeamSlugs_Call{Call: _e.mock.On("GetAllTeamSlugs", ctx)}
}

func (_c *MockQuerier_GetAllTeamSlugs_Call) Run(run func(ctx context.Context)) *MockQuerier_GetAllTeamSlugs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockQuerier_GetAllTeamSlugs_Call) Return(_a0 []slug.Slug, _a1 error) *MockQuerier_GetAllTeamSlugs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetAllTeamSlugs_Call) RunAndReturn(run func(context.Context) ([]slug.Slug, error)) *MockQuerier_GetAllTeamSlugs_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllUserRoles provides a mock function with given fields: ctx
func (_m *MockQuerier) GetAllUserRoles(ctx context.Context) ([]*UserRole, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetAllUserRoles")
	}

	var r0 []*UserRole
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]*UserRole, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []*UserRole); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*UserRole)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetAllUserRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllUserRoles'
type MockQuerier_GetAllUserRoles_Call struct {
	*mock.Call
}

// GetAllUserRoles is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockQuerier_Expecter) GetAllUserRoles(ctx interface{}) *MockQuerier_GetAllUserRoles_Call {
	return &MockQuerier_GetAllUserRoles_Call{Call: _e.mock.On("GetAllUserRoles", ctx)}
}

func (_c *MockQuerier_GetAllUserRoles_Call) Run(run func(ctx context.Context)) *MockQuerier_GetAllUserRoles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockQuerier_GetAllUserRoles_Call) Return(_a0 []*UserRole, _a1 error) *MockQuerier_GetAllUserRoles_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetAllUserRoles_Call) RunAndReturn(run func(context.Context) ([]*UserRole, error)) *MockQuerier_GetAllUserRoles_Call {
	_c.Call.Return(run)
	return _c
}

// GetAuditLogsForCorrelationID provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) GetAuditLogsForCorrelationID(ctx context.Context, arg GetAuditLogsForCorrelationIDParams) ([]*AuditLog, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for GetAuditLogsForCorrelationID")
	}

	var r0 []*AuditLog
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, GetAuditLogsForCorrelationIDParams) ([]*AuditLog, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, GetAuditLogsForCorrelationIDParams) []*AuditLog); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*AuditLog)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, GetAuditLogsForCorrelationIDParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetAuditLogsForCorrelationID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuditLogsForCorrelationID'
type MockQuerier_GetAuditLogsForCorrelationID_Call struct {
	*mock.Call
}

// GetAuditLogsForCorrelationID is a helper method to define mock.On call
//   - ctx context.Context
//   - arg GetAuditLogsForCorrelationIDParams
func (_e *MockQuerier_Expecter) GetAuditLogsForCorrelationID(ctx interface{}, arg interface{}) *MockQuerier_GetAuditLogsForCorrelationID_Call {
	return &MockQuerier_GetAuditLogsForCorrelationID_Call{Call: _e.mock.On("GetAuditLogsForCorrelationID", ctx, arg)}
}

func (_c *MockQuerier_GetAuditLogsForCorrelationID_Call) Run(run func(ctx context.Context, arg GetAuditLogsForCorrelationIDParams)) *MockQuerier_GetAuditLogsForCorrelationID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(GetAuditLogsForCorrelationIDParams))
	})
	return _c
}

func (_c *MockQuerier_GetAuditLogsForCorrelationID_Call) Return(_a0 []*AuditLog, _a1 error) *MockQuerier_GetAuditLogsForCorrelationID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetAuditLogsForCorrelationID_Call) RunAndReturn(run func(context.Context, GetAuditLogsForCorrelationIDParams) ([]*AuditLog, error)) *MockQuerier_GetAuditLogsForCorrelationID_Call {
	_c.Call.Return(run)
	return _c
}

// GetAuditLogsForCorrelationIDCount provides a mock function with given fields: ctx, correlationID
func (_m *MockQuerier) GetAuditLogsForCorrelationIDCount(ctx context.Context, correlationID uuid.UUID) (int64, error) {
	ret := _m.Called(ctx, correlationID)

	if len(ret) == 0 {
		panic("no return value specified for GetAuditLogsForCorrelationIDCount")
	}

	var r0 int64
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) (int64, error)); ok {
		return rf(ctx, correlationID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) int64); ok {
		r0 = rf(ctx, correlationID)
	} else {
		r0 = ret.Get(0).(int64)
	}

	if rf, ok := ret.Get(1).(func(context.Context, uuid.UUID) error); ok {
		r1 = rf(ctx, correlationID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetAuditLogsForCorrelationIDCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuditLogsForCorrelationIDCount'
type MockQuerier_GetAuditLogsForCorrelationIDCount_Call struct {
	*mock.Call
}

// GetAuditLogsForCorrelationIDCount is a helper method to define mock.On call
//   - ctx context.Context
//   - correlationID uuid.UUID
func (_e *MockQuerier_Expecter) GetAuditLogsForCorrelationIDCount(ctx interface{}, correlationID interface{}) *MockQuerier_GetAuditLogsForCorrelationIDCount_Call {
	return &MockQuerier_GetAuditLogsForCorrelationIDCount_Call{Call: _e.mock.On("GetAuditLogsForCorrelationIDCount", ctx, correlationID)}
}

func (_c *MockQuerier_GetAuditLogsForCorrelationIDCount_Call) Run(run func(ctx context.Context, correlationID uuid.UUID)) *MockQuerier_GetAuditLogsForCorrelationIDCount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uuid.UUID))
	})
	return _c
}

func (_c *MockQuerier_GetAuditLogsForCorrelationIDCount_Call) Return(_a0 int64, _a1 error) *MockQuerier_GetAuditLogsForCorrelationIDCount_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetAuditLogsForCorrelationIDCount_Call) RunAndReturn(run func(context.Context, uuid.UUID) (int64, error)) *MockQuerier_GetAuditLogsForCorrelationIDCount_Call {
	_c.Call.Return(run)
	return _c
}

// GetAuditLogsForReconciler provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) GetAuditLogsForReconciler(ctx context.Context, arg GetAuditLogsForReconcilerParams) ([]*AuditLog, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for GetAuditLogsForReconciler")
	}

	var r0 []*AuditLog
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, GetAuditLogsForReconcilerParams) ([]*AuditLog, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, GetAuditLogsForReconcilerParams) []*AuditLog); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*AuditLog)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, GetAuditLogsForReconcilerParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetAuditLogsForReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuditLogsForReconciler'
type MockQuerier_GetAuditLogsForReconciler_Call struct {
	*mock.Call
}

// GetAuditLogsForReconciler is a helper method to define mock.On call
//   - ctx context.Context
//   - arg GetAuditLogsForReconcilerParams
func (_e *MockQuerier_Expecter) GetAuditLogsForReconciler(ctx interface{}, arg interface{}) *MockQuerier_GetAuditLogsForReconciler_Call {
	return &MockQuerier_GetAuditLogsForReconciler_Call{Call: _e.mock.On("GetAuditLogsForReconciler", ctx, arg)}
}

func (_c *MockQuerier_GetAuditLogsForReconciler_Call) Run(run func(ctx context.Context, arg GetAuditLogsForReconcilerParams)) *MockQuerier_GetAuditLogsForReconciler_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(GetAuditLogsForReconcilerParams))
	})
	return _c
}

func (_c *MockQuerier_GetAuditLogsForReconciler_Call) Return(_a0 []*AuditLog, _a1 error) *MockQuerier_GetAuditLogsForReconciler_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetAuditLogsForReconciler_Call) RunAndReturn(run func(context.Context, GetAuditLogsForReconcilerParams) ([]*AuditLog, error)) *MockQuerier_GetAuditLogsForReconciler_Call {
	_c.Call.Return(run)
	return _c
}

// GetAuditLogsForReconcilerCount provides a mock function with given fields: ctx, targetIdentifier
func (_m *MockQuerier) GetAuditLogsForReconcilerCount(ctx context.Context, targetIdentifier string) (int64, error) {
	ret := _m.Called(ctx, targetIdentifier)

	if len(ret) == 0 {
		panic("no return value specified for GetAuditLogsForReconcilerCount")
	}

	var r0 int64
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (int64, error)); ok {
		return rf(ctx, targetIdentifier)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) int64); ok {
		r0 = rf(ctx, targetIdentifier)
	} else {
		r0 = ret.Get(0).(int64)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, targetIdentifier)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetAuditLogsForReconcilerCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuditLogsForReconcilerCount'
type MockQuerier_GetAuditLogsForReconcilerCount_Call struct {
	*mock.Call
}

// GetAuditLogsForReconcilerCount is a helper method to define mock.On call
//   - ctx context.Context
//   - targetIdentifier string
func (_e *MockQuerier_Expecter) GetAuditLogsForReconcilerCount(ctx interface{}, targetIdentifier interface{}) *MockQuerier_GetAuditLogsForReconcilerCount_Call {
	return &MockQuerier_GetAuditLogsForReconcilerCount_Call{Call: _e.mock.On("GetAuditLogsForReconcilerCount", ctx, targetIdentifier)}
}

func (_c *MockQuerier_GetAuditLogsForReconcilerCount_Call) Run(run func(ctx context.Context, targetIdentifier string)) *MockQuerier_GetAuditLogsForReconcilerCount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockQuerier_GetAuditLogsForReconcilerCount_Call) Return(_a0 int64, _a1 error) *MockQuerier_GetAuditLogsForReconcilerCount_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetAuditLogsForReconcilerCount_Call) RunAndReturn(run func(context.Context, string) (int64, error)) *MockQuerier_GetAuditLogsForReconcilerCount_Call {
	_c.Call.Return(run)
	return _c
}

// GetAuditLogsForTeam provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) GetAuditLogsForTeam(ctx context.Context, arg GetAuditLogsForTeamParams) ([]*AuditLog, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for GetAuditLogsForTeam")
	}

	var r0 []*AuditLog
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, GetAuditLogsForTeamParams) ([]*AuditLog, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, GetAuditLogsForTeamParams) []*AuditLog); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*AuditLog)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, GetAuditLogsForTeamParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetAuditLogsForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuditLogsForTeam'
type MockQuerier_GetAuditLogsForTeam_Call struct {
	*mock.Call
}

// GetAuditLogsForTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - arg GetAuditLogsForTeamParams
func (_e *MockQuerier_Expecter) GetAuditLogsForTeam(ctx interface{}, arg interface{}) *MockQuerier_GetAuditLogsForTeam_Call {
	return &MockQuerier_GetAuditLogsForTeam_Call{Call: _e.mock.On("GetAuditLogsForTeam", ctx, arg)}
}

func (_c *MockQuerier_GetAuditLogsForTeam_Call) Run(run func(ctx context.Context, arg GetAuditLogsForTeamParams)) *MockQuerier_GetAuditLogsForTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(GetAuditLogsForTeamParams))
	})
	return _c
}

func (_c *MockQuerier_GetAuditLogsForTeam_Call) Return(_a0 []*AuditLog, _a1 error) *MockQuerier_GetAuditLogsForTeam_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetAuditLogsForTeam_Call) RunAndReturn(run func(context.Context, GetAuditLogsForTeamParams) ([]*AuditLog, error)) *MockQuerier_GetAuditLogsForTeam_Call {
	_c.Call.Return(run)
	return _c
}

// GetAuditLogsForTeamCount provides a mock function with given fields: ctx, targetIdentifier
func (_m *MockQuerier) GetAuditLogsForTeamCount(ctx context.Context, targetIdentifier string) (int64, error) {
	ret := _m.Called(ctx, targetIdentifier)

	if len(ret) == 0 {
		panic("no return value specified for GetAuditLogsForTeamCount")
	}

	var r0 int64
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (int64, error)); ok {
		return rf(ctx, targetIdentifier)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) int64); ok {
		r0 = rf(ctx, targetIdentifier)
	} else {
		r0 = ret.Get(0).(int64)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, targetIdentifier)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetAuditLogsForTeamCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuditLogsForTeamCount'
type MockQuerier_GetAuditLogsForTeamCount_Call struct {
	*mock.Call
}

// GetAuditLogsForTeamCount is a helper method to define mock.On call
//   - ctx context.Context
//   - targetIdentifier string
func (_e *MockQuerier_Expecter) GetAuditLogsForTeamCount(ctx interface{}, targetIdentifier interface{}) *MockQuerier_GetAuditLogsForTeamCount_Call {
	return &MockQuerier_GetAuditLogsForTeamCount_Call{Call: _e.mock.On("GetAuditLogsForTeamCount", ctx, targetIdentifier)}
}

func (_c *MockQuerier_GetAuditLogsForTeamCount_Call) Run(run func(ctx context.Context, targetIdentifier string)) *MockQuerier_GetAuditLogsForTeamCount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockQuerier_GetAuditLogsForTeamCount_Call) Return(_a0 int64, _a1 error) *MockQuerier_GetAuditLogsForTeamCount_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetAuditLogsForTeamCount_Call) RunAndReturn(run func(context.Context, string) (int64, error)) *MockQuerier_GetAuditLogsForTeamCount_Call {
	_c.Call.Return(run)
	return _c
}

// GetEnabledReconcilers provides a mock function with given fields: ctx
func (_m *MockQuerier) GetEnabledReconcilers(ctx context.Context) ([]*Reconciler, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetEnabledReconcilers")
	}

	var r0 []*Reconciler
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]*Reconciler, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []*Reconciler); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*Reconciler)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetEnabledReconcilers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEnabledReconcilers'
type MockQuerier_GetEnabledReconcilers_Call struct {
	*mock.Call
}

// GetEnabledReconcilers is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockQuerier_Expecter) GetEnabledReconcilers(ctx interface{}) *MockQuerier_GetEnabledReconcilers_Call {
	return &MockQuerier_GetEnabledReconcilers_Call{Call: _e.mock.On("GetEnabledReconcilers", ctx)}
}

func (_c *MockQuerier_GetEnabledReconcilers_Call) Run(run func(ctx context.Context)) *MockQuerier_GetEnabledReconcilers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockQuerier_GetEnabledReconcilers_Call) Return(_a0 []*Reconciler, _a1 error) *MockQuerier_GetEnabledReconcilers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetEnabledReconcilers_Call) RunAndReturn(run func(context.Context) ([]*Reconciler, error)) *MockQuerier_GetEnabledReconcilers_Call {
	_c.Call.Return(run)
	return _c
}

// GetReconciler provides a mock function with given fields: ctx, name
func (_m *MockQuerier) GetReconciler(ctx context.Context, name string) (*Reconciler, error) {
	ret := _m.Called(ctx, name)

	if len(ret) == 0 {
		panic("no return value specified for GetReconciler")
	}

	var r0 *Reconciler
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*Reconciler, error)); ok {
		return rf(ctx, name)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *Reconciler); ok {
		r0 = rf(ctx, name)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*Reconciler)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, name)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReconciler'
type MockQuerier_GetReconciler_Call struct {
	*mock.Call
}

// GetReconciler is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
func (_e *MockQuerier_Expecter) GetReconciler(ctx interface{}, name interface{}) *MockQuerier_GetReconciler_Call {
	return &MockQuerier_GetReconciler_Call{Call: _e.mock.On("GetReconciler", ctx, name)}
}

func (_c *MockQuerier_GetReconciler_Call) Run(run func(ctx context.Context, name string)) *MockQuerier_GetReconciler_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockQuerier_GetReconciler_Call) Return(_a0 *Reconciler, _a1 error) *MockQuerier_GetReconciler_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetReconciler_Call) RunAndReturn(run func(context.Context, string) (*Reconciler, error)) *MockQuerier_GetReconciler_Call {
	_c.Call.Return(run)
	return _c
}

// GetReconcilerConfig provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) GetReconcilerConfig(ctx context.Context, arg GetReconcilerConfigParams) ([]*GetReconcilerConfigRow, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for GetReconcilerConfig")
	}

	var r0 []*GetReconcilerConfigRow
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, GetReconcilerConfigParams) ([]*GetReconcilerConfigRow, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, GetReconcilerConfigParams) []*GetReconcilerConfigRow); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*GetReconcilerConfigRow)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, GetReconcilerConfigParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetReconcilerConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReconcilerConfig'
type MockQuerier_GetReconcilerConfig_Call struct {
	*mock.Call
}

// GetReconcilerConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - arg GetReconcilerConfigParams
func (_e *MockQuerier_Expecter) GetReconcilerConfig(ctx interface{}, arg interface{}) *MockQuerier_GetReconcilerConfig_Call {
	return &MockQuerier_GetReconcilerConfig_Call{Call: _e.mock.On("GetReconcilerConfig", ctx, arg)}
}

func (_c *MockQuerier_GetReconcilerConfig_Call) Run(run func(ctx context.Context, arg GetReconcilerConfigParams)) *MockQuerier_GetReconcilerConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(GetReconcilerConfigParams))
	})
	return _c
}

func (_c *MockQuerier_GetReconcilerConfig_Call) Return(_a0 []*GetReconcilerConfigRow, _a1 error) *MockQuerier_GetReconcilerConfig_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetReconcilerConfig_Call) RunAndReturn(run func(context.Context, GetReconcilerConfigParams) ([]*GetReconcilerConfigRow, error)) *MockQuerier_GetReconcilerConfig_Call {
	_c.Call.Return(run)
	return _c
}

// GetReconcilerState provides a mock function with given fields: ctx, reconcilerName
func (_m *MockQuerier) GetReconcilerState(ctx context.Context, reconcilerName string) ([]*GetReconcilerStateRow, error) {
	ret := _m.Called(ctx, reconcilerName)

	if len(ret) == 0 {
		panic("no return value specified for GetReconcilerState")
	}

	var r0 []*GetReconcilerStateRow
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) ([]*GetReconcilerStateRow, error)); ok {
		return rf(ctx, reconcilerName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) []*GetReconcilerStateRow); ok {
		r0 = rf(ctx, reconcilerName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*GetReconcilerStateRow)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, reconcilerName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetReconcilerState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReconcilerState'
type MockQuerier_GetReconcilerState_Call struct {
	*mock.Call
}

// GetReconcilerState is a helper method to define mock.On call
//   - ctx context.Context
//   - reconcilerName string
func (_e *MockQuerier_Expecter) GetReconcilerState(ctx interface{}, reconcilerName interface{}) *MockQuerier_GetReconcilerState_Call {
	return &MockQuerier_GetReconcilerState_Call{Call: _e.mock.On("GetReconcilerState", ctx, reconcilerName)}
}

func (_c *MockQuerier_GetReconcilerState_Call) Run(run func(ctx context.Context, reconcilerName string)) *MockQuerier_GetReconcilerState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockQuerier_GetReconcilerState_Call) Return(_a0 []*GetReconcilerStateRow, _a1 error) *MockQuerier_GetReconcilerState_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetReconcilerState_Call) RunAndReturn(run func(context.Context, string) ([]*GetReconcilerStateRow, error)) *MockQuerier_GetReconcilerState_Call {
	_c.Call.Return(run)
	return _c
}

// GetReconcilerStateForTeam provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) GetReconcilerStateForTeam(ctx context.Context, arg GetReconcilerStateForTeamParams) (*ReconcilerState, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for GetReconcilerStateForTeam")
	}

	var r0 *ReconcilerState
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, GetReconcilerStateForTeamParams) (*ReconcilerState, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, GetReconcilerStateForTeamParams) *ReconcilerState); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ReconcilerState)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, GetReconcilerStateForTeamParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetReconcilerStateForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReconcilerStateForTeam'
type MockQuerier_GetReconcilerStateForTeam_Call struct {
	*mock.Call
}

// GetReconcilerStateForTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - arg GetReconcilerStateForTeamParams
func (_e *MockQuerier_Expecter) GetReconcilerStateForTeam(ctx interface{}, arg interface{}) *MockQuerier_GetReconcilerStateForTeam_Call {
	return &MockQuerier_GetReconcilerStateForTeam_Call{Call: _e.mock.On("GetReconcilerStateForTeam", ctx, arg)}
}

func (_c *MockQuerier_GetReconcilerStateForTeam_Call) Run(run func(ctx context.Context, arg GetReconcilerStateForTeamParams)) *MockQuerier_GetReconcilerStateForTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(GetReconcilerStateForTeamParams))
	})
	return _c
}

func (_c *MockQuerier_GetReconcilerStateForTeam_Call) Return(_a0 *ReconcilerState, _a1 error) *MockQuerier_GetReconcilerStateForTeam_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetReconcilerStateForTeam_Call) RunAndReturn(run func(context.Context, GetReconcilerStateForTeamParams) (*ReconcilerState, error)) *MockQuerier_GetReconcilerStateForTeam_Call {
	_c.Call.Return(run)
	return _c
}

// GetReconcilers provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) GetReconcilers(ctx context.Context, arg GetReconcilersParams) ([]*Reconciler, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for GetReconcilers")
	}

	var r0 []*Reconciler
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, GetReconcilersParams) ([]*Reconciler, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, GetReconcilersParams) []*Reconciler); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*Reconciler)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, GetReconcilersParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetReconcilers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReconcilers'
type MockQuerier_GetReconcilers_Call struct {
	*mock.Call
}

// GetReconcilers is a helper method to define mock.On call
//   - ctx context.Context
//   - arg GetReconcilersParams
func (_e *MockQuerier_Expecter) GetReconcilers(ctx interface{}, arg interface{}) *MockQuerier_GetReconcilers_Call {
	return &MockQuerier_GetReconcilers_Call{Call: _e.mock.On("GetReconcilers", ctx, arg)}
}

func (_c *MockQuerier_GetReconcilers_Call) Run(run func(ctx context.Context, arg GetReconcilersParams)) *MockQuerier_GetReconcilers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(GetReconcilersParams))
	})
	return _c
}

func (_c *MockQuerier_GetReconcilers_Call) Return(_a0 []*Reconciler, _a1 error) *MockQuerier_GetReconcilers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetReconcilers_Call) RunAndReturn(run func(context.Context, GetReconcilersParams) ([]*Reconciler, error)) *MockQuerier_GetReconcilers_Call {
	_c.Call.Return(run)
	return _c
}

// GetReconcilersCount provides a mock function with given fields: ctx
func (_m *MockQuerier) GetReconcilersCount(ctx context.Context) (int64, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetReconcilersCount")
	}

	var r0 int64
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (int64, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) int64); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Get(0).(int64)
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetReconcilersCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReconcilersCount'
type MockQuerier_GetReconcilersCount_Call struct {
	*mock.Call
}

// GetReconcilersCount is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockQuerier_Expecter) GetReconcilersCount(ctx interface{}) *MockQuerier_GetReconcilersCount_Call {
	return &MockQuerier_GetReconcilersCount_Call{Call: _e.mock.On("GetReconcilersCount", ctx)}
}

func (_c *MockQuerier_GetReconcilersCount_Call) Run(run func(ctx context.Context)) *MockQuerier_GetReconcilersCount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockQuerier_GetReconcilersCount_Call) Return(_a0 int64, _a1 error) *MockQuerier_GetReconcilersCount_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetReconcilersCount_Call) RunAndReturn(run func(context.Context) (int64, error)) *MockQuerier_GetReconcilersCount_Call {
	_c.Call.Return(run)
	return _c
}

// GetRepositoryAuthorizations provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) GetRepositoryAuthorizations(ctx context.Context, arg GetRepositoryAuthorizationsParams) ([]RepositoryAuthorizationEnum, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for GetRepositoryAuthorizations")
	}

	var r0 []RepositoryAuthorizationEnum
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, GetRepositoryAuthorizationsParams) ([]RepositoryAuthorizationEnum, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, GetRepositoryAuthorizationsParams) []RepositoryAuthorizationEnum); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]RepositoryAuthorizationEnum)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, GetRepositoryAuthorizationsParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetRepositoryAuthorizations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRepositoryAuthorizations'
type MockQuerier_GetRepositoryAuthorizations_Call struct {
	*mock.Call
}

// GetRepositoryAuthorizations is a helper method to define mock.On call
//   - ctx context.Context
//   - arg GetRepositoryAuthorizationsParams
func (_e *MockQuerier_Expecter) GetRepositoryAuthorizations(ctx interface{}, arg interface{}) *MockQuerier_GetRepositoryAuthorizations_Call {
	return &MockQuerier_GetRepositoryAuthorizations_Call{Call: _e.mock.On("GetRepositoryAuthorizations", ctx, arg)}
}

func (_c *MockQuerier_GetRepositoryAuthorizations_Call) Run(run func(ctx context.Context, arg GetRepositoryAuthorizationsParams)) *MockQuerier_GetRepositoryAuthorizations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(GetRepositoryAuthorizationsParams))
	})
	return _c
}

func (_c *MockQuerier_GetRepositoryAuthorizations_Call) Return(_a0 []RepositoryAuthorizationEnum, _a1 error) *MockQuerier_GetRepositoryAuthorizations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetRepositoryAuthorizations_Call) RunAndReturn(run func(context.Context, GetRepositoryAuthorizationsParams) ([]RepositoryAuthorizationEnum, error)) *MockQuerier_GetRepositoryAuthorizations_Call {
	_c.Call.Return(run)
	return _c
}

// GetServiceAccountByApiKey provides a mock function with given fields: ctx, apiKey
func (_m *MockQuerier) GetServiceAccountByApiKey(ctx context.Context, apiKey string) (*ServiceAccount, error) {
	ret := _m.Called(ctx, apiKey)

	if len(ret) == 0 {
		panic("no return value specified for GetServiceAccountByApiKey")
	}

	var r0 *ServiceAccount
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*ServiceAccount, error)); ok {
		return rf(ctx, apiKey)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *ServiceAccount); ok {
		r0 = rf(ctx, apiKey)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ServiceAccount)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, apiKey)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetServiceAccountByApiKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccountByApiKey'
type MockQuerier_GetServiceAccountByApiKey_Call struct {
	*mock.Call
}

// GetServiceAccountByApiKey is a helper method to define mock.On call
//   - ctx context.Context
//   - apiKey string
func (_e *MockQuerier_Expecter) GetServiceAccountByApiKey(ctx interface{}, apiKey interface{}) *MockQuerier_GetServiceAccountByApiKey_Call {
	return &MockQuerier_GetServiceAccountByApiKey_Call{Call: _e.mock.On("GetServiceAccountByApiKey", ctx, apiKey)}
}

func (_c *MockQuerier_GetServiceAccountByApiKey_Call) Run(run func(ctx context.Context, apiKey string)) *MockQuerier_GetServiceAccountByApiKey_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockQuerier_GetServiceAccountByApiKey_Call) Return(_a0 *ServiceAccount, _a1 error) *MockQuerier_GetServiceAccountByApiKey_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetServiceAccountByApiKey_Call) RunAndReturn(run func(context.Context, string) (*ServiceAccount, error)) *MockQuerier_GetServiceAccountByApiKey_Call {
	_c.Call.Return(run)
	return _c
}

// GetServiceAccountByName provides a mock function with given fields: ctx, name
func (_m *MockQuerier) GetServiceAccountByName(ctx context.Context, name string) (*ServiceAccount, error) {
	ret := _m.Called(ctx, name)

	if len(ret) == 0 {
		panic("no return value specified for GetServiceAccountByName")
	}

	var r0 *ServiceAccount
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*ServiceAccount, error)); ok {
		return rf(ctx, name)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *ServiceAccount); ok {
		r0 = rf(ctx, name)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ServiceAccount)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, name)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetServiceAccountByName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccountByName'
type MockQuerier_GetServiceAccountByName_Call struct {
	*mock.Call
}

// GetServiceAccountByName is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
func (_e *MockQuerier_Expecter) GetServiceAccountByName(ctx interface{}, name interface{}) *MockQuerier_GetServiceAccountByName_Call {
	return &MockQuerier_GetServiceAccountByName_Call{Call: _e.mock.On("GetServiceAccountByName", ctx, name)}
}

func (_c *MockQuerier_GetServiceAccountByName_Call) Run(run func(ctx context.Context, name string)) *MockQuerier_GetServiceAccountByName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockQuerier_GetServiceAccountByName_Call) Return(_a0 *ServiceAccount, _a1 error) *MockQuerier_GetServiceAccountByName_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetServiceAccountByName_Call) RunAndReturn(run func(context.Context, string) (*ServiceAccount, error)) *MockQuerier_GetServiceAccountByName_Call {
	_c.Call.Return(run)
	return _c
}

// GetServiceAccountRoles provides a mock function with given fields: ctx, serviceAccountID
func (_m *MockQuerier) GetServiceAccountRoles(ctx context.Context, serviceAccountID uuid.UUID) ([]*ServiceAccountRole, error) {
	ret := _m.Called(ctx, serviceAccountID)

	if len(ret) == 0 {
		panic("no return value specified for GetServiceAccountRoles")
	}

	var r0 []*ServiceAccountRole
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) ([]*ServiceAccountRole, error)); ok {
		return rf(ctx, serviceAccountID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) []*ServiceAccountRole); ok {
		r0 = rf(ctx, serviceAccountID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*ServiceAccountRole)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uuid.UUID) error); ok {
		r1 = rf(ctx, serviceAccountID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetServiceAccountRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccountRoles'
type MockQuerier_GetServiceAccountRoles_Call struct {
	*mock.Call
}

// GetServiceAccountRoles is a helper method to define mock.On call
//   - ctx context.Context
//   - serviceAccountID uuid.UUID
func (_e *MockQuerier_Expecter) GetServiceAccountRoles(ctx interface{}, serviceAccountID interface{}) *MockQuerier_GetServiceAccountRoles_Call {
	return &MockQuerier_GetServiceAccountRoles_Call{Call: _e.mock.On("GetServiceAccountRoles", ctx, serviceAccountID)}
}

func (_c *MockQuerier_GetServiceAccountRoles_Call) Run(run func(ctx context.Context, serviceAccountID uuid.UUID)) *MockQuerier_GetServiceAccountRoles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uuid.UUID))
	})
	return _c
}

func (_c *MockQuerier_GetServiceAccountRoles_Call) Return(_a0 []*ServiceAccountRole, _a1 error) *MockQuerier_GetServiceAccountRoles_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetServiceAccountRoles_Call) RunAndReturn(run func(context.Context, uuid.UUID) ([]*ServiceAccountRole, error)) *MockQuerier_GetServiceAccountRoles_Call {
	_c.Call.Return(run)
	return _c
}

// GetServiceAccounts provides a mock function with given fields: ctx
func (_m *MockQuerier) GetServiceAccounts(ctx context.Context) ([]*ServiceAccount, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetServiceAccounts")
	}

	var r0 []*ServiceAccount
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]*ServiceAccount, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []*ServiceAccount); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*ServiceAccount)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetServiceAccounts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccounts'
type MockQuerier_GetServiceAccounts_Call struct {
	*mock.Call
}

// GetServiceAccounts is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockQuerier_Expecter) GetServiceAccounts(ctx interface{}) *MockQuerier_GetServiceAccounts_Call {
	return &MockQuerier_GetServiceAccounts_Call{Call: _e.mock.On("GetServiceAccounts", ctx)}
}

func (_c *MockQuerier_GetServiceAccounts_Call) Run(run func(ctx context.Context)) *MockQuerier_GetServiceAccounts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockQuerier_GetServiceAccounts_Call) Return(_a0 []*ServiceAccount, _a1 error) *MockQuerier_GetServiceAccounts_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetServiceAccounts_Call) RunAndReturn(run func(context.Context) ([]*ServiceAccount, error)) *MockQuerier_GetServiceAccounts_Call {
	_c.Call.Return(run)
	return _c
}

// GetServiceAccountsByIDs provides a mock function with given fields: ctx, ids
func (_m *MockQuerier) GetServiceAccountsByIDs(ctx context.Context, ids []uuid.UUID) ([]*ServiceAccount, error) {
	ret := _m.Called(ctx, ids)

	if len(ret) == 0 {
		panic("no return value specified for GetServiceAccountsByIDs")
	}

	var r0 []*ServiceAccount
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []uuid.UUID) ([]*ServiceAccount, error)); ok {
		return rf(ctx, ids)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []uuid.UUID) []*ServiceAccount); ok {
		r0 = rf(ctx, ids)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*ServiceAccount)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []uuid.UUID) error); ok {
		r1 = rf(ctx, ids)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetServiceAccountsByIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccountsByIDs'
type MockQuerier_GetServiceAccountsByIDs_Call struct {
	*mock.Call
}

// GetServiceAccountsByIDs is a helper method to define mock.On call
//   - ctx context.Context
//   - ids []uuid.UUID
func (_e *MockQuerier_Expecter) GetServiceAccountsByIDs(ctx interface{}, ids interface{}) *MockQuerier_GetServiceAccountsByIDs_Call {
	return &MockQuerier_GetServiceAccountsByIDs_Call{Call: _e.mock.On("GetServiceAccountsByIDs", ctx, ids)}
}

func (_c *MockQuerier_GetServiceAccountsByIDs_Call) Run(run func(ctx context.Context, ids []uuid.UUID)) *MockQuerier_GetServiceAccountsByIDs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]uuid.UUID))
	})
	return _c
}

func (_c *MockQuerier_GetServiceAccountsByIDs_Call) Return(_a0 []*ServiceAccount, _a1 error) *MockQuerier_GetServiceAccountsByIDs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetServiceAccountsByIDs_Call) RunAndReturn(run func(context.Context, []uuid.UUID) ([]*ServiceAccount, error)) *MockQuerier_GetServiceAccountsByIDs_Call {
	_c.Call.Return(run)
	return _c
}

// GetSessionByID provides a mock function with given fields: ctx, id
func (_m *MockQuerier) GetSessionByID(ctx context.Context, id uuid.UUID) (*Session, error) {
	ret := _m.Called(ctx, id)

	if len(ret) == 0 {
		panic("no return value specified for GetSessionByID")
	}

	var r0 *Session
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) (*Session, error)); ok {
		return rf(ctx, id)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) *Session); ok {
		r0 = rf(ctx, id)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*Session)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uuid.UUID) error); ok {
		r1 = rf(ctx, id)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetSessionByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSessionByID'
type MockQuerier_GetSessionByID_Call struct {
	*mock.Call
}

// GetSessionByID is a helper method to define mock.On call
//   - ctx context.Context
//   - id uuid.UUID
func (_e *MockQuerier_Expecter) GetSessionByID(ctx interface{}, id interface{}) *MockQuerier_GetSessionByID_Call {
	return &MockQuerier_GetSessionByID_Call{Call: _e.mock.On("GetSessionByID", ctx, id)}
}

func (_c *MockQuerier_GetSessionByID_Call) Run(run func(ctx context.Context, id uuid.UUID)) *MockQuerier_GetSessionByID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uuid.UUID))
	})
	return _c
}

func (_c *MockQuerier_GetSessionByID_Call) Return(_a0 *Session, _a1 error) *MockQuerier_GetSessionByID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetSessionByID_Call) RunAndReturn(run func(context.Context, uuid.UUID) (*Session, error)) *MockQuerier_GetSessionByID_Call {
	_c.Call.Return(run)
	return _c
}

// GetTeamBySlug provides a mock function with given fields: ctx, argSlug
func (_m *MockQuerier) GetTeamBySlug(ctx context.Context, argSlug slug.Slug) (*Team, error) {
	ret := _m.Called(ctx, argSlug)

	if len(ret) == 0 {
		panic("no return value specified for GetTeamBySlug")
	}

	var r0 *Team
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, slug.Slug) (*Team, error)); ok {
		return rf(ctx, argSlug)
	}
	if rf, ok := ret.Get(0).(func(context.Context, slug.Slug) *Team); ok {
		r0 = rf(ctx, argSlug)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*Team)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, slug.Slug) error); ok {
		r1 = rf(ctx, argSlug)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetTeamBySlug_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamBySlug'
type MockQuerier_GetTeamBySlug_Call struct {
	*mock.Call
}

// GetTeamBySlug is a helper method to define mock.On call
//   - ctx context.Context
//   - argSlug slug.Slug
func (_e *MockQuerier_Expecter) GetTeamBySlug(ctx interface{}, argSlug interface{}) *MockQuerier_GetTeamBySlug_Call {
	return &MockQuerier_GetTeamBySlug_Call{Call: _e.mock.On("GetTeamBySlug", ctx, argSlug)}
}

func (_c *MockQuerier_GetTeamBySlug_Call) Run(run func(ctx context.Context, argSlug slug.Slug)) *MockQuerier_GetTeamBySlug_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(slug.Slug))
	})
	return _c
}

func (_c *MockQuerier_GetTeamBySlug_Call) Return(_a0 *Team, _a1 error) *MockQuerier_GetTeamBySlug_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetTeamBySlug_Call) RunAndReturn(run func(context.Context, slug.Slug) (*Team, error)) *MockQuerier_GetTeamBySlug_Call {
	_c.Call.Return(run)
	return _c
}

// GetTeamBySlugs provides a mock function with given fields: ctx, slugs
func (_m *MockQuerier) GetTeamBySlugs(ctx context.Context, slugs []slug.Slug) ([]*Team, error) {
	ret := _m.Called(ctx, slugs)

	if len(ret) == 0 {
		panic("no return value specified for GetTeamBySlugs")
	}

	var r0 []*Team
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []slug.Slug) ([]*Team, error)); ok {
		return rf(ctx, slugs)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []slug.Slug) []*Team); ok {
		r0 = rf(ctx, slugs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*Team)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []slug.Slug) error); ok {
		r1 = rf(ctx, slugs)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetTeamBySlugs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamBySlugs'
type MockQuerier_GetTeamBySlugs_Call struct {
	*mock.Call
}

// GetTeamBySlugs is a helper method to define mock.On call
//   - ctx context.Context
//   - slugs []slug.Slug
func (_e *MockQuerier_Expecter) GetTeamBySlugs(ctx interface{}, slugs interface{}) *MockQuerier_GetTeamBySlugs_Call {
	return &MockQuerier_GetTeamBySlugs_Call{Call: _e.mock.On("GetTeamBySlugs", ctx, slugs)}
}

func (_c *MockQuerier_GetTeamBySlugs_Call) Run(run func(ctx context.Context, slugs []slug.Slug)) *MockQuerier_GetTeamBySlugs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]slug.Slug))
	})
	return _c
}

func (_c *MockQuerier_GetTeamBySlugs_Call) Return(_a0 []*Team, _a1 error) *MockQuerier_GetTeamBySlugs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetTeamBySlugs_Call) RunAndReturn(run func(context.Context, []slug.Slug) ([]*Team, error)) *MockQuerier_GetTeamBySlugs_Call {
	_c.Call.Return(run)
	return _c
}

// GetTeamDeleteKey provides a mock function with given fields: ctx, key
func (_m *MockQuerier) GetTeamDeleteKey(ctx context.Context, key uuid.UUID) (*TeamDeleteKey, error) {
	ret := _m.Called(ctx, key)

	if len(ret) == 0 {
		panic("no return value specified for GetTeamDeleteKey")
	}

	var r0 *TeamDeleteKey
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) (*TeamDeleteKey, error)); ok {
		return rf(ctx, key)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) *TeamDeleteKey); ok {
		r0 = rf(ctx, key)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*TeamDeleteKey)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uuid.UUID) error); ok {
		r1 = rf(ctx, key)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetTeamDeleteKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamDeleteKey'
type MockQuerier_GetTeamDeleteKey_Call struct {
	*mock.Call
}

// GetTeamDeleteKey is a helper method to define mock.On call
//   - ctx context.Context
//   - key uuid.UUID
func (_e *MockQuerier_Expecter) GetTeamDeleteKey(ctx interface{}, key interface{}) *MockQuerier_GetTeamDeleteKey_Call {
	return &MockQuerier_GetTeamDeleteKey_Call{Call: _e.mock.On("GetTeamDeleteKey", ctx, key)}
}

func (_c *MockQuerier_GetTeamDeleteKey_Call) Run(run func(ctx context.Context, key uuid.UUID)) *MockQuerier_GetTeamDeleteKey_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uuid.UUID))
	})
	return _c
}

func (_c *MockQuerier_GetTeamDeleteKey_Call) Return(_a0 *TeamDeleteKey, _a1 error) *MockQuerier_GetTeamDeleteKey_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetTeamDeleteKey_Call) RunAndReturn(run func(context.Context, uuid.UUID) (*TeamDeleteKey, error)) *MockQuerier_GetTeamDeleteKey_Call {
	_c.Call.Return(run)
	return _c
}

// GetTeamEnvironments provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) GetTeamEnvironments(ctx context.Context, arg GetTeamEnvironmentsParams) ([]*TeamAllEnvironment, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for GetTeamEnvironments")
	}

	var r0 []*TeamAllEnvironment
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, GetTeamEnvironmentsParams) ([]*TeamAllEnvironment, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, GetTeamEnvironmentsParams) []*TeamAllEnvironment); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*TeamAllEnvironment)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, GetTeamEnvironmentsParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetTeamEnvironments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamEnvironments'
type MockQuerier_GetTeamEnvironments_Call struct {
	*mock.Call
}

// GetTeamEnvironments is a helper method to define mock.On call
//   - ctx context.Context
//   - arg GetTeamEnvironmentsParams
func (_e *MockQuerier_Expecter) GetTeamEnvironments(ctx interface{}, arg interface{}) *MockQuerier_GetTeamEnvironments_Call {
	return &MockQuerier_GetTeamEnvironments_Call{Call: _e.mock.On("GetTeamEnvironments", ctx, arg)}
}

func (_c *MockQuerier_GetTeamEnvironments_Call) Run(run func(ctx context.Context, arg GetTeamEnvironmentsParams)) *MockQuerier_GetTeamEnvironments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(GetTeamEnvironmentsParams))
	})
	return _c
}

func (_c *MockQuerier_GetTeamEnvironments_Call) Return(_a0 []*TeamAllEnvironment, _a1 error) *MockQuerier_GetTeamEnvironments_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetTeamEnvironments_Call) RunAndReturn(run func(context.Context, GetTeamEnvironmentsParams) ([]*TeamAllEnvironment, error)) *MockQuerier_GetTeamEnvironments_Call {
	_c.Call.Return(run)
	return _c
}

// GetTeamEnvironmentsBySlugsAndEnvNames provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) GetTeamEnvironmentsBySlugsAndEnvNames(ctx context.Context, arg GetTeamEnvironmentsBySlugsAndEnvNamesParams) ([]*TeamAllEnvironment, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for GetTeamEnvironmentsBySlugsAndEnvNames")
	}

	var r0 []*TeamAllEnvironment
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, GetTeamEnvironmentsBySlugsAndEnvNamesParams) ([]*TeamAllEnvironment, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, GetTeamEnvironmentsBySlugsAndEnvNamesParams) []*TeamAllEnvironment); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*TeamAllEnvironment)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, GetTeamEnvironmentsBySlugsAndEnvNamesParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamEnvironmentsBySlugsAndEnvNames'
type MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call struct {
	*mock.Call
}

// GetTeamEnvironmentsBySlugsAndEnvNames is a helper method to define mock.On call
//   - ctx context.Context
//   - arg GetTeamEnvironmentsBySlugsAndEnvNamesParams
func (_e *MockQuerier_Expecter) GetTeamEnvironmentsBySlugsAndEnvNames(ctx interface{}, arg interface{}) *MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call {
	return &MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call{Call: _e.mock.On("GetTeamEnvironmentsBySlugsAndEnvNames", ctx, arg)}
}

func (_c *MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call) Run(run func(ctx context.Context, arg GetTeamEnvironmentsBySlugsAndEnvNamesParams)) *MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(GetTeamEnvironmentsBySlugsAndEnvNamesParams))
	})
	return _c
}

func (_c *MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call) Return(_a0 []*TeamAllEnvironment, _a1 error) *MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call) RunAndReturn(run func(context.Context, GetTeamEnvironmentsBySlugsAndEnvNamesParams) ([]*TeamAllEnvironment, error)) *MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call {
	_c.Call.Return(run)
	return _c
}

// GetTeamEnvironmentsCount provides a mock function with given fields: ctx, teamSlug
func (_m *MockQuerier) GetTeamEnvironmentsCount(ctx context.Context, teamSlug slug.Slug) (int64, error) {
	ret := _m.Called(ctx, teamSlug)

	if len(ret) == 0 {
		panic("no return value specified for GetTeamEnvironmentsCount")
	}

	var r0 int64
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, slug.Slug) (int64, error)); ok {
		return rf(ctx, teamSlug)
	}
	if rf, ok := ret.Get(0).(func(context.Context, slug.Slug) int64); ok {
		r0 = rf(ctx, teamSlug)
	} else {
		r0 = ret.Get(0).(int64)
	}

	if rf, ok := ret.Get(1).(func(context.Context, slug.Slug) error); ok {
		r1 = rf(ctx, teamSlug)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetTeamEnvironmentsCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamEnvironmentsCount'
type MockQuerier_GetTeamEnvironmentsCount_Call struct {
	*mock.Call
}

// GetTeamEnvironmentsCount is a helper method to define mock.On call
//   - ctx context.Context
//   - teamSlug slug.Slug
func (_e *MockQuerier_Expecter) GetTeamEnvironmentsCount(ctx interface{}, teamSlug interface{}) *MockQuerier_GetTeamEnvironmentsCount_Call {
	return &MockQuerier_GetTeamEnvironmentsCount_Call{Call: _e.mock.On("GetTeamEnvironmentsCount", ctx, teamSlug)}
}

func (_c *MockQuerier_GetTeamEnvironmentsCount_Call) Run(run func(ctx context.Context, teamSlug slug.Slug)) *MockQuerier_GetTeamEnvironmentsCount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(slug.Slug))
	})
	return _c
}

func (_c *MockQuerier_GetTeamEnvironmentsCount_Call) Return(_a0 int64, _a1 error) *MockQuerier_GetTeamEnvironmentsCount_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetTeamEnvironmentsCount_Call) RunAndReturn(run func(context.Context, slug.Slug) (int64, error)) *MockQuerier_GetTeamEnvironmentsCount_Call {
	_c.Call.Return(run)
	return _c
}

// GetTeamMember provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) GetTeamMember(ctx context.Context, arg GetTeamMemberParams) (*User, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for GetTeamMember")
	}

	var r0 *User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, GetTeamMemberParams) (*User, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, GetTeamMemberParams) *User); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*User)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, GetTeamMemberParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetTeamMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamMember'
type MockQuerier_GetTeamMember_Call struct {
	*mock.Call
}

// GetTeamMember is a helper method to define mock.On call
//   - ctx context.Context
//   - arg GetTeamMemberParams
func (_e *MockQuerier_Expecter) GetTeamMember(ctx interface{}, arg interface{}) *MockQuerier_GetTeamMember_Call {
	return &MockQuerier_GetTeamMember_Call{Call: _e.mock.On("GetTeamMember", ctx, arg)}
}

func (_c *MockQuerier_GetTeamMember_Call) Run(run func(ctx context.Context, arg GetTeamMemberParams)) *MockQuerier_GetTeamMember_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(GetTeamMemberParams))
	})
	return _c
}

func (_c *MockQuerier_GetTeamMember_Call) Return(_a0 *User, _a1 error) *MockQuerier_GetTeamMember_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetTeamMember_Call) RunAndReturn(run func(context.Context, GetTeamMemberParams) (*User, error)) *MockQuerier_GetTeamMember_Call {
	_c.Call.Return(run)
	return _c
}

// GetTeamMemberOptOuts provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) GetTeamMemberOptOuts(ctx context.Context, arg GetTeamMemberOptOutsParams) ([]*GetTeamMemberOptOutsRow, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for GetTeamMemberOptOuts")
	}

	var r0 []*GetTeamMemberOptOutsRow
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, GetTeamMemberOptOutsParams) ([]*GetTeamMemberOptOutsRow, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, GetTeamMemberOptOutsParams) []*GetTeamMemberOptOutsRow); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*GetTeamMemberOptOutsRow)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, GetTeamMemberOptOutsParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetTeamMemberOptOuts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamMemberOptOuts'
type MockQuerier_GetTeamMemberOptOuts_Call struct {
	*mock.Call
}

// GetTeamMemberOptOuts is a helper method to define mock.On call
//   - ctx context.Context
//   - arg GetTeamMemberOptOutsParams
func (_e *MockQuerier_Expecter) GetTeamMemberOptOuts(ctx interface{}, arg interface{}) *MockQuerier_GetTeamMemberOptOuts_Call {
	return &MockQuerier_GetTeamMemberOptOuts_Call{Call: _e.mock.On("GetTeamMemberOptOuts", ctx, arg)}
}

func (_c *MockQuerier_GetTeamMemberOptOuts_Call) Run(run func(ctx context.Context, arg GetTeamMemberOptOutsParams)) *MockQuerier_GetTeamMemberOptOuts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(GetTeamMemberOptOutsParams))
	})
	return _c
}

func (_c *MockQuerier_GetTeamMemberOptOuts_Call) Return(_a0 []*GetTeamMemberOptOutsRow, _a1 error) *MockQuerier_GetTeamMemberOptOuts_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetTeamMemberOptOuts_Call) RunAndReturn(run func(context.Context, GetTeamMemberOptOutsParams) ([]*GetTeamMemberOptOutsRow, error)) *MockQuerier_GetTeamMemberOptOuts_Call {
	_c.Call.Return(run)
	return _c
}

// GetTeamMembers provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) GetTeamMembers(ctx context.Context, arg GetTeamMembersParams) ([]*User, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for GetTeamMembers")
	}

	var r0 []*User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, GetTeamMembersParams) ([]*User, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, GetTeamMembersParams) []*User); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*User)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, GetTeamMembersParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetTeamMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamMembers'
type MockQuerier_GetTeamMembers_Call struct {
	*mock.Call
}

// GetTeamMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - arg GetTeamMembersParams
func (_e *MockQuerier_Expecter) GetTeamMembers(ctx interface{}, arg interface{}) *MockQuerier_GetTeamMembers_Call {
	return &MockQuerier_GetTeamMembers_Call{Call: _e.mock.On("GetTeamMembers", ctx, arg)}
}

func (_c *MockQuerier_GetTeamMembers_Call) Run(run func(ctx context.Context, arg GetTeamMembersParams)) *MockQuerier_GetTeamMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(GetTeamMembersParams))
	})
	return _c
}

func (_c *MockQuerier_GetTeamMembers_Call) Return(_a0 []*User, _a1 error) *MockQuerier_GetTeamMembers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetTeamMembers_Call) RunAndReturn(run func(context.Context, GetTeamMembersParams) ([]*User, error)) *MockQuerier_GetTeamMembers_Call {
	_c.Call.Return(run)
	return _c
}

// GetTeamMembersCount provides a mock function with given fields: ctx, teamSlug
func (_m *MockQuerier) GetTeamMembersCount(ctx context.Context, teamSlug *slug.Slug) (int64, error) {
	ret := _m.Called(ctx, teamSlug)

	if len(ret) == 0 {
		panic("no return value specified for GetTeamMembersCount")
	}

	var r0 int64
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *slug.Slug) (int64, error)); ok {
		return rf(ctx, teamSlug)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *slug.Slug) int64); ok {
		r0 = rf(ctx, teamSlug)
	} else {
		r0 = ret.Get(0).(int64)
	}

	if rf, ok := ret.Get(1).(func(context.Context, *slug.Slug) error); ok {
		r1 = rf(ctx, teamSlug)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetTeamMembersCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamMembersCount'
type MockQuerier_GetTeamMembersCount_Call struct {
	*mock.Call
}

// GetTeamMembersCount is a helper method to define mock.On call
//   - ctx context.Context
//   - teamSlug *slug.Slug
func (_e *MockQuerier_Expecter) GetTeamMembersCount(ctx interface{}, teamSlug interface{}) *MockQuerier_GetTeamMembersCount_Call {
	return &MockQuerier_GetTeamMembersCount_Call{Call: _e.mock.On("GetTeamMembersCount", ctx, teamSlug)}
}

func (_c *MockQuerier_GetTeamMembersCount_Call) Run(run func(ctx context.Context, teamSlug *slug.Slug)) *MockQuerier_GetTeamMembersCount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*slug.Slug))
	})
	return _c
}

func (_c *MockQuerier_GetTeamMembersCount_Call) Return(_a0 int64, _a1 error) *MockQuerier_GetTeamMembersCount_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetTeamMembersCount_Call) RunAndReturn(run func(context.Context, *slug.Slug) (int64, error)) *MockQuerier_GetTeamMembersCount_Call {
	_c.Call.Return(run)
	return _c
}

// GetTeamMembersForReconciler provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) GetTeamMembersForReconciler(ctx context.Context, arg GetTeamMembersForReconcilerParams) ([]*User, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for GetTeamMembersForReconciler")
	}

	var r0 []*User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, GetTeamMembersForReconcilerParams) ([]*User, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, GetTeamMembersForReconcilerParams) []*User); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*User)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, GetTeamMembersForReconcilerParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetTeamMembersForReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamMembersForReconciler'
type MockQuerier_GetTeamMembersForReconciler_Call struct {
	*mock.Call
}

// GetTeamMembersForReconciler is a helper method to define mock.On call
//   - ctx context.Context
//   - arg GetTeamMembersForReconcilerParams
func (_e *MockQuerier_Expecter) GetTeamMembersForReconciler(ctx interface{}, arg interface{}) *MockQuerier_GetTeamMembersForReconciler_Call {
	return &MockQuerier_GetTeamMembersForReconciler_Call{Call: _e.mock.On("GetTeamMembersForReconciler", ctx, arg)}
}

func (_c *MockQuerier_GetTeamMembersForReconciler_Call) Run(run func(ctx context.Context, arg GetTeamMembersForReconcilerParams)) *MockQuerier_GetTeamMembersForReconciler_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(GetTeamMembersForReconcilerParams))
	})
	return _c
}

func (_c *MockQuerier_GetTeamMembersForReconciler_Call) Return(_a0 []*User, _a1 error) *MockQuerier_GetTeamMembersForReconciler_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetTeamMembersForReconciler_Call) RunAndReturn(run func(context.Context, GetTeamMembersForReconcilerParams) ([]*User, error)) *MockQuerier_GetTeamMembersForReconciler_Call {
	_c.Call.Return(run)
	return _c
}

// GetTeamReconcilerErrors provides a mock function with given fields: ctx, teamSlug
func (_m *MockQuerier) GetTeamReconcilerErrors(ctx context.Context, teamSlug slug.Slug) ([]*ReconcilerError, error) {
	ret := _m.Called(ctx, teamSlug)

	if len(ret) == 0 {
		panic("no return value specified for GetTeamReconcilerErrors")
	}

	var r0 []*ReconcilerError
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, slug.Slug) ([]*ReconcilerError, error)); ok {
		return rf(ctx, teamSlug)
	}
	if rf, ok := ret.Get(0).(func(context.Context, slug.Slug) []*ReconcilerError); ok {
		r0 = rf(ctx, teamSlug)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*ReconcilerError)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, slug.Slug) error); ok {
		r1 = rf(ctx, teamSlug)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetTeamReconcilerErrors_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamReconcilerErrors'
type MockQuerier_GetTeamReconcilerErrors_Call struct {
	*mock.Call
}

// GetTeamReconcilerErrors is a helper method to define mock.On call
//   - ctx context.Context
//   - teamSlug slug.Slug
func (_e *MockQuerier_Expecter) GetTeamReconcilerErrors(ctx interface{}, teamSlug interface{}) *MockQuerier_GetTeamReconcilerErrors_Call {
	return &MockQuerier_GetTeamReconcilerErrors_Call{Call: _e.mock.On("GetTeamReconcilerErrors", ctx, teamSlug)}
}

func (_c *MockQuerier_GetTeamReconcilerErrors_Call) Run(run func(ctx context.Context, teamSlug slug.Slug)) *MockQuerier_GetTeamReconcilerErrors_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(slug.Slug))
	})
	return _c
}

func (_c *MockQuerier_GetTeamReconcilerErrors_Call) Return(_a0 []*ReconcilerError, _a1 error) *MockQuerier_GetTeamReconcilerErrors_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetTeamReconcilerErrors_Call) RunAndReturn(run func(context.Context, slug.Slug) ([]*ReconcilerError, error)) *MockQuerier_GetTeamReconcilerErrors_Call {
	_c.Call.Return(run)
	return _c
}

// GetTeams provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) GetTeams(ctx context.Context, arg GetTeamsParams) ([]*Team, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for GetTeams")
	}

	var r0 []*Team
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, GetTeamsParams) ([]*Team, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, GetTeamsParams) []*Team); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*Team)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, GetTeamsParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetTeams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeams'
type MockQuerier_GetTeams_Call struct {
	*mock.Call
}

// GetTeams is a helper method to define mock.On call
//   - ctx context.Context
//   - arg GetTeamsParams
func (_e *MockQuerier_Expecter) GetTeams(ctx interface{}, arg interface{}) *MockQuerier_GetTeams_Call {
	return &MockQuerier_GetTeams_Call{Call: _e.mock.On("GetTeams", ctx, arg)}
}

func (_c *MockQuerier_GetTeams_Call) Run(run func(ctx context.Context, arg GetTeamsParams)) *MockQuerier_GetTeams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(GetTeamsParams))
	})
	return _c
}

func (_c *MockQuerier_GetTeams_Call) Return(_a0 []*Team, _a1 error) *MockQuerier_GetTeams_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetTeams_Call) RunAndReturn(run func(context.Context, GetTeamsParams) ([]*Team, error)) *MockQuerier_GetTeams_Call {
	_c.Call.Return(run)
	return _c
}

// GetTeamsCount provides a mock function with given fields: ctx
func (_m *MockQuerier) GetTeamsCount(ctx context.Context) (int64, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetTeamsCount")
	}

	var r0 int64
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (int64, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) int64); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Get(0).(int64)
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetTeamsCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamsCount'
type MockQuerier_GetTeamsCount_Call struct {
	*mock.Call
}

// GetTeamsCount is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockQuerier_Expecter) GetTeamsCount(ctx interface{}) *MockQuerier_GetTeamsCount_Call {
	return &MockQuerier_GetTeamsCount_Call{Call: _e.mock.On("GetTeamsCount", ctx)}
}

func (_c *MockQuerier_GetTeamsCount_Call) Run(run func(ctx context.Context)) *MockQuerier_GetTeamsCount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockQuerier_GetTeamsCount_Call) Return(_a0 int64, _a1 error) *MockQuerier_GetTeamsCount_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetTeamsCount_Call) RunAndReturn(run func(context.Context) (int64, error)) *MockQuerier_GetTeamsCount_Call {
	_c.Call.Return(run)
	return _c
}

// GetUserByEmail provides a mock function with given fields: ctx, email
func (_m *MockQuerier) GetUserByEmail(ctx context.Context, email string) (*User, error) {
	ret := _m.Called(ctx, email)

	if len(ret) == 0 {
		panic("no return value specified for GetUserByEmail")
	}

	var r0 *User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*User, error)); ok {
		return rf(ctx, email)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *User); ok {
		r0 = rf(ctx, email)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*User)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, email)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetUserByEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserByEmail'
type MockQuerier_GetUserByEmail_Call struct {
	*mock.Call
}

// GetUserByEmail is a helper method to define mock.On call
//   - ctx context.Context
//   - email string
func (_e *MockQuerier_Expecter) GetUserByEmail(ctx interface{}, email interface{}) *MockQuerier_GetUserByEmail_Call {
	return &MockQuerier_GetUserByEmail_Call{Call: _e.mock.On("GetUserByEmail", ctx, email)}
}

func (_c *MockQuerier_GetUserByEmail_Call) Run(run func(ctx context.Context, email string)) *MockQuerier_GetUserByEmail_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockQuerier_GetUserByEmail_Call) Return(_a0 *User, _a1 error) *MockQuerier_GetUserByEmail_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetUserByEmail_Call) RunAndReturn(run func(context.Context, string) (*User, error)) *MockQuerier_GetUserByEmail_Call {
	_c.Call.Return(run)
	return _c
}

// GetUserByExternalID provides a mock function with given fields: ctx, externalID
func (_m *MockQuerier) GetUserByExternalID(ctx context.Context, externalID string) (*User, error) {
	ret := _m.Called(ctx, externalID)

	if len(ret) == 0 {
		panic("no return value specified for GetUserByExternalID")
	}

	var r0 *User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*User, error)); ok {
		return rf(ctx, externalID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *User); ok {
		r0 = rf(ctx, externalID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*User)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, externalID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetUserByExternalID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserByExternalID'
type MockQuerier_GetUserByExternalID_Call struct {
	*mock.Call
}

// GetUserByExternalID is a helper method to define mock.On call
//   - ctx context.Context
//   - externalID string
func (_e *MockQuerier_Expecter) GetUserByExternalID(ctx interface{}, externalID interface{}) *MockQuerier_GetUserByExternalID_Call {
	return &MockQuerier_GetUserByExternalID_Call{Call: _e.mock.On("GetUserByExternalID", ctx, externalID)}
}

func (_c *MockQuerier_GetUserByExternalID_Call) Run(run func(ctx context.Context, externalID string)) *MockQuerier_GetUserByExternalID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockQuerier_GetUserByExternalID_Call) Return(_a0 *User, _a1 error) *MockQuerier_GetUserByExternalID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetUserByExternalID_Call) RunAndReturn(run func(context.Context, string) (*User, error)) *MockQuerier_GetUserByExternalID_Call {
	_c.Call.Return(run)
	return _c
}

// GetUserByID provides a mock function with given fields: ctx, id
func (_m *MockQuerier) GetUserByID(ctx context.Context, id uuid.UUID) (*User, error) {
	ret := _m.Called(ctx, id)

	if len(ret) == 0 {
		panic("no return value specified for GetUserByID")
	}

	var r0 *User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) (*User, error)); ok {
		return rf(ctx, id)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) *User); ok {
		r0 = rf(ctx, id)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*User)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uuid.UUID) error); ok {
		r1 = rf(ctx, id)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetUserByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserByID'
type MockQuerier_GetUserByID_Call struct {
	*mock.Call
}

// GetUserByID is a helper method to define mock.On call
//   - ctx context.Context
//   - id uuid.UUID
func (_e *MockQuerier_Expecter) GetUserByID(ctx interface{}, id interface{}) *MockQuerier_GetUserByID_Call {
	return &MockQuerier_GetUserByID_Call{Call: _e.mock.On("GetUserByID", ctx, id)}
}

func (_c *MockQuerier_GetUserByID_Call) Run(run func(ctx context.Context, id uuid.UUID)) *MockQuerier_GetUserByID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uuid.UUID))
	})
	return _c
}

func (_c *MockQuerier_GetUserByID_Call) Return(_a0 *User, _a1 error) *MockQuerier_GetUserByID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetUserByID_Call) RunAndReturn(run func(context.Context, uuid.UUID) (*User, error)) *MockQuerier_GetUserByID_Call {
	_c.Call.Return(run)
	return _c
}

// GetUserRoles provides a mock function with given fields: ctx, userID
func (_m *MockQuerier) GetUserRoles(ctx context.Context, userID uuid.UUID) ([]*UserRole, error) {
	ret := _m.Called(ctx, userID)

	if len(ret) == 0 {
		panic("no return value specified for GetUserRoles")
	}

	var r0 []*UserRole
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) ([]*UserRole, error)); ok {
		return rf(ctx, userID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) []*UserRole); ok {
		r0 = rf(ctx, userID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*UserRole)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uuid.UUID) error); ok {
		r1 = rf(ctx, userID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetUserRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserRoles'
type MockQuerier_GetUserRoles_Call struct {
	*mock.Call
}

// GetUserRoles is a helper method to define mock.On call
//   - ctx context.Context
//   - userID uuid.UUID
func (_e *MockQuerier_Expecter) GetUserRoles(ctx interface{}, userID interface{}) *MockQuerier_GetUserRoles_Call {
	return &MockQuerier_GetUserRoles_Call{Call: _e.mock.On("GetUserRoles", ctx, userID)}
}

func (_c *MockQuerier_GetUserRoles_Call) Run(run func(ctx context.Context, userID uuid.UUID)) *MockQuerier_GetUserRoles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uuid.UUID))
	})
	return _c
}

func (_c *MockQuerier_GetUserRoles_Call) Return(_a0 []*UserRole, _a1 error) *MockQuerier_GetUserRoles_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetUserRoles_Call) RunAndReturn(run func(context.Context, uuid.UUID) ([]*UserRole, error)) *MockQuerier_GetUserRoles_Call {
	_c.Call.Return(run)
	return _c
}

// GetUserRolesForUsers provides a mock function with given fields: ctx, userIds
func (_m *MockQuerier) GetUserRolesForUsers(ctx context.Context, userIds []uuid.UUID) ([]*GetUserRolesForUsersRow, error) {
	ret := _m.Called(ctx, userIds)

	if len(ret) == 0 {
		panic("no return value specified for GetUserRolesForUsers")
	}

	var r0 []*GetUserRolesForUsersRow
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []uuid.UUID) ([]*GetUserRolesForUsersRow, error)); ok {
		return rf(ctx, userIds)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []uuid.UUID) []*GetUserRolesForUsersRow); ok {
		r0 = rf(ctx, userIds)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*GetUserRolesForUsersRow)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []uuid.UUID) error); ok {
		r1 = rf(ctx, userIds)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetUserRolesForUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserRolesForUsers'
type MockQuerier_GetUserRolesForUsers_Call struct {
	*mock.Call
}

// GetUserRolesForUsers is a helper method to define mock.On call
//   - ctx context.Context
//   - userIds []uuid.UUID
func (_e *MockQuerier_Expecter) GetUserRolesForUsers(ctx interface{}, userIds interface{}) *MockQuerier_GetUserRolesForUsers_Call {
	return &MockQuerier_GetUserRolesForUsers_Call{Call: _e.mock.On("GetUserRolesForUsers", ctx, userIds)}
}

func (_c *MockQuerier_GetUserRolesForUsers_Call) Run(run func(ctx context.Context, userIds []uuid.UUID)) *MockQuerier_GetUserRolesForUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]uuid.UUID))
	})
	return _c
}

func (_c *MockQuerier_GetUserRolesForUsers_Call) Return(_a0 []*GetUserRolesForUsersRow, _a1 error) *MockQuerier_GetUserRolesForUsers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetUserRolesForUsers_Call) RunAndReturn(run func(context.Context, []uuid.UUID) ([]*GetUserRolesForUsersRow, error)) *MockQuerier_GetUserRolesForUsers_Call {
	_c.Call.Return(run)
	return _c
}

// GetUserTeams provides a mock function with given fields: ctx, userID
func (_m *MockQuerier) GetUserTeams(ctx context.Context, userID uuid.UUID) ([]*GetUserTeamsRow, error) {
	ret := _m.Called(ctx, userID)

	if len(ret) == 0 {
		panic("no return value specified for GetUserTeams")
	}

	var r0 []*GetUserTeamsRow
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) ([]*GetUserTeamsRow, error)); ok {
		return rf(ctx, userID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) []*GetUserTeamsRow); ok {
		r0 = rf(ctx, userID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*GetUserTeamsRow)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uuid.UUID) error); ok {
		r1 = rf(ctx, userID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetUserTeams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserTeams'
type MockQuerier_GetUserTeams_Call struct {
	*mock.Call
}

// GetUserTeams is a helper method to define mock.On call
//   - ctx context.Context
//   - userID uuid.UUID
func (_e *MockQuerier_Expecter) GetUserTeams(ctx interface{}, userID interface{}) *MockQuerier_GetUserTeams_Call {
	return &MockQuerier_GetUserTeams_Call{Call: _e.mock.On("GetUserTeams", ctx, userID)}
}

func (_c *MockQuerier_GetUserTeams_Call) Run(run func(ctx context.Context, userID uuid.UUID)) *MockQuerier_GetUserTeams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uuid.UUID))
	})
	return _c
}

func (_c *MockQuerier_GetUserTeams_Call) Return(_a0 []*GetUserTeamsRow, _a1 error) *MockQuerier_GetUserTeams_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetUserTeams_Call) RunAndReturn(run func(context.Context, uuid.UUID) ([]*GetUserTeamsRow, error)) *MockQuerier_GetUserTeams_Call {
	_c.Call.Return(run)
	return _c
}

// GetUserTeamsCount provides a mock function with given fields: ctx, userID
func (_m *MockQuerier) GetUserTeamsCount(ctx context.Context, userID uuid.UUID) (int64, error) {
	ret := _m.Called(ctx, userID)

	if len(ret) == 0 {
		panic("no return value specified for GetUserTeamsCount")
	}

	var r0 int64
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) (int64, error)); ok {
		return rf(ctx, userID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) int64); ok {
		r0 = rf(ctx, userID)
	} else {
		r0 = ret.Get(0).(int64)
	}

	if rf, ok := ret.Get(1).(func(context.Context, uuid.UUID) error); ok {
		r1 = rf(ctx, userID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetUserTeamsCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserTeamsCount'
type MockQuerier_GetUserTeamsCount_Call struct {
	*mock.Call
}

// GetUserTeamsCount is a helper method to define mock.On call
//   - ctx context.Context
//   - userID uuid.UUID
func (_e *MockQuerier_Expecter) GetUserTeamsCount(ctx interface{}, userID interface{}) *MockQuerier_GetUserTeamsCount_Call {
	return &MockQuerier_GetUserTeamsCount_Call{Call: _e.mock.On("GetUserTeamsCount", ctx, userID)}
}

func (_c *MockQuerier_GetUserTeamsCount_Call) Run(run func(ctx context.Context, userID uuid.UUID)) *MockQuerier_GetUserTeamsCount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uuid.UUID))
	})
	return _c
}

func (_c *MockQuerier_GetUserTeamsCount_Call) Return(_a0 int64, _a1 error) *MockQuerier_GetUserTeamsCount_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetUserTeamsCount_Call) RunAndReturn(run func(context.Context, uuid.UUID) (int64, error)) *MockQuerier_GetUserTeamsCount_Call {
	_c.Call.Return(run)
	return _c
}

// GetUserTeamsPaginated provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) GetUserTeamsPaginated(ctx context.Context, arg GetUserTeamsPaginatedParams) ([]*GetUserTeamsPaginatedRow, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for GetUserTeamsPaginated")
	}

	var r0 []*GetUserTeamsPaginatedRow
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, GetUserTeamsPaginatedParams) ([]*GetUserTeamsPaginatedRow, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, GetUserTeamsPaginatedParams) []*GetUserTeamsPaginatedRow); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*GetUserTeamsPaginatedRow)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, GetUserTeamsPaginatedParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetUserTeamsPaginated_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserTeamsPaginated'
type MockQuerier_GetUserTeamsPaginated_Call struct {
	*mock.Call
}

// GetUserTeamsPaginated is a helper method to define mock.On call
//   - ctx context.Context
//   - arg GetUserTeamsPaginatedParams
func (_e *MockQuerier_Expecter) GetUserTeamsPaginated(ctx interface{}, arg interface{}) *MockQuerier_GetUserTeamsPaginated_Call {
	return &MockQuerier_GetUserTeamsPaginated_Call{Call: _e.mock.On("GetUserTeamsPaginated", ctx, arg)}
}

func (_c *MockQuerier_GetUserTeamsPaginated_Call) Run(run func(ctx context.Context, arg GetUserTeamsPaginatedParams)) *MockQuerier_GetUserTeamsPaginated_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(GetUserTeamsPaginatedParams))
	})
	return _c
}

func (_c *MockQuerier_GetUserTeamsPaginated_Call) Return(_a0 []*GetUserTeamsPaginatedRow, _a1 error) *MockQuerier_GetUserTeamsPaginated_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetUserTeamsPaginated_Call) RunAndReturn(run func(context.Context, GetUserTeamsPaginatedParams) ([]*GetUserTeamsPaginatedRow, error)) *MockQuerier_GetUserTeamsPaginated_Call {
	_c.Call.Return(run)
	return _c
}

// GetUsers provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) GetUsers(ctx context.Context, arg GetUsersParams) ([]*User, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for GetUsers")
	}

	var r0 []*User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, GetUsersParams) ([]*User, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, GetUsersParams) []*User); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*User)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, GetUsersParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUsers'
type MockQuerier_GetUsers_Call struct {
	*mock.Call
}

// GetUsers is a helper method to define mock.On call
//   - ctx context.Context
//   - arg GetUsersParams
func (_e *MockQuerier_Expecter) GetUsers(ctx interface{}, arg interface{}) *MockQuerier_GetUsers_Call {
	return &MockQuerier_GetUsers_Call{Call: _e.mock.On("GetUsers", ctx, arg)}
}

func (_c *MockQuerier_GetUsers_Call) Run(run func(ctx context.Context, arg GetUsersParams)) *MockQuerier_GetUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(GetUsersParams))
	})
	return _c
}

func (_c *MockQuerier_GetUsers_Call) Return(_a0 []*User, _a1 error) *MockQuerier_GetUsers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetUsers_Call) RunAndReturn(run func(context.Context, GetUsersParams) ([]*User, error)) *MockQuerier_GetUsers_Call {
	_c.Call.Return(run)
	return _c
}

// GetUsersByIDs provides a mock function with given fields: ctx, ids
func (_m *MockQuerier) GetUsersByIDs(ctx context.Context, ids []uuid.UUID) ([]*User, error) {
	ret := _m.Called(ctx, ids)

	if len(ret) == 0 {
		panic("no return value specified for GetUsersByIDs")
	}

	var r0 []*User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []uuid.UUID) ([]*User, error)); ok {
		return rf(ctx, ids)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []uuid.UUID) []*User); ok {
		r0 = rf(ctx, ids)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*User)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []uuid.UUID) error); ok {
		r1 = rf(ctx, ids)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetUsersByIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUsersByIDs'
type MockQuerier_GetUsersByIDs_Call struct {
	*mock.Call
}

// GetUsersByIDs is a helper method to define mock.On call
//   - ctx context.Context
//   - ids []uuid.UUID
func (_e *MockQuerier_Expecter) GetUsersByIDs(ctx interface{}, ids interface{}) *MockQuerier_GetUsersByIDs_Call {
	return &MockQuerier_GetUsersByIDs_Call{Call: _e.mock.On("GetUsersByIDs", ctx, ids)}
}

func (_c *MockQuerier_GetUsersByIDs_Call) Run(run func(ctx context.Context, ids []uuid.UUID)) *MockQuerier_GetUsersByIDs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]uuid.UUID))
	})
	return _c
}

func (_c *MockQuerier_GetUsersByIDs_Call) Return(_a0 []*User, _a1 error) *MockQuerier_GetUsersByIDs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetUsersByIDs_Call) RunAndReturn(run func(context.Context, []uuid.UUID) ([]*User, error)) *MockQuerier_GetUsersByIDs_Call {
	_c.Call.Return(run)
	return _c
}

// GetUsersCount provides a mock function with given fields: ctx
func (_m *MockQuerier) GetUsersCount(ctx context.Context) (int64, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetUsersCount")
	}

	var r0 int64
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (int64, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) int64); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Get(0).(int64)
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetUsersCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUsersCount'
type MockQuerier_GetUsersCount_Call struct {
	*mock.Call
}

// GetUsersCount is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockQuerier_Expecter) GetUsersCount(ctx interface{}) *MockQuerier_GetUsersCount_Call {
	return &MockQuerier_GetUsersCount_Call{Call: _e.mock.On("GetUsersCount", ctx)}
}

func (_c *MockQuerier_GetUsersCount_Call) Run(run func(ctx context.Context)) *MockQuerier_GetUsersCount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockQuerier_GetUsersCount_Call) Return(_a0 int64, _a1 error) *MockQuerier_GetUsersCount_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetUsersCount_Call) RunAndReturn(run func(context.Context) (int64, error)) *MockQuerier_GetUsersCount_Call {
	_c.Call.Return(run)
	return _c
}

// GetUsersWithGloballyAssignedRole provides a mock function with given fields: ctx, roleName
func (_m *MockQuerier) GetUsersWithGloballyAssignedRole(ctx context.Context, roleName RoleName) ([]*User, error) {
	ret := _m.Called(ctx, roleName)

	if len(ret) == 0 {
		panic("no return value specified for GetUsersWithGloballyAssignedRole")
	}

	var r0 []*User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, RoleName) ([]*User, error)); ok {
		return rf(ctx, roleName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, RoleName) []*User); ok {
		r0 = rf(ctx, roleName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*User)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, RoleName) error); ok {
		r1 = rf(ctx, roleName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_GetUsersWithGloballyAssignedRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUsersWithGloballyAssignedRole'
type MockQuerier_GetUsersWithGloballyAssignedRole_Call struct {
	*mock.Call
}

// GetUsersWithGloballyAssignedRole is a helper method to define mock.On call
//   - ctx context.Context
//   - roleName RoleName
func (_e *MockQuerier_Expecter) GetUsersWithGloballyAssignedRole(ctx interface{}, roleName interface{}) *MockQuerier_GetUsersWithGloballyAssignedRole_Call {
	return &MockQuerier_GetUsersWithGloballyAssignedRole_Call{Call: _e.mock.On("GetUsersWithGloballyAssignedRole", ctx, roleName)}
}

func (_c *MockQuerier_GetUsersWithGloballyAssignedRole_Call) Run(run func(ctx context.Context, roleName RoleName)) *MockQuerier_GetUsersWithGloballyAssignedRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(RoleName))
	})
	return _c
}

func (_c *MockQuerier_GetUsersWithGloballyAssignedRole_Call) Return(_a0 []*User, _a1 error) *MockQuerier_GetUsersWithGloballyAssignedRole_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_GetUsersWithGloballyAssignedRole_Call) RunAndReturn(run func(context.Context, RoleName) ([]*User, error)) *MockQuerier_GetUsersWithGloballyAssignedRole_Call {
	_c.Call.Return(run)
	return _c
}

// InsertEnvironment provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) InsertEnvironment(ctx context.Context, arg InsertEnvironmentParams) error {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for InsertEnvironment")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, InsertEnvironmentParams) error); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_InsertEnvironment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InsertEnvironment'
type MockQuerier_InsertEnvironment_Call struct {
	*mock.Call
}

// InsertEnvironment is a helper method to define mock.On call
//   - ctx context.Context
//   - arg InsertEnvironmentParams
func (_e *MockQuerier_Expecter) InsertEnvironment(ctx interface{}, arg interface{}) *MockQuerier_InsertEnvironment_Call {
	return &MockQuerier_InsertEnvironment_Call{Call: _e.mock.On("InsertEnvironment", ctx, arg)}
}

func (_c *MockQuerier_InsertEnvironment_Call) Run(run func(ctx context.Context, arg InsertEnvironmentParams)) *MockQuerier_InsertEnvironment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(InsertEnvironmentParams))
	})
	return _c
}

func (_c *MockQuerier_InsertEnvironment_Call) Return(_a0 error) *MockQuerier_InsertEnvironment_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_InsertEnvironment_Call) RunAndReturn(run func(context.Context, InsertEnvironmentParams) error) *MockQuerier_InsertEnvironment_Call {
	_c.Call.Return(run)
	return _c
}

// LastCostDate provides a mock function with given fields: ctx
func (_m *MockQuerier) LastCostDate(ctx context.Context) (pgtype.Date, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for LastCostDate")
	}

	var r0 pgtype.Date
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (pgtype.Date, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) pgtype.Date); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Get(0).(pgtype.Date)
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_LastCostDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LastCostDate'
type MockQuerier_LastCostDate_Call struct {
	*mock.Call
}

// LastCostDate is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockQuerier_Expecter) LastCostDate(ctx interface{}) *MockQuerier_LastCostDate_Call {
	return &MockQuerier_LastCostDate_Call{Call: _e.mock.On("LastCostDate", ctx)}
}

func (_c *MockQuerier_LastCostDate_Call) Run(run func(ctx context.Context)) *MockQuerier_LastCostDate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockQuerier_LastCostDate_Call) Return(_a0 pgtype.Date, _a1 error) *MockQuerier_LastCostDate_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_LastCostDate_Call) RunAndReturn(run func(context.Context) (pgtype.Date, error)) *MockQuerier_LastCostDate_Call {
	_c.Call.Return(run)
	return _c
}

// ListRepositoriesByAuthorization provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) ListRepositoriesByAuthorization(ctx context.Context, arg ListRepositoriesByAuthorizationParams) ([]string, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for ListRepositoriesByAuthorization")
	}

	var r0 []string
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ListRepositoriesByAuthorizationParams) ([]string, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ListRepositoriesByAuthorizationParams) []string); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ListRepositoriesByAuthorizationParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_ListRepositoriesByAuthorization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRepositoriesByAuthorization'
type MockQuerier_ListRepositoriesByAuthorization_Call struct {
	*mock.Call
}

// ListRepositoriesByAuthorization is a helper method to define mock.On call
//   - ctx context.Context
//   - arg ListRepositoriesByAuthorizationParams
func (_e *MockQuerier_Expecter) ListRepositoriesByAuthorization(ctx interface{}, arg interface{}) *MockQuerier_ListRepositoriesByAuthorization_Call {
	return &MockQuerier_ListRepositoriesByAuthorization_Call{Call: _e.mock.On("ListRepositoriesByAuthorization", ctx, arg)}
}

func (_c *MockQuerier_ListRepositoriesByAuthorization_Call) Run(run func(ctx context.Context, arg ListRepositoriesByAuthorizationParams)) *MockQuerier_ListRepositoriesByAuthorization_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ListRepositoriesByAuthorizationParams))
	})
	return _c
}

func (_c *MockQuerier_ListRepositoriesByAuthorization_Call) Return(_a0 []string, _a1 error) *MockQuerier_ListRepositoriesByAuthorization_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_ListRepositoriesByAuthorization_Call) RunAndReturn(run func(context.Context, ListRepositoriesByAuthorizationParams) ([]string, error)) *MockQuerier_ListRepositoriesByAuthorization_Call {
	_c.Call.Return(run)
	return _c
}

// MaxResourceUtilizationDate provides a mock function with given fields: ctx
func (_m *MockQuerier) MaxResourceUtilizationDate(ctx context.Context) (pgtype.Timestamptz, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for MaxResourceUtilizationDate")
	}

	var r0 pgtype.Timestamptz
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (pgtype.Timestamptz, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) pgtype.Timestamptz); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Get(0).(pgtype.Timestamptz)
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_MaxResourceUtilizationDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MaxResourceUtilizationDate'
type MockQuerier_MaxResourceUtilizationDate_Call struct {
	*mock.Call
}

// MaxResourceUtilizationDate is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockQuerier_Expecter) MaxResourceUtilizationDate(ctx interface{}) *MockQuerier_MaxResourceUtilizationDate_Call {
	return &MockQuerier_MaxResourceUtilizationDate_Call{Call: _e.mock.On("MaxResourceUtilizationDate", ctx)}
}

func (_c *MockQuerier_MaxResourceUtilizationDate_Call) Run(run func(ctx context.Context)) *MockQuerier_MaxResourceUtilizationDate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockQuerier_MaxResourceUtilizationDate_Call) Return(_a0 pgtype.Timestamptz, _a1 error) *MockQuerier_MaxResourceUtilizationDate_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_MaxResourceUtilizationDate_Call) RunAndReturn(run func(context.Context) (pgtype.Timestamptz, error)) *MockQuerier_MaxResourceUtilizationDate_Call {
	_c.Call.Return(run)
	return _c
}

// MonthlyCostForApp provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) MonthlyCostForApp(ctx context.Context, arg MonthlyCostForAppParams) ([]*MonthlyCostForAppRow, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for MonthlyCostForApp")
	}

	var r0 []*MonthlyCostForAppRow
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, MonthlyCostForAppParams) ([]*MonthlyCostForAppRow, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, MonthlyCostForAppParams) []*MonthlyCostForAppRow); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*MonthlyCostForAppRow)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, MonthlyCostForAppParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_MonthlyCostForApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MonthlyCostForApp'
type MockQuerier_MonthlyCostForApp_Call struct {
	*mock.Call
}

// MonthlyCostForApp is a helper method to define mock.On call
//   - ctx context.Context
//   - arg MonthlyCostForAppParams
func (_e *MockQuerier_Expecter) MonthlyCostForApp(ctx interface{}, arg interface{}) *MockQuerier_MonthlyCostForApp_Call {
	return &MockQuerier_MonthlyCostForApp_Call{Call: _e.mock.On("MonthlyCostForApp", ctx, arg)}
}

func (_c *MockQuerier_MonthlyCostForApp_Call) Run(run func(ctx context.Context, arg MonthlyCostForAppParams)) *MockQuerier_MonthlyCostForApp_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(MonthlyCostForAppParams))
	})
	return _c
}

func (_c *MockQuerier_MonthlyCostForApp_Call) Return(_a0 []*MonthlyCostForAppRow, _a1 error) *MockQuerier_MonthlyCostForApp_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_MonthlyCostForApp_Call) RunAndReturn(run func(context.Context, MonthlyCostForAppParams) ([]*MonthlyCostForAppRow, error)) *MockQuerier_MonthlyCostForApp_Call {
	_c.Call.Return(run)
	return _c
}

// MonthlyCostForTeam provides a mock function with given fields: ctx, teamSlug
func (_m *MockQuerier) MonthlyCostForTeam(ctx context.Context, teamSlug slug.Slug) ([]*CostMonthlyTeam, error) {
	ret := _m.Called(ctx, teamSlug)

	if len(ret) == 0 {
		panic("no return value specified for MonthlyCostForTeam")
	}

	var r0 []*CostMonthlyTeam
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, slug.Slug) ([]*CostMonthlyTeam, error)); ok {
		return rf(ctx, teamSlug)
	}
	if rf, ok := ret.Get(0).(func(context.Context, slug.Slug) []*CostMonthlyTeam); ok {
		r0 = rf(ctx, teamSlug)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*CostMonthlyTeam)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, slug.Slug) error); ok {
		r1 = rf(ctx, teamSlug)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_MonthlyCostForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MonthlyCostForTeam'
type MockQuerier_MonthlyCostForTeam_Call struct {
	*mock.Call
}

// MonthlyCostForTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - teamSlug slug.Slug
func (_e *MockQuerier_Expecter) MonthlyCostForTeam(ctx interface{}, teamSlug interface{}) *MockQuerier_MonthlyCostForTeam_Call {
	return &MockQuerier_MonthlyCostForTeam_Call{Call: _e.mock.On("MonthlyCostForTeam", ctx, teamSlug)}
}

func (_c *MockQuerier_MonthlyCostForTeam_Call) Run(run func(ctx context.Context, teamSlug slug.Slug)) *MockQuerier_MonthlyCostForTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(slug.Slug))
	})
	return _c
}

func (_c *MockQuerier_MonthlyCostForTeam_Call) Return(_a0 []*CostMonthlyTeam, _a1 error) *MockQuerier_MonthlyCostForTeam_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_MonthlyCostForTeam_Call) RunAndReturn(run func(context.Context, slug.Slug) ([]*CostMonthlyTeam, error)) *MockQuerier_MonthlyCostForTeam_Call {
	_c.Call.Return(run)
	return _c
}

// RefreshCostMonthlyTeam provides a mock function with given fields: ctx
func (_m *MockQuerier) RefreshCostMonthlyTeam(ctx context.Context) error {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for RefreshCostMonthlyTeam")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_RefreshCostMonthlyTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefreshCostMonthlyTeam'
type MockQuerier_RefreshCostMonthlyTeam_Call struct {
	*mock.Call
}

// RefreshCostMonthlyTeam is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockQuerier_Expecter) RefreshCostMonthlyTeam(ctx interface{}) *MockQuerier_RefreshCostMonthlyTeam_Call {
	return &MockQuerier_RefreshCostMonthlyTeam_Call{Call: _e.mock.On("RefreshCostMonthlyTeam", ctx)}
}

func (_c *MockQuerier_RefreshCostMonthlyTeam_Call) Run(run func(ctx context.Context)) *MockQuerier_RefreshCostMonthlyTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockQuerier_RefreshCostMonthlyTeam_Call) Return(_a0 error) *MockQuerier_RefreshCostMonthlyTeam_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_RefreshCostMonthlyTeam_Call) RunAndReturn(run func(context.Context) error) *MockQuerier_RefreshCostMonthlyTeam_Call {
	_c.Call.Return(run)
	return _c
}

// RefreshResourceTeamRange provides a mock function with given fields: ctx
func (_m *MockQuerier) RefreshResourceTeamRange(ctx context.Context) error {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for RefreshResourceTeamRange")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_RefreshResourceTeamRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefreshResourceTeamRange'
type MockQuerier_RefreshResourceTeamRange_Call struct {
	*mock.Call
}

// RefreshResourceTeamRange is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockQuerier_Expecter) RefreshResourceTeamRange(ctx interface{}) *MockQuerier_RefreshResourceTeamRange_Call {
	return &MockQuerier_RefreshResourceTeamRange_Call{Call: _e.mock.On("RefreshResourceTeamRange", ctx)}
}

func (_c *MockQuerier_RefreshResourceTeamRange_Call) Run(run func(ctx context.Context)) *MockQuerier_RefreshResourceTeamRange_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockQuerier_RefreshResourceTeamRange_Call) Return(_a0 error) *MockQuerier_RefreshResourceTeamRange_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_RefreshResourceTeamRange_Call) RunAndReturn(run func(context.Context) error) *MockQuerier_RefreshResourceTeamRange_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveAllServiceAccountRoles provides a mock function with given fields: ctx, serviceAccountID
func (_m *MockQuerier) RemoveAllServiceAccountRoles(ctx context.Context, serviceAccountID uuid.UUID) error {
	ret := _m.Called(ctx, serviceAccountID)

	if len(ret) == 0 {
		panic("no return value specified for RemoveAllServiceAccountRoles")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) error); ok {
		r0 = rf(ctx, serviceAccountID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_RemoveAllServiceAccountRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAllServiceAccountRoles'
type MockQuerier_RemoveAllServiceAccountRoles_Call struct {
	*mock.Call
}

// RemoveAllServiceAccountRoles is a helper method to define mock.On call
//   - ctx context.Context
//   - serviceAccountID uuid.UUID
func (_e *MockQuerier_Expecter) RemoveAllServiceAccountRoles(ctx interface{}, serviceAccountID interface{}) *MockQuerier_RemoveAllServiceAccountRoles_Call {
	return &MockQuerier_RemoveAllServiceAccountRoles_Call{Call: _e.mock.On("RemoveAllServiceAccountRoles", ctx, serviceAccountID)}
}

func (_c *MockQuerier_RemoveAllServiceAccountRoles_Call) Run(run func(ctx context.Context, serviceAccountID uuid.UUID)) *MockQuerier_RemoveAllServiceAccountRoles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uuid.UUID))
	})
	return _c
}

func (_c *MockQuerier_RemoveAllServiceAccountRoles_Call) Return(_a0 error) *MockQuerier_RemoveAllServiceAccountRoles_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_RemoveAllServiceAccountRoles_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *MockQuerier_RemoveAllServiceAccountRoles_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveApiKeysFromServiceAccount provides a mock function with given fields: ctx, serviceAccountID
func (_m *MockQuerier) RemoveApiKeysFromServiceAccount(ctx context.Context, serviceAccountID uuid.UUID) error {
	ret := _m.Called(ctx, serviceAccountID)

	if len(ret) == 0 {
		panic("no return value specified for RemoveApiKeysFromServiceAccount")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID) error); ok {
		r0 = rf(ctx, serviceAccountID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_RemoveApiKeysFromServiceAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveApiKeysFromServiceAccount'
type MockQuerier_RemoveApiKeysFromServiceAccount_Call struct {
	*mock.Call
}

// RemoveApiKeysFromServiceAccount is a helper method to define mock.On call
//   - ctx context.Context
//   - serviceAccountID uuid.UUID
func (_e *MockQuerier_Expecter) RemoveApiKeysFromServiceAccount(ctx interface{}, serviceAccountID interface{}) *MockQuerier_RemoveApiKeysFromServiceAccount_Call {
	return &MockQuerier_RemoveApiKeysFromServiceAccount_Call{Call: _e.mock.On("RemoveApiKeysFromServiceAccount", ctx, serviceAccountID)}
}

func (_c *MockQuerier_RemoveApiKeysFromServiceAccount_Call) Run(run func(ctx context.Context, serviceAccountID uuid.UUID)) *MockQuerier_RemoveApiKeysFromServiceAccount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uuid.UUID))
	})
	return _c
}

func (_c *MockQuerier_RemoveApiKeysFromServiceAccount_Call) Return(_a0 error) *MockQuerier_RemoveApiKeysFromServiceAccount_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_RemoveApiKeysFromServiceAccount_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *MockQuerier_RemoveApiKeysFromServiceAccount_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveReconcilerOptOut provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) RemoveReconcilerOptOut(ctx context.Context, arg RemoveReconcilerOptOutParams) error {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for RemoveReconcilerOptOut")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, RemoveReconcilerOptOutParams) error); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_RemoveReconcilerOptOut_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveReconcilerOptOut'
type MockQuerier_RemoveReconcilerOptOut_Call struct {
	*mock.Call
}

// RemoveReconcilerOptOut is a helper method to define mock.On call
//   - ctx context.Context
//   - arg RemoveReconcilerOptOutParams
func (_e *MockQuerier_Expecter) RemoveReconcilerOptOut(ctx interface{}, arg interface{}) *MockQuerier_RemoveReconcilerOptOut_Call {
	return &MockQuerier_RemoveReconcilerOptOut_Call{Call: _e.mock.On("RemoveReconcilerOptOut", ctx, arg)}
}

func (_c *MockQuerier_RemoveReconcilerOptOut_Call) Run(run func(ctx context.Context, arg RemoveReconcilerOptOutParams)) *MockQuerier_RemoveReconcilerOptOut_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(RemoveReconcilerOptOutParams))
	})
	return _c
}

func (_c *MockQuerier_RemoveReconcilerOptOut_Call) Return(_a0 error) *MockQuerier_RemoveReconcilerOptOut_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_RemoveReconcilerOptOut_Call) RunAndReturn(run func(context.Context, RemoveReconcilerOptOutParams) error) *MockQuerier_RemoveReconcilerOptOut_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveRepositoryAuthorization provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) RemoveRepositoryAuthorization(ctx context.Context, arg RemoveRepositoryAuthorizationParams) error {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for RemoveRepositoryAuthorization")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, RemoveRepositoryAuthorizationParams) error); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_RemoveRepositoryAuthorization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRepositoryAuthorization'
type MockQuerier_RemoveRepositoryAuthorization_Call struct {
	*mock.Call
}

// RemoveRepositoryAuthorization is a helper method to define mock.On call
//   - ctx context.Context
//   - arg RemoveRepositoryAuthorizationParams
func (_e *MockQuerier_Expecter) RemoveRepositoryAuthorization(ctx interface{}, arg interface{}) *MockQuerier_RemoveRepositoryAuthorization_Call {
	return &MockQuerier_RemoveRepositoryAuthorization_Call{Call: _e.mock.On("RemoveRepositoryAuthorization", ctx, arg)}
}

func (_c *MockQuerier_RemoveRepositoryAuthorization_Call) Run(run func(ctx context.Context, arg RemoveRepositoryAuthorizationParams)) *MockQuerier_RemoveRepositoryAuthorization_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(RemoveRepositoryAuthorizationParams))
	})
	return _c
}

func (_c *MockQuerier_RemoveRepositoryAuthorization_Call) Return(_a0 error) *MockQuerier_RemoveRepositoryAuthorization_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_RemoveRepositoryAuthorization_Call) RunAndReturn(run func(context.Context, RemoveRepositoryAuthorizationParams) error) *MockQuerier_RemoveRepositoryAuthorization_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveUserFromTeam provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) RemoveUserFromTeam(ctx context.Context, arg RemoveUserFromTeamParams) error {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for RemoveUserFromTeam")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, RemoveUserFromTeamParams) error); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_RemoveUserFromTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveUserFromTeam'
type MockQuerier_RemoveUserFromTeam_Call struct {
	*mock.Call
}

// RemoveUserFromTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - arg RemoveUserFromTeamParams
func (_e *MockQuerier_Expecter) RemoveUserFromTeam(ctx interface{}, arg interface{}) *MockQuerier_RemoveUserFromTeam_Call {
	return &MockQuerier_RemoveUserFromTeam_Call{Call: _e.mock.On("RemoveUserFromTeam", ctx, arg)}
}

func (_c *MockQuerier_RemoveUserFromTeam_Call) Run(run func(ctx context.Context, arg RemoveUserFromTeamParams)) *MockQuerier_RemoveUserFromTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(RemoveUserFromTeamParams))
	})
	return _c
}

func (_c *MockQuerier_RemoveUserFromTeam_Call) Return(_a0 error) *MockQuerier_RemoveUserFromTeam_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_RemoveUserFromTeam_Call) RunAndReturn(run func(context.Context, RemoveUserFromTeamParams) error) *MockQuerier_RemoveUserFromTeam_Call {
	_c.Call.Return(run)
	return _c
}

// ResetReconcilerConfig provides a mock function with given fields: ctx, reconcilerName
func (_m *MockQuerier) ResetReconcilerConfig(ctx context.Context, reconcilerName string) error {
	ret := _m.Called(ctx, reconcilerName)

	if len(ret) == 0 {
		panic("no return value specified for ResetReconcilerConfig")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = rf(ctx, reconcilerName)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_ResetReconcilerConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetReconcilerConfig'
type MockQuerier_ResetReconcilerConfig_Call struct {
	*mock.Call
}

// ResetReconcilerConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - reconcilerName string
func (_e *MockQuerier_Expecter) ResetReconcilerConfig(ctx interface{}, reconcilerName interface{}) *MockQuerier_ResetReconcilerConfig_Call {
	return &MockQuerier_ResetReconcilerConfig_Call{Call: _e.mock.On("ResetReconcilerConfig", ctx, reconcilerName)}
}

func (_c *MockQuerier_ResetReconcilerConfig_Call) Run(run func(ctx context.Context, reconcilerName string)) *MockQuerier_ResetReconcilerConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockQuerier_ResetReconcilerConfig_Call) Return(_a0 error) *MockQuerier_ResetReconcilerConfig_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_ResetReconcilerConfig_Call) RunAndReturn(run func(context.Context, string) error) *MockQuerier_ResetReconcilerConfig_Call {
	_c.Call.Return(run)
	return _c
}

// ResourceUtilizationForApp provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) ResourceUtilizationForApp(ctx context.Context, arg ResourceUtilizationForAppParams) ([]*ResourceUtilizationMetric, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for ResourceUtilizationForApp")
	}

	var r0 []*ResourceUtilizationMetric
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ResourceUtilizationForAppParams) ([]*ResourceUtilizationMetric, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ResourceUtilizationForAppParams) []*ResourceUtilizationMetric); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*ResourceUtilizationMetric)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ResourceUtilizationForAppParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_ResourceUtilizationForApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceUtilizationForApp'
type MockQuerier_ResourceUtilizationForApp_Call struct {
	*mock.Call
}

// ResourceUtilizationForApp is a helper method to define mock.On call
//   - ctx context.Context
//   - arg ResourceUtilizationForAppParams
func (_e *MockQuerier_Expecter) ResourceUtilizationForApp(ctx interface{}, arg interface{}) *MockQuerier_ResourceUtilizationForApp_Call {
	return &MockQuerier_ResourceUtilizationForApp_Call{Call: _e.mock.On("ResourceUtilizationForApp", ctx, arg)}
}

func (_c *MockQuerier_ResourceUtilizationForApp_Call) Run(run func(ctx context.Context, arg ResourceUtilizationForAppParams)) *MockQuerier_ResourceUtilizationForApp_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ResourceUtilizationForAppParams))
	})
	return _c
}

func (_c *MockQuerier_ResourceUtilizationForApp_Call) Return(_a0 []*ResourceUtilizationMetric, _a1 error) *MockQuerier_ResourceUtilizationForApp_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_ResourceUtilizationForApp_Call) RunAndReturn(run func(context.Context, ResourceUtilizationForAppParams) ([]*ResourceUtilizationMetric, error)) *MockQuerier_ResourceUtilizationForApp_Call {
	_c.Call.Return(run)
	return _c
}

// ResourceUtilizationForTeam provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) ResourceUtilizationForTeam(ctx context.Context, arg ResourceUtilizationForTeamParams) ([]*ResourceUtilizationForTeamRow, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for ResourceUtilizationForTeam")
	}

	var r0 []*ResourceUtilizationForTeamRow
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ResourceUtilizationForTeamParams) ([]*ResourceUtilizationForTeamRow, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ResourceUtilizationForTeamParams) []*ResourceUtilizationForTeamRow); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*ResourceUtilizationForTeamRow)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ResourceUtilizationForTeamParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_ResourceUtilizationForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceUtilizationForTeam'
type MockQuerier_ResourceUtilizationForTeam_Call struct {
	*mock.Call
}

// ResourceUtilizationForTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - arg ResourceUtilizationForTeamParams
func (_e *MockQuerier_Expecter) ResourceUtilizationForTeam(ctx interface{}, arg interface{}) *MockQuerier_ResourceUtilizationForTeam_Call {
	return &MockQuerier_ResourceUtilizationForTeam_Call{Call: _e.mock.On("ResourceUtilizationForTeam", ctx, arg)}
}

func (_c *MockQuerier_ResourceUtilizationForTeam_Call) Run(run func(ctx context.Context, arg ResourceUtilizationForTeamParams)) *MockQuerier_ResourceUtilizationForTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ResourceUtilizationForTeamParams))
	})
	return _c
}

func (_c *MockQuerier_ResourceUtilizationForTeam_Call) Return(_a0 []*ResourceUtilizationForTeamRow, _a1 error) *MockQuerier_ResourceUtilizationForTeam_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_ResourceUtilizationForTeam_Call) RunAndReturn(run func(context.Context, ResourceUtilizationForTeamParams) ([]*ResourceUtilizationForTeamRow, error)) *MockQuerier_ResourceUtilizationForTeam_Call {
	_c.Call.Return(run)
	return _c
}

// ResourceUtilizationOverageForTeam provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) ResourceUtilizationOverageForTeam(ctx context.Context, arg ResourceUtilizationOverageForTeamParams) ([]*ResourceUtilizationOverageForTeamRow, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for ResourceUtilizationOverageForTeam")
	}

	var r0 []*ResourceUtilizationOverageForTeamRow
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ResourceUtilizationOverageForTeamParams) ([]*ResourceUtilizationOverageForTeamRow, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ResourceUtilizationOverageForTeamParams) []*ResourceUtilizationOverageForTeamRow); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*ResourceUtilizationOverageForTeamRow)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ResourceUtilizationOverageForTeamParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_ResourceUtilizationOverageForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceUtilizationOverageForTeam'
type MockQuerier_ResourceUtilizationOverageForTeam_Call struct {
	*mock.Call
}

// ResourceUtilizationOverageForTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - arg ResourceUtilizationOverageForTeamParams
func (_e *MockQuerier_Expecter) ResourceUtilizationOverageForTeam(ctx interface{}, arg interface{}) *MockQuerier_ResourceUtilizationOverageForTeam_Call {
	return &MockQuerier_ResourceUtilizationOverageForTeam_Call{Call: _e.mock.On("ResourceUtilizationOverageForTeam", ctx, arg)}
}

func (_c *MockQuerier_ResourceUtilizationOverageForTeam_Call) Run(run func(ctx context.Context, arg ResourceUtilizationOverageForTeamParams)) *MockQuerier_ResourceUtilizationOverageForTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ResourceUtilizationOverageForTeamParams))
	})
	return _c
}

func (_c *MockQuerier_ResourceUtilizationOverageForTeam_Call) Return(_a0 []*ResourceUtilizationOverageForTeamRow, _a1 error) *MockQuerier_ResourceUtilizationOverageForTeam_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_ResourceUtilizationOverageForTeam_Call) RunAndReturn(run func(context.Context, ResourceUtilizationOverageForTeamParams) ([]*ResourceUtilizationOverageForTeamRow, error)) *MockQuerier_ResourceUtilizationOverageForTeam_Call {
	_c.Call.Return(run)
	return _c
}

// ResourceUtilizationRangeForApp provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) ResourceUtilizationRangeForApp(ctx context.Context, arg ResourceUtilizationRangeForAppParams) (*ResourceUtilizationRangeForAppRow, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for ResourceUtilizationRangeForApp")
	}

	var r0 *ResourceUtilizationRangeForAppRow
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ResourceUtilizationRangeForAppParams) (*ResourceUtilizationRangeForAppRow, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ResourceUtilizationRangeForAppParams) *ResourceUtilizationRangeForAppRow); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ResourceUtilizationRangeForAppRow)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ResourceUtilizationRangeForAppParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_ResourceUtilizationRangeForApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceUtilizationRangeForApp'
type MockQuerier_ResourceUtilizationRangeForApp_Call struct {
	*mock.Call
}

// ResourceUtilizationRangeForApp is a helper method to define mock.On call
//   - ctx context.Context
//   - arg ResourceUtilizationRangeForAppParams
func (_e *MockQuerier_Expecter) ResourceUtilizationRangeForApp(ctx interface{}, arg interface{}) *MockQuerier_ResourceUtilizationRangeForApp_Call {
	return &MockQuerier_ResourceUtilizationRangeForApp_Call{Call: _e.mock.On("ResourceUtilizationRangeForApp", ctx, arg)}
}

func (_c *MockQuerier_ResourceUtilizationRangeForApp_Call) Run(run func(ctx context.Context, arg ResourceUtilizationRangeForAppParams)) *MockQuerier_ResourceUtilizationRangeForApp_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ResourceUtilizationRangeForAppParams))
	})
	return _c
}

func (_c *MockQuerier_ResourceUtilizationRangeForApp_Call) Return(_a0 *ResourceUtilizationRangeForAppRow, _a1 error) *MockQuerier_ResourceUtilizationRangeForApp_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_ResourceUtilizationRangeForApp_Call) RunAndReturn(run func(context.Context, ResourceUtilizationRangeForAppParams) (*ResourceUtilizationRangeForAppRow, error)) *MockQuerier_ResourceUtilizationRangeForApp_Call {
	_c.Call.Return(run)
	return _c
}

// ResourceUtilizationRangeForTeam provides a mock function with given fields: ctx, teamSlug
func (_m *MockQuerier) ResourceUtilizationRangeForTeam(ctx context.Context, teamSlug slug.Slug) (*ResourceUtilizationRangeForTeamRow, error) {
	ret := _m.Called(ctx, teamSlug)

	if len(ret) == 0 {
		panic("no return value specified for ResourceUtilizationRangeForTeam")
	}

	var r0 *ResourceUtilizationRangeForTeamRow
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, slug.Slug) (*ResourceUtilizationRangeForTeamRow, error)); ok {
		return rf(ctx, teamSlug)
	}
	if rf, ok := ret.Get(0).(func(context.Context, slug.Slug) *ResourceUtilizationRangeForTeamRow); ok {
		r0 = rf(ctx, teamSlug)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ResourceUtilizationRangeForTeamRow)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, slug.Slug) error); ok {
		r1 = rf(ctx, teamSlug)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_ResourceUtilizationRangeForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceUtilizationRangeForTeam'
type MockQuerier_ResourceUtilizationRangeForTeam_Call struct {
	*mock.Call
}

// ResourceUtilizationRangeForTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - teamSlug slug.Slug
func (_e *MockQuerier_Expecter) ResourceUtilizationRangeForTeam(ctx interface{}, teamSlug interface{}) *MockQuerier_ResourceUtilizationRangeForTeam_Call {
	return &MockQuerier_ResourceUtilizationRangeForTeam_Call{Call: _e.mock.On("ResourceUtilizationRangeForTeam", ctx, teamSlug)}
}

func (_c *MockQuerier_ResourceUtilizationRangeForTeam_Call) Run(run func(ctx context.Context, teamSlug slug.Slug)) *MockQuerier_ResourceUtilizationRangeForTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(slug.Slug))
	})
	return _c
}

func (_c *MockQuerier_ResourceUtilizationRangeForTeam_Call) Return(_a0 *ResourceUtilizationRangeForTeamRow, _a1 error) *MockQuerier_ResourceUtilizationRangeForTeam_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_ResourceUtilizationRangeForTeam_Call) RunAndReturn(run func(context.Context, slug.Slug) (*ResourceUtilizationRangeForTeamRow, error)) *MockQuerier_ResourceUtilizationRangeForTeam_Call {
	_c.Call.Return(run)
	return _c
}

// ResourceUtilizationUpsert provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) ResourceUtilizationUpsert(ctx context.Context, arg []ResourceUtilizationUpsertParams) *ResourceUtilizationUpsertBatchResults {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for ResourceUtilizationUpsert")
	}

	var r0 *ResourceUtilizationUpsertBatchResults
	if rf, ok := ret.Get(0).(func(context.Context, []ResourceUtilizationUpsertParams) *ResourceUtilizationUpsertBatchResults); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ResourceUtilizationUpsertBatchResults)
		}
	}

	return r0
}

// MockQuerier_ResourceUtilizationUpsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceUtilizationUpsert'
type MockQuerier_ResourceUtilizationUpsert_Call struct {
	*mock.Call
}

// ResourceUtilizationUpsert is a helper method to define mock.On call
//   - ctx context.Context
//   - arg []ResourceUtilizationUpsertParams
func (_e *MockQuerier_Expecter) ResourceUtilizationUpsert(ctx interface{}, arg interface{}) *MockQuerier_ResourceUtilizationUpsert_Call {
	return &MockQuerier_ResourceUtilizationUpsert_Call{Call: _e.mock.On("ResourceUtilizationUpsert", ctx, arg)}
}

func (_c *MockQuerier_ResourceUtilizationUpsert_Call) Run(run func(ctx context.Context, arg []ResourceUtilizationUpsertParams)) *MockQuerier_ResourceUtilizationUpsert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]ResourceUtilizationUpsertParams))
	})
	return _c
}

func (_c *MockQuerier_ResourceUtilizationUpsert_Call) Return(_a0 *ResourceUtilizationUpsertBatchResults) *MockQuerier_ResourceUtilizationUpsert_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_ResourceUtilizationUpsert_Call) RunAndReturn(run func(context.Context, []ResourceUtilizationUpsertParams) *ResourceUtilizationUpsertBatchResults) *MockQuerier_ResourceUtilizationUpsert_Call {
	_c.Call.Return(run)
	return _c
}

// RevokeGlobalUserRole provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) RevokeGlobalUserRole(ctx context.Context, arg RevokeGlobalUserRoleParams) error {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for RevokeGlobalUserRole")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, RevokeGlobalUserRoleParams) error); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_RevokeGlobalUserRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevokeGlobalUserRole'
type MockQuerier_RevokeGlobalUserRole_Call struct {
	*mock.Call
}

// RevokeGlobalUserRole is a helper method to define mock.On call
//   - ctx context.Context
//   - arg RevokeGlobalUserRoleParams
func (_e *MockQuerier_Expecter) RevokeGlobalUserRole(ctx interface{}, arg interface{}) *MockQuerier_RevokeGlobalUserRole_Call {
	return &MockQuerier_RevokeGlobalUserRole_Call{Call: _e.mock.On("RevokeGlobalUserRole", ctx, arg)}
}

func (_c *MockQuerier_RevokeGlobalUserRole_Call) Run(run func(ctx context.Context, arg RevokeGlobalUserRoleParams)) *MockQuerier_RevokeGlobalUserRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(RevokeGlobalUserRoleParams))
	})
	return _c
}

func (_c *MockQuerier_RevokeGlobalUserRole_Call) Return(_a0 error) *MockQuerier_RevokeGlobalUserRole_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_RevokeGlobalUserRole_Call) RunAndReturn(run func(context.Context, RevokeGlobalUserRoleParams) error) *MockQuerier_RevokeGlobalUserRole_Call {
	_c.Call.Return(run)
	return _c
}

// SetLastSuccessfulSyncForTeam provides a mock function with given fields: ctx, argSlug
func (_m *MockQuerier) SetLastSuccessfulSyncForTeam(ctx context.Context, argSlug slug.Slug) error {
	ret := _m.Called(ctx, argSlug)

	if len(ret) == 0 {
		panic("no return value specified for SetLastSuccessfulSyncForTeam")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, slug.Slug) error); ok {
		r0 = rf(ctx, argSlug)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_SetLastSuccessfulSyncForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetLastSuccessfulSyncForTeam'
type MockQuerier_SetLastSuccessfulSyncForTeam_Call struct {
	*mock.Call
}

// SetLastSuccessfulSyncForTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - argSlug slug.Slug
func (_e *MockQuerier_Expecter) SetLastSuccessfulSyncForTeam(ctx interface{}, argSlug interface{}) *MockQuerier_SetLastSuccessfulSyncForTeam_Call {
	return &MockQuerier_SetLastSuccessfulSyncForTeam_Call{Call: _e.mock.On("SetLastSuccessfulSyncForTeam", ctx, argSlug)}
}

func (_c *MockQuerier_SetLastSuccessfulSyncForTeam_Call) Run(run func(ctx context.Context, argSlug slug.Slug)) *MockQuerier_SetLastSuccessfulSyncForTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(slug.Slug))
	})
	return _c
}

func (_c *MockQuerier_SetLastSuccessfulSyncForTeam_Call) Return(_a0 error) *MockQuerier_SetLastSuccessfulSyncForTeam_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_SetLastSuccessfulSyncForTeam_Call) RunAndReturn(run func(context.Context, slug.Slug) error) *MockQuerier_SetLastSuccessfulSyncForTeam_Call {
	_c.Call.Return(run)
	return _c
}

// SetReconcilerErrorForTeam provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) SetReconcilerErrorForTeam(ctx context.Context, arg SetReconcilerErrorForTeamParams) error {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for SetReconcilerErrorForTeam")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, SetReconcilerErrorForTeamParams) error); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_SetReconcilerErrorForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetReconcilerErrorForTeam'
type MockQuerier_SetReconcilerErrorForTeam_Call struct {
	*mock.Call
}

// SetReconcilerErrorForTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - arg SetReconcilerErrorForTeamParams
func (_e *MockQuerier_Expecter) SetReconcilerErrorForTeam(ctx interface{}, arg interface{}) *MockQuerier_SetReconcilerErrorForTeam_Call {
	return &MockQuerier_SetReconcilerErrorForTeam_Call{Call: _e.mock.On("SetReconcilerErrorForTeam", ctx, arg)}
}

func (_c *MockQuerier_SetReconcilerErrorForTeam_Call) Run(run func(ctx context.Context, arg SetReconcilerErrorForTeamParams)) *MockQuerier_SetReconcilerErrorForTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(SetReconcilerErrorForTeamParams))
	})
	return _c
}

func (_c *MockQuerier_SetReconcilerErrorForTeam_Call) Return(_a0 error) *MockQuerier_SetReconcilerErrorForTeam_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_SetReconcilerErrorForTeam_Call) RunAndReturn(run func(context.Context, SetReconcilerErrorForTeamParams) error) *MockQuerier_SetReconcilerErrorForTeam_Call {
	_c.Call.Return(run)
	return _c
}

// SetSessionExpires provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) SetSessionExpires(ctx context.Context, arg SetSessionExpiresParams) (*Session, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for SetSessionExpires")
	}

	var r0 *Session
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, SetSessionExpiresParams) (*Session, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, SetSessionExpiresParams) *Session); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*Session)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, SetSessionExpiresParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_SetSessionExpires_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSessionExpires'
type MockQuerier_SetSessionExpires_Call struct {
	*mock.Call
}

// SetSessionExpires is a helper method to define mock.On call
//   - ctx context.Context
//   - arg SetSessionExpiresParams
func (_e *MockQuerier_Expecter) SetSessionExpires(ctx interface{}, arg interface{}) *MockQuerier_SetSessionExpires_Call {
	return &MockQuerier_SetSessionExpires_Call{Call: _e.mock.On("SetSessionExpires", ctx, arg)}
}

func (_c *MockQuerier_SetSessionExpires_Call) Run(run func(ctx context.Context, arg SetSessionExpiresParams)) *MockQuerier_SetSessionExpires_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(SetSessionExpiresParams))
	})
	return _c
}

func (_c *MockQuerier_SetSessionExpires_Call) Return(_a0 *Session, _a1 error) *MockQuerier_SetSessionExpires_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_SetSessionExpires_Call) RunAndReturn(run func(context.Context, SetSessionExpiresParams) (*Session, error)) *MockQuerier_SetSessionExpires_Call {
	_c.Call.Return(run)
	return _c
}

// SpecificResourceUtilizationForApp provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) SpecificResourceUtilizationForApp(ctx context.Context, arg SpecificResourceUtilizationForAppParams) (*SpecificResourceUtilizationForAppRow, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for SpecificResourceUtilizationForApp")
	}

	var r0 *SpecificResourceUtilizationForAppRow
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, SpecificResourceUtilizationForAppParams) (*SpecificResourceUtilizationForAppRow, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, SpecificResourceUtilizationForAppParams) *SpecificResourceUtilizationForAppRow); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*SpecificResourceUtilizationForAppRow)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, SpecificResourceUtilizationForAppParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_SpecificResourceUtilizationForApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SpecificResourceUtilizationForApp'
type MockQuerier_SpecificResourceUtilizationForApp_Call struct {
	*mock.Call
}

// SpecificResourceUtilizationForApp is a helper method to define mock.On call
//   - ctx context.Context
//   - arg SpecificResourceUtilizationForAppParams
func (_e *MockQuerier_Expecter) SpecificResourceUtilizationForApp(ctx interface{}, arg interface{}) *MockQuerier_SpecificResourceUtilizationForApp_Call {
	return &MockQuerier_SpecificResourceUtilizationForApp_Call{Call: _e.mock.On("SpecificResourceUtilizationForApp", ctx, arg)}
}

func (_c *MockQuerier_SpecificResourceUtilizationForApp_Call) Run(run func(ctx context.Context, arg SpecificResourceUtilizationForAppParams)) *MockQuerier_SpecificResourceUtilizationForApp_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(SpecificResourceUtilizationForAppParams))
	})
	return _c
}

func (_c *MockQuerier_SpecificResourceUtilizationForApp_Call) Return(_a0 *SpecificResourceUtilizationForAppRow, _a1 error) *MockQuerier_SpecificResourceUtilizationForApp_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_SpecificResourceUtilizationForApp_Call) RunAndReturn(run func(context.Context, SpecificResourceUtilizationForAppParams) (*SpecificResourceUtilizationForAppRow, error)) *MockQuerier_SpecificResourceUtilizationForApp_Call {
	_c.Call.Return(run)
	return _c
}

// SpecificResourceUtilizationForTeam provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) SpecificResourceUtilizationForTeam(ctx context.Context, arg SpecificResourceUtilizationForTeamParams) ([]*SpecificResourceUtilizationForTeamRow, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for SpecificResourceUtilizationForTeam")
	}

	var r0 []*SpecificResourceUtilizationForTeamRow
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, SpecificResourceUtilizationForTeamParams) ([]*SpecificResourceUtilizationForTeamRow, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, SpecificResourceUtilizationForTeamParams) []*SpecificResourceUtilizationForTeamRow); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*SpecificResourceUtilizationForTeamRow)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, SpecificResourceUtilizationForTeamParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_SpecificResourceUtilizationForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SpecificResourceUtilizationForTeam'
type MockQuerier_SpecificResourceUtilizationForTeam_Call struct {
	*mock.Call
}

// SpecificResourceUtilizationForTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - arg SpecificResourceUtilizationForTeamParams
func (_e *MockQuerier_Expecter) SpecificResourceUtilizationForTeam(ctx interface{}, arg interface{}) *MockQuerier_SpecificResourceUtilizationForTeam_Call {
	return &MockQuerier_SpecificResourceUtilizationForTeam_Call{Call: _e.mock.On("SpecificResourceUtilizationForTeam", ctx, arg)}
}

func (_c *MockQuerier_SpecificResourceUtilizationForTeam_Call) Run(run func(ctx context.Context, arg SpecificResourceUtilizationForTeamParams)) *MockQuerier_SpecificResourceUtilizationForTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(SpecificResourceUtilizationForTeamParams))
	})
	return _c
}

func (_c *MockQuerier_SpecificResourceUtilizationForTeam_Call) Return(_a0 []*SpecificResourceUtilizationForTeamRow, _a1 error) *MockQuerier_SpecificResourceUtilizationForTeam_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_SpecificResourceUtilizationForTeam_Call) RunAndReturn(run func(context.Context, SpecificResourceUtilizationForTeamParams) ([]*SpecificResourceUtilizationForTeamRow, error)) *MockQuerier_SpecificResourceUtilizationForTeam_Call {
	_c.Call.Return(run)
	return _c
}

// TeamExists provides a mock function with given fields: ctx, argSlug
func (_m *MockQuerier) TeamExists(ctx context.Context, argSlug slug.Slug) (bool, error) {
	ret := _m.Called(ctx, argSlug)

	if len(ret) == 0 {
		panic("no return value specified for TeamExists")
	}

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, slug.Slug) (bool, error)); ok {
		return rf(ctx, argSlug)
	}
	if rf, ok := ret.Get(0).(func(context.Context, slug.Slug) bool); ok {
		r0 = rf(ctx, argSlug)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, slug.Slug) error); ok {
		r1 = rf(ctx, argSlug)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_TeamExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TeamExists'
type MockQuerier_TeamExists_Call struct {
	*mock.Call
}

// TeamExists is a helper method to define mock.On call
//   - ctx context.Context
//   - argSlug slug.Slug
func (_e *MockQuerier_Expecter) TeamExists(ctx interface{}, argSlug interface{}) *MockQuerier_TeamExists_Call {
	return &MockQuerier_TeamExists_Call{Call: _e.mock.On("TeamExists", ctx, argSlug)}
}

func (_c *MockQuerier_TeamExists_Call) Run(run func(ctx context.Context, argSlug slug.Slug)) *MockQuerier_TeamExists_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(slug.Slug))
	})
	return _c
}

func (_c *MockQuerier_TeamExists_Call) Return(_a0 bool, _a1 error) *MockQuerier_TeamExists_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_TeamExists_Call) RunAndReturn(run func(context.Context, slug.Slug) (bool, error)) *MockQuerier_TeamExists_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTeam provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) UpdateTeam(ctx context.Context, arg UpdateTeamParams) (*Team, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for UpdateTeam")
	}

	var r0 *Team
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, UpdateTeamParams) (*Team, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, UpdateTeamParams) *Team); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*Team)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, UpdateTeamParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_UpdateTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTeam'
type MockQuerier_UpdateTeam_Call struct {
	*mock.Call
}

// UpdateTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - arg UpdateTeamParams
func (_e *MockQuerier_Expecter) UpdateTeam(ctx interface{}, arg interface{}) *MockQuerier_UpdateTeam_Call {
	return &MockQuerier_UpdateTeam_Call{Call: _e.mock.On("UpdateTeam", ctx, arg)}
}

func (_c *MockQuerier_UpdateTeam_Call) Run(run func(ctx context.Context, arg UpdateTeamParams)) *MockQuerier_UpdateTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(UpdateTeamParams))
	})
	return _c
}

func (_c *MockQuerier_UpdateTeam_Call) Return(_a0 *Team, _a1 error) *MockQuerier_UpdateTeam_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_UpdateTeam_Call) RunAndReturn(run func(context.Context, UpdateTeamParams) (*Team, error)) *MockQuerier_UpdateTeam_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTeamExternalReferences provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) UpdateTeamExternalReferences(ctx context.Context, arg UpdateTeamExternalReferencesParams) (*Team, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for UpdateTeamExternalReferences")
	}

	var r0 *Team
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, UpdateTeamExternalReferencesParams) (*Team, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, UpdateTeamExternalReferencesParams) *Team); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*Team)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, UpdateTeamExternalReferencesParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_UpdateTeamExternalReferences_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTeamExternalReferences'
type MockQuerier_UpdateTeamExternalReferences_Call struct {
	*mock.Call
}

// UpdateTeamExternalReferences is a helper method to define mock.On call
//   - ctx context.Context
//   - arg UpdateTeamExternalReferencesParams
func (_e *MockQuerier_Expecter) UpdateTeamExternalReferences(ctx interface{}, arg interface{}) *MockQuerier_UpdateTeamExternalReferences_Call {
	return &MockQuerier_UpdateTeamExternalReferences_Call{Call: _e.mock.On("UpdateTeamExternalReferences", ctx, arg)}
}

func (_c *MockQuerier_UpdateTeamExternalReferences_Call) Run(run func(ctx context.Context, arg UpdateTeamExternalReferencesParams)) *MockQuerier_UpdateTeamExternalReferences_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(UpdateTeamExternalReferencesParams))
	})
	return _c
}

func (_c *MockQuerier_UpdateTeamExternalReferences_Call) Return(_a0 *Team, _a1 error) *MockQuerier_UpdateTeamExternalReferences_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_UpdateTeamExternalReferences_Call) RunAndReturn(run func(context.Context, UpdateTeamExternalReferencesParams) (*Team, error)) *MockQuerier_UpdateTeamExternalReferences_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateUser provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) UpdateUser(ctx context.Context, arg UpdateUserParams) (*User, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for UpdateUser")
	}

	var r0 *User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, UpdateUserParams) (*User, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, UpdateUserParams) *User); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*User)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, UpdateUserParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_UpdateUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUser'
type MockQuerier_UpdateUser_Call struct {
	*mock.Call
}

// UpdateUser is a helper method to define mock.On call
//   - ctx context.Context
//   - arg UpdateUserParams
func (_e *MockQuerier_Expecter) UpdateUser(ctx interface{}, arg interface{}) *MockQuerier_UpdateUser_Call {
	return &MockQuerier_UpdateUser_Call{Call: _e.mock.On("UpdateUser", ctx, arg)}
}

func (_c *MockQuerier_UpdateUser_Call) Run(run func(ctx context.Context, arg UpdateUserParams)) *MockQuerier_UpdateUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(UpdateUserParams))
	})
	return _c
}

func (_c *MockQuerier_UpdateUser_Call) Return(_a0 *User, _a1 error) *MockQuerier_UpdateUser_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_UpdateUser_Call) RunAndReturn(run func(context.Context, UpdateUserParams) (*User, error)) *MockQuerier_UpdateUser_Call {
	_c.Call.Return(run)
	return _c
}

// UpsertReconciler provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) UpsertReconciler(ctx context.Context, arg UpsertReconcilerParams) (*Reconciler, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for UpsertReconciler")
	}

	var r0 *Reconciler
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, UpsertReconcilerParams) (*Reconciler, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, UpsertReconcilerParams) *Reconciler); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*Reconciler)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, UpsertReconcilerParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_UpsertReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertReconciler'
type MockQuerier_UpsertReconciler_Call struct {
	*mock.Call
}

// UpsertReconciler is a helper method to define mock.On call
//   - ctx context.Context
//   - arg UpsertReconcilerParams
func (_e *MockQuerier_Expecter) UpsertReconciler(ctx interface{}, arg interface{}) *MockQuerier_UpsertReconciler_Call {
	return &MockQuerier_UpsertReconciler_Call{Call: _e.mock.On("UpsertReconciler", ctx, arg)}
}

func (_c *MockQuerier_UpsertReconciler_Call) Run(run func(ctx context.Context, arg UpsertReconcilerParams)) *MockQuerier_UpsertReconciler_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(UpsertReconcilerParams))
	})
	return _c
}

func (_c *MockQuerier_UpsertReconciler_Call) Return(_a0 *Reconciler, _a1 error) *MockQuerier_UpsertReconciler_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_UpsertReconciler_Call) RunAndReturn(run func(context.Context, UpsertReconcilerParams) (*Reconciler, error)) *MockQuerier_UpsertReconciler_Call {
	_c.Call.Return(run)
	return _c
}

// UpsertReconcilerConfig provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) UpsertReconcilerConfig(ctx context.Context, arg UpsertReconcilerConfigParams) error {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for UpsertReconcilerConfig")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, UpsertReconcilerConfigParams) error); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockQuerier_UpsertReconcilerConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertReconcilerConfig'
type MockQuerier_UpsertReconcilerConfig_Call struct {
	*mock.Call
}

// UpsertReconcilerConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - arg UpsertReconcilerConfigParams
func (_e *MockQuerier_Expecter) UpsertReconcilerConfig(ctx interface{}, arg interface{}) *MockQuerier_UpsertReconcilerConfig_Call {
	return &MockQuerier_UpsertReconcilerConfig_Call{Call: _e.mock.On("UpsertReconcilerConfig", ctx, arg)}
}

func (_c *MockQuerier_UpsertReconcilerConfig_Call) Run(run func(ctx context.Context, arg UpsertReconcilerConfigParams)) *MockQuerier_UpsertReconcilerConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(UpsertReconcilerConfigParams))
	})
	return _c
}

func (_c *MockQuerier_UpsertReconcilerConfig_Call) Return(_a0 error) *MockQuerier_UpsertReconcilerConfig_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_UpsertReconcilerConfig_Call) RunAndReturn(run func(context.Context, UpsertReconcilerConfigParams) error) *MockQuerier_UpsertReconcilerConfig_Call {
	_c.Call.Return(run)
	return _c
}

// UpsertReconcilerState provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) UpsertReconcilerState(ctx context.Context, arg UpsertReconcilerStateParams) (*ReconcilerState, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for UpsertReconcilerState")
	}

	var r0 *ReconcilerState
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, UpsertReconcilerStateParams) (*ReconcilerState, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, UpsertReconcilerStateParams) *ReconcilerState); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ReconcilerState)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, UpsertReconcilerStateParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_UpsertReconcilerState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertReconcilerState'
type MockQuerier_UpsertReconcilerState_Call struct {
	*mock.Call
}

// UpsertReconcilerState is a helper method to define mock.On call
//   - ctx context.Context
//   - arg UpsertReconcilerStateParams
func (_e *MockQuerier_Expecter) UpsertReconcilerState(ctx interface{}, arg interface{}) *MockQuerier_UpsertReconcilerState_Call {
	return &MockQuerier_UpsertReconcilerState_Call{Call: _e.mock.On("UpsertReconcilerState", ctx, arg)}
}

func (_c *MockQuerier_UpsertReconcilerState_Call) Run(run func(ctx context.Context, arg UpsertReconcilerStateParams)) *MockQuerier_UpsertReconcilerState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(UpsertReconcilerStateParams))
	})
	return _c
}

func (_c *MockQuerier_UpsertReconcilerState_Call) Return(_a0 *ReconcilerState, _a1 error) *MockQuerier_UpsertReconcilerState_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_UpsertReconcilerState_Call) RunAndReturn(run func(context.Context, UpsertReconcilerStateParams) (*ReconcilerState, error)) *MockQuerier_UpsertReconcilerState_Call {
	_c.Call.Return(run)
	return _c
}

// UpsertTeamEnvironment provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) UpsertTeamEnvironment(ctx context.Context, arg UpsertTeamEnvironmentParams) (*TeamEnvironment, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for UpsertTeamEnvironment")
	}

	var r0 *TeamEnvironment
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, UpsertTeamEnvironmentParams) (*TeamEnvironment, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, UpsertTeamEnvironmentParams) *TeamEnvironment); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*TeamEnvironment)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, UpsertTeamEnvironmentParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_UpsertTeamEnvironment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertTeamEnvironment'
type MockQuerier_UpsertTeamEnvironment_Call struct {
	*mock.Call
}

// UpsertTeamEnvironment is a helper method to define mock.On call
//   - ctx context.Context
//   - arg UpsertTeamEnvironmentParams
func (_e *MockQuerier_Expecter) UpsertTeamEnvironment(ctx interface{}, arg interface{}) *MockQuerier_UpsertTeamEnvironment_Call {
	return &MockQuerier_UpsertTeamEnvironment_Call{Call: _e.mock.On("UpsertTeamEnvironment", ctx, arg)}
}

func (_c *MockQuerier_UpsertTeamEnvironment_Call) Run(run func(ctx context.Context, arg UpsertTeamEnvironmentParams)) *MockQuerier_UpsertTeamEnvironment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(UpsertTeamEnvironmentParams))
	})
	return _c
}

func (_c *MockQuerier_UpsertTeamEnvironment_Call) Return(_a0 *TeamEnvironment, _a1 error) *MockQuerier_UpsertTeamEnvironment_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_UpsertTeamEnvironment_Call) RunAndReturn(run func(context.Context, UpsertTeamEnvironmentParams) (*TeamEnvironment, error)) *MockQuerier_UpsertTeamEnvironment_Call {
	_c.Call.Return(run)
	return _c
}

// VulnerabilityMetricsDateRangeForTeam provides a mock function with given fields: ctx, teamSlug
func (_m *MockQuerier) VulnerabilityMetricsDateRangeForTeam(ctx context.Context, teamSlug slug.Slug) (*VulnerabilityMetricsDateRangeForTeamRow, error) {
	ret := _m.Called(ctx, teamSlug)

	if len(ret) == 0 {
		panic("no return value specified for VulnerabilityMetricsDateRangeForTeam")
	}

	var r0 *VulnerabilityMetricsDateRangeForTeamRow
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, slug.Slug) (*VulnerabilityMetricsDateRangeForTeamRow, error)); ok {
		return rf(ctx, teamSlug)
	}
	if rf, ok := ret.Get(0).(func(context.Context, slug.Slug) *VulnerabilityMetricsDateRangeForTeamRow); ok {
		r0 = rf(ctx, teamSlug)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*VulnerabilityMetricsDateRangeForTeamRow)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, slug.Slug) error); ok {
		r1 = rf(ctx, teamSlug)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VulnerabilityMetricsDateRangeForTeam'
type MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call struct {
	*mock.Call
}

// VulnerabilityMetricsDateRangeForTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - teamSlug slug.Slug
func (_e *MockQuerier_Expecter) VulnerabilityMetricsDateRangeForTeam(ctx interface{}, teamSlug interface{}) *MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call {
	return &MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call{Call: _e.mock.On("VulnerabilityMetricsDateRangeForTeam", ctx, teamSlug)}
}

func (_c *MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call) Run(run func(ctx context.Context, teamSlug slug.Slug)) *MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(slug.Slug))
	})
	return _c
}

func (_c *MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call) Return(_a0 *VulnerabilityMetricsDateRangeForTeamRow, _a1 error) *MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call) RunAndReturn(run func(context.Context, slug.Slug) (*VulnerabilityMetricsDateRangeForTeamRow, error)) *MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call {
	_c.Call.Return(run)
	return _c
}

// VulnerabilityMetricsMaxDate provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) VulnerabilityMetricsMaxDate(ctx context.Context, arg VulnerabilityMetricsMaxDateParams) (pgtype.Date, error) {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for VulnerabilityMetricsMaxDate")
	}

	var r0 pgtype.Date
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, VulnerabilityMetricsMaxDateParams) (pgtype.Date, error)); ok {
		return rf(ctx, arg)
	}
	if rf, ok := ret.Get(0).(func(context.Context, VulnerabilityMetricsMaxDateParams) pgtype.Date); ok {
		r0 = rf(ctx, arg)
	} else {
		r0 = ret.Get(0).(pgtype.Date)
	}

	if rf, ok := ret.Get(1).(func(context.Context, VulnerabilityMetricsMaxDateParams) error); ok {
		r1 = rf(ctx, arg)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockQuerier_VulnerabilityMetricsMaxDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VulnerabilityMetricsMaxDate'
type MockQuerier_VulnerabilityMetricsMaxDate_Call struct {
	*mock.Call
}

// VulnerabilityMetricsMaxDate is a helper method to define mock.On call
//   - ctx context.Context
//   - arg VulnerabilityMetricsMaxDateParams
func (_e *MockQuerier_Expecter) VulnerabilityMetricsMaxDate(ctx interface{}, arg interface{}) *MockQuerier_VulnerabilityMetricsMaxDate_Call {
	return &MockQuerier_VulnerabilityMetricsMaxDate_Call{Call: _e.mock.On("VulnerabilityMetricsMaxDate", ctx, arg)}
}

func (_c *MockQuerier_VulnerabilityMetricsMaxDate_Call) Run(run func(ctx context.Context, arg VulnerabilityMetricsMaxDateParams)) *MockQuerier_VulnerabilityMetricsMaxDate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(VulnerabilityMetricsMaxDateParams))
	})
	return _c
}

func (_c *MockQuerier_VulnerabilityMetricsMaxDate_Call) Return(_a0 pgtype.Date, _a1 error) *MockQuerier_VulnerabilityMetricsMaxDate_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerier_VulnerabilityMetricsMaxDate_Call) RunAndReturn(run func(context.Context, VulnerabilityMetricsMaxDateParams) (pgtype.Date, error)) *MockQuerier_VulnerabilityMetricsMaxDate_Call {
	_c.Call.Return(run)
	return _c
}

// VulnerabilityMetricsUpsert provides a mock function with given fields: ctx, arg
func (_m *MockQuerier) VulnerabilityMetricsUpsert(ctx context.Context, arg []VulnerabilityMetricsUpsertParams) *VulnerabilityMetricsUpsertBatchResults {
	ret := _m.Called(ctx, arg)

	if len(ret) == 0 {
		panic("no return value specified for VulnerabilityMetricsUpsert")
	}

	var r0 *VulnerabilityMetricsUpsertBatchResults
	if rf, ok := ret.Get(0).(func(context.Context, []VulnerabilityMetricsUpsertParams) *VulnerabilityMetricsUpsertBatchResults); ok {
		r0 = rf(ctx, arg)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*VulnerabilityMetricsUpsertBatchResults)
		}
	}

	return r0
}

// MockQuerier_VulnerabilityMetricsUpsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VulnerabilityMetricsUpsert'
type MockQuerier_VulnerabilityMetricsUpsert_Call struct {
	*mock.Call
}

// VulnerabilityMetricsUpsert is a helper method to define mock.On call
//   - ctx context.Context
//   - arg []VulnerabilityMetricsUpsertParams
func (_e *MockQuerier_Expecter) VulnerabilityMetricsUpsert(ctx interface{}, arg interface{}) *MockQuerier_VulnerabilityMetricsUpsert_Call {
	return &MockQuerier_VulnerabilityMetricsUpsert_Call{Call: _e.mock.On("VulnerabilityMetricsUpsert", ctx, arg)}
}

func (_c *MockQuerier_VulnerabilityMetricsUpsert_Call) Run(run func(ctx context.Context, arg []VulnerabilityMetricsUpsertParams)) *MockQuerier_VulnerabilityMetricsUpsert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]VulnerabilityMetricsUpsertParams))
	})
	return _c
}

func (_c *MockQuerier_VulnerabilityMetricsUpsert_Call) Return(_a0 *VulnerabilityMetricsUpsertBatchResults) *MockQuerier_VulnerabilityMetricsUpsert_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockQuerier_VulnerabilityMetricsUpsert_Call) RunAndReturn(run func(context.Context, []VulnerabilityMetricsUpsertParams) *VulnerabilityMetricsUpsertBatchResults) *MockQuerier_VulnerabilityMetricsUpsert_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockQuerier creates a new instance of MockQuerier. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockQuerier(t interface {
	mock.TestingT
	Cleanup(func())
},
) *MockQuerier {
	mock := &MockQuerier{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}