// Code generated by http://github.com/gojuno/minimock (v3.4.7). DO NOT EDIT.

package mocks

//go:generate minimock -i git.techease.ru/Smart-search/smart-search-back/internal/repository.UserRepository -o user_repository_mock.go -n UserRepositoryMock -p mocks

import (
	"context"
	"sync"
	mm_atomic "sync/atomic"
	mm_time "time"

	"git.techease.ru/Smart-search/smart-search-back/internal/model"
	"github.com/gojuno/minimock/v3"
	"github.com/jackc/pgx/v5"
)

// UserRepositoryMock implements mm_repository.UserRepository
type UserRepositoryMock struct {
	t          minimock.Tester
	finishOnce sync.Once

	funcCheckInviteLimit          func(ctx context.Context, userID int) (b1 bool, err error)
	funcCheckInviteLimitOrigin    string
	inspectFuncCheckInviteLimit   func(ctx context.Context, userID int)
	afterCheckInviteLimitCounter  uint64
	beforeCheckInviteLimitCounter uint64
	CheckInviteLimitMock          mUserRepositoryMockCheckInviteLimit

	funcCheckInviteLimitTx          func(ctx context.Context, tx pgx.Tx, userID int) (b1 bool, err error)
	funcCheckInviteLimitTxOrigin    string
	inspectFuncCheckInviteLimitTx   func(ctx context.Context, tx pgx.Tx, userID int)
	afterCheckInviteLimitTxCounter  uint64
	beforeCheckInviteLimitTxCounter uint64
	CheckInviteLimitTxMock          mUserRepositoryMockCheckInviteLimitTx

	funcCreate          func(ctx context.Context, user *model.User) (err error)
	funcCreateOrigin    string
	inspectFuncCreate   func(ctx context.Context, user *model.User)
	afterCreateCounter  uint64
	beforeCreateCounter uint64
	CreateMock          mUserRepositoryMockCreate

	funcCreateTx          func(ctx context.Context, tx pgx.Tx, user *model.User) (err error)
	funcCreateTxOrigin    string
	inspectFuncCreateTx   func(ctx context.Context, tx pgx.Tx, user *model.User)
	afterCreateTxCounter  uint64
	beforeCreateTxCounter uint64
	CreateTxMock          mUserRepositoryMockCreateTx

	funcFindByEmailHash          func(ctx context.Context, emailHash string) (up1 *model.User, err error)
	funcFindByEmailHashOrigin    string
	inspectFuncFindByEmailHash   func(ctx context.Context, emailHash string)
	afterFindByEmailHashCounter  uint64
	beforeFindByEmailHashCounter uint64
	FindByEmailHashMock          mUserRepositoryMockFindByEmailHash

	funcFindByID          func(ctx context.Context, userID int) (up1 *model.User, err error)
	funcFindByIDOrigin    string
	inspectFuncFindByID   func(ctx context.Context, userID int)
	afterFindByIDCounter  uint64
	beforeFindByIDCounter uint64
	FindByIDMock          mUserRepositoryMockFindByID

	funcGetBalance          func(ctx context.Context, userID int) (f1 float64, err error)
	funcGetBalanceOrigin    string
	inspectFuncGetBalance   func(ctx context.Context, userID int)
	afterGetBalanceCounter  uint64
	beforeGetBalanceCounter uint64
	GetBalanceMock          mUserRepositoryMockGetBalance

	funcIncrementInvitesIssued          func(ctx context.Context, userID int) (err error)
	funcIncrementInvitesIssuedOrigin    string
	inspectFuncIncrementInvitesIssued   func(ctx context.Context, userID int)
	afterIncrementInvitesIssuedCounter  uint64
	beforeIncrementInvitesIssuedCounter uint64
	IncrementInvitesIssuedMock          mUserRepositoryMockIncrementInvitesIssued

	funcIncrementInvitesIssuedTx          func(ctx context.Context, tx pgx.Tx, userID int) (err error)
	funcIncrementInvitesIssuedTxOrigin    string
	inspectFuncIncrementInvitesIssuedTx   func(ctx context.Context, tx pgx.Tx, userID int)
	afterIncrementInvitesIssuedTxCounter  uint64
	beforeIncrementInvitesIssuedTxCounter uint64
	IncrementInvitesIssuedTxMock          mUserRepositoryMockIncrementInvitesIssuedTx

	funcUpdateBalance          func(ctx context.Context, userID int, delta float64) (err error)
	funcUpdateBalanceOrigin    string
	inspectFuncUpdateBalance   func(ctx context.Context, userID int, delta float64)
	afterUpdateBalanceCounter  uint64
	beforeUpdateBalanceCounter uint64
	UpdateBalanceMock          mUserRepositoryMockUpdateBalance

	funcUpdateBalanceTx          func(ctx context.Context, tx pgx.Tx, userID int, delta float64) (err error)
	funcUpdateBalanceTxOrigin    string
	inspectFuncUpdateBalanceTx   func(ctx context.Context, tx pgx.Tx, userID int, delta float64)
	afterUpdateBalanceTxCounter  uint64
	beforeUpdateBalanceTxCounter uint64
	UpdateBalanceTxMock          mUserRepositoryMockUpdateBalanceTx
}

// NewUserRepositoryMock returns a mock for mm_repository.UserRepository
func NewUserRepositoryMock(t minimock.Tester) *UserRepositoryMock {
	m := &UserRepositoryMock{t: t}

	if controller, ok := t.(minimock.MockController); ok {
		controller.RegisterMocker(m)
	}

	m.CheckInviteLimitMock = mUserRepositoryMockCheckInviteLimit{mock: m}
	m.CheckInviteLimitMock.callArgs = []*UserRepositoryMockCheckInviteLimitParams{}

	m.CheckInviteLimitTxMock = mUserRepositoryMockCheckInviteLimitTx{mock: m}
	m.CheckInviteLimitTxMock.callArgs = []*UserRepositoryMockCheckInviteLimitTxParams{}

	m.CreateMock = mUserRepositoryMockCreate{mock: m}
	m.CreateMock.callArgs = []*UserRepositoryMockCreateParams{}

	m.CreateTxMock = mUserRepositoryMockCreateTx{mock: m}
	m.CreateTxMock.callArgs = []*UserRepositoryMockCreateTxParams{}

	m.FindByEmailHashMock = mUserRepositoryMockFindByEmailHash{mock: m}
	m.FindByEmailHashMock.callArgs = []*UserRepositoryMockFindByEmailHashParams{}

	m.FindByIDMock = mUserRepositoryMockFindByID{mock: m}
	m.FindByIDMock.callArgs = []*UserRepositoryMockFindByIDParams{}

	m.GetBalanceMock = mUserRepositoryMockGetBalance{mock: m}
	m.GetBalanceMock.callArgs = []*UserRepositoryMockGetBalanceParams{}

	m.IncrementInvitesIssuedMock = mUserRepositoryMockIncrementInvitesIssued{mock: m}
	m.IncrementInvitesIssuedMock.callArgs = []*UserRepositoryMockIncrementInvitesIssuedParams{}

	m.IncrementInvitesIssuedTxMock = mUserRepositoryMockIncrementInvitesIssuedTx{mock: m}
	m.IncrementInvitesIssuedTxMock.callArgs = []*UserRepositoryMockIncrementInvitesIssuedTxParams{}

	m.UpdateBalanceMock = mUserRepositoryMockUpdateBalance{mock: m}
	m.UpdateBalanceMock.callArgs = []*UserRepositoryMockUpdateBalanceParams{}

	m.UpdateBalanceTxMock = mUserRepositoryMockUpdateBalanceTx{mock: m}
	m.UpdateBalanceTxMock.callArgs = []*UserRepositoryMockUpdateBalanceTxParams{}

	t.Cleanup(m.MinimockFinish)

	return m
}

type mUserRepositoryMockCheckInviteLimit struct {
	optional           bool
	mock               *UserRepositoryMock
	defaultExpectation *UserRepositoryMockCheckInviteLimitExpectation
	expectations       []*UserRepositoryMockCheckInviteLimitExpectation

	callArgs []*UserRepositoryMockCheckInviteLimitParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// UserRepositoryMockCheckInviteLimitExpectation specifies expectation struct of the UserRepository.CheckInviteLimit
type UserRepositoryMockCheckInviteLimitExpectation struct {
	mock               *UserRepositoryMock
	params             *UserRepositoryMockCheckInviteLimitParams
	paramPtrs          *UserRepositoryMockCheckInviteLimitParamPtrs
	expectationOrigins UserRepositoryMockCheckInviteLimitExpectationOrigins
	results            *UserRepositoryMockCheckInviteLimitResults
	returnOrigin       string
	Counter            uint64
}

// UserRepositoryMockCheckInviteLimitParams contains parameters of the UserRepository.CheckInviteLimit
type UserRepositoryMockCheckInviteLimitParams struct {
	ctx    context.Context
	userID int
}

// UserRepositoryMockCheckInviteLimitParamPtrs contains pointers to parameters of the UserRepository.CheckInviteLimit
type UserRepositoryMockCheckInviteLimitParamPtrs struct {
	ctx    *context.Context
	userID *int
}

// UserRepositoryMockCheckInviteLimitResults contains results of the UserRepository.CheckInviteLimit
type UserRepositoryMockCheckInviteLimitResults struct {
	b1  bool
	err error
}

// UserRepositoryMockCheckInviteLimitOrigins contains origins of expectations of the UserRepository.CheckInviteLimit
type UserRepositoryMockCheckInviteLimitExpectationOrigins struct {
	origin       string
	originCtx    string
	originUserID string
}

// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
// Optional() makes method check to work in '0 or more' mode.
// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
// catch the problems when the expected method call is totally skipped during test run.
func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) Optional() *mUserRepositoryMockCheckInviteLimit {
	mmCheckInviteLimit.optional = true
	return mmCheckInviteLimit
}

// Expect sets up expected params for UserRepository.CheckInviteLimit
func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) Expect(ctx context.Context, userID int) *mUserRepositoryMockCheckInviteLimit {
	if mmCheckInviteLimit.mock.funcCheckInviteLimit != nil {
		mmCheckInviteLimit.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimit mock is already set by Set")
	}

	if mmCheckInviteLimit.defaultExpectation == nil {
		mmCheckInviteLimit.defaultExpectation = &UserRepositoryMockCheckInviteLimitExpectation{}
	}

	if mmCheckInviteLimit.defaultExpectation.paramPtrs != nil {
		mmCheckInviteLimit.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimit mock is already set by ExpectParams functions")
	}

	mmCheckInviteLimit.defaultExpectation.params = &UserRepositoryMockCheckInviteLimitParams{ctx, userID}
	mmCheckInviteLimit.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmCheckInviteLimit.expectations {
		if minimock.Equal(e.params, mmCheckInviteLimit.defaultExpectation.params) {
			mmCheckInviteLimit.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCheckInviteLimit.defaultExpectation.params)
		}
	}

	return mmCheckInviteLimit
}

// ExpectCtxParam1 sets up expected param ctx for UserRepository.CheckInviteLimit
func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockCheckInviteLimit {
	if mmCheckInviteLimit.mock.funcCheckInviteLimit != nil {
		mmCheckInviteLimit.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimit mock is already set by Set")
	}

	if mmCheckInviteLimit.defaultExpectation == nil {
		mmCheckInviteLimit.defaultExpectation = &UserRepositoryMockCheckInviteLimitExpectation{}
	}

	if mmCheckInviteLimit.defaultExpectation.params != nil {
		mmCheckInviteLimit.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimit mock is already set by Expect")
	}

	if mmCheckInviteLimit.defaultExpectation.paramPtrs == nil {
		mmCheckInviteLimit.defaultExpectation.paramPtrs = &UserRepositoryMockCheckInviteLimitParamPtrs{}
	}
	mmCheckInviteLimit.defaultExpectation.paramPtrs.ctx = &ctx
	mmCheckInviteLimit.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmCheckInviteLimit
}

// ExpectUserIDParam2 sets up expected param userID for UserRepository.CheckInviteLimit
func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) ExpectUserIDParam2(userID int) *mUserRepositoryMockCheckInviteLimit {
	if mmCheckInviteLimit.mock.funcCheckInviteLimit != nil {
		mmCheckInviteLimit.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimit mock is already set by Set")
	}

	if mmCheckInviteLimit.defaultExpectation == nil {
		mmCheckInviteLimit.defaultExpectation = &UserRepositoryMockCheckInviteLimitExpectation{}
	}

	if mmCheckInviteLimit.defaultExpectation.params != nil {
		mmCheckInviteLimit.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimit mock is already set by Expect")
	}

	if mmCheckInviteLimit.defaultExpectation.paramPtrs == nil {
		mmCheckInviteLimit.defaultExpectation.paramPtrs = &UserRepositoryMockCheckInviteLimitParamPtrs{}
	}
	mmCheckInviteLimit.defaultExpectation.paramPtrs.userID = &userID
	mmCheckInviteLimit.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)

	return mmCheckInviteLimit
}

// Inspect accepts an inspector function that has same arguments as the UserRepository.CheckInviteLimit
func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) Inspect(f func(ctx context.Context, userID int)) *mUserRepositoryMockCheckInviteLimit {
	if mmCheckInviteLimit.mock.inspectFuncCheckInviteLimit != nil {
		mmCheckInviteLimit.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.CheckInviteLimit")
	}

	mmCheckInviteLimit.mock.inspectFuncCheckInviteLimit = f

	return mmCheckInviteLimit
}

// Return sets up results that will be returned by UserRepository.CheckInviteLimit
func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) Return(b1 bool, err error) *UserRepositoryMock {
	if mmCheckInviteLimit.mock.funcCheckInviteLimit != nil {
		mmCheckInviteLimit.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimit mock is already set by Set")
	}

	if mmCheckInviteLimit.defaultExpectation == nil {
		mmCheckInviteLimit.defaultExpectation = &UserRepositoryMockCheckInviteLimitExpectation{mock: mmCheckInviteLimit.mock}
	}
	mmCheckInviteLimit.defaultExpectation.results = &UserRepositoryMockCheckInviteLimitResults{b1, err}
	mmCheckInviteLimit.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmCheckInviteLimit.mock
}

// Set uses given function f to mock the UserRepository.CheckInviteLimit method
func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) Set(f func(ctx context.Context, userID int) (b1 bool, err error)) *UserRepositoryMock {
	if mmCheckInviteLimit.defaultExpectation != nil {
		mmCheckInviteLimit.mock.t.Fatalf("Default expectation is already set for the UserRepository.CheckInviteLimit method")
	}

	if len(mmCheckInviteLimit.expectations) > 0 {
		mmCheckInviteLimit.mock.t.Fatalf("Some expectations are already set for the UserRepository.CheckInviteLimit method")
	}

	mmCheckInviteLimit.mock.funcCheckInviteLimit = f
	mmCheckInviteLimit.mock.funcCheckInviteLimitOrigin = minimock.CallerInfo(1)
	return mmCheckInviteLimit.mock
}

// When sets expectation for the UserRepository.CheckInviteLimit which will trigger the result defined by the following
// Then helper
func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) When(ctx context.Context, userID int) *UserRepositoryMockCheckInviteLimitExpectation {
	if mmCheckInviteLimit.mock.funcCheckInviteLimit != nil {
		mmCheckInviteLimit.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimit mock is already set by Set")
	}

	expectation := &UserRepositoryMockCheckInviteLimitExpectation{
		mock:               mmCheckInviteLimit.mock,
		params:             &UserRepositoryMockCheckInviteLimitParams{ctx, userID},
		expectationOrigins: UserRepositoryMockCheckInviteLimitExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmCheckInviteLimit.expectations = append(mmCheckInviteLimit.expectations, expectation)
	return expectation
}

// Then sets up UserRepository.CheckInviteLimit return parameters for the expectation previously defined by the When method
func (e *UserRepositoryMockCheckInviteLimitExpectation) Then(b1 bool, err error) *UserRepositoryMock {
	e.results = &UserRepositoryMockCheckInviteLimitResults{b1, err}
	return e.mock
}

// Times sets number of times UserRepository.CheckInviteLimit should be invoked
func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) Times(n uint64) *mUserRepositoryMockCheckInviteLimit {
	if n == 0 {
		mmCheckInviteLimit.mock.t.Fatalf("Times of UserRepositoryMock.CheckInviteLimit mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmCheckInviteLimit.expectedInvocations, n)
	mmCheckInviteLimit.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmCheckInviteLimit
}

func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) invocationsDone() bool {
	if len(mmCheckInviteLimit.expectations) == 0 && mmCheckInviteLimit.defaultExpectation == nil && mmCheckInviteLimit.mock.funcCheckInviteLimit == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmCheckInviteLimit.mock.afterCheckInviteLimitCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmCheckInviteLimit.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// CheckInviteLimit implements mm_repository.UserRepository
func (mmCheckInviteLimit *UserRepositoryMock) CheckInviteLimit(ctx context.Context, userID int) (b1 bool, err error) {
	mm_atomic.AddUint64(&mmCheckInviteLimit.beforeCheckInviteLimitCounter, 1)
	defer mm_atomic.AddUint64(&mmCheckInviteLimit.afterCheckInviteLimitCounter, 1)

	mmCheckInviteLimit.t.Helper()

	if mmCheckInviteLimit.inspectFuncCheckInviteLimit != nil {
		mmCheckInviteLimit.inspectFuncCheckInviteLimit(ctx, userID)
	}

	mm_params := UserRepositoryMockCheckInviteLimitParams{ctx, userID}

	// Record call args
	mmCheckInviteLimit.CheckInviteLimitMock.mutex.Lock()
	mmCheckInviteLimit.CheckInviteLimitMock.callArgs = append(mmCheckInviteLimit.CheckInviteLimitMock.callArgs, &mm_params)
	mmCheckInviteLimit.CheckInviteLimitMock.mutex.Unlock()

	for _, e := range mmCheckInviteLimit.CheckInviteLimitMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.b1, e.results.err
		}
	}

	if mmCheckInviteLimit.CheckInviteLimitMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmCheckInviteLimit.CheckInviteLimitMock.defaultExpectation.Counter, 1)
		mm_want := mmCheckInviteLimit.CheckInviteLimitMock.defaultExpectation.params
		mm_want_ptrs := mmCheckInviteLimit.CheckInviteLimitMock.defaultExpectation.paramPtrs

		mm_got := UserRepositoryMockCheckInviteLimitParams{ctx, userID}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmCheckInviteLimit.t.Errorf("UserRepositoryMock.CheckInviteLimit got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmCheckInviteLimit.CheckInviteLimitMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
			}

			if mm_want_ptrs.userID != nil && !minimock.Equal(*mm_want_ptrs.userID, mm_got.userID) {
				mmCheckInviteLimit.t.Errorf("UserRepositoryMock.CheckInviteLimit got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmCheckInviteLimit.CheckInviteLimitMock.defaultExpectation.expectationOrigins.originUserID, *mm_want_ptrs.userID, mm_got.userID, minimock.Diff(*mm_want_ptrs.userID, mm_got.userID))
			}

		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmCheckInviteLimit.t.Errorf("UserRepositoryMock.CheckInviteLimit got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmCheckInviteLimit.CheckInviteLimitMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmCheckInviteLimit.CheckInviteLimitMock.defaultExpectation.results
		if mm_results == nil {
			mmCheckInviteLimit.t.Fatal("No results are set for the UserRepositoryMock.CheckInviteLimit")
		}
		return (*mm_results).b1, (*mm_results).err
	}
	if mmCheckInviteLimit.funcCheckInviteLimit != nil {
		return mmCheckInviteLimit.funcCheckInviteLimit(ctx, userID)
	}
	mmCheckInviteLimit.t.Fatalf("Unexpected call to UserRepositoryMock.CheckInviteLimit. %v %v", ctx, userID)
	return
}

// CheckInviteLimitAfterCounter returns a count of finished UserRepositoryMock.CheckInviteLimit invocations
func (mmCheckInviteLimit *UserRepositoryMock) CheckInviteLimitAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmCheckInviteLimit.afterCheckInviteLimitCounter)
}

// CheckInviteLimitBeforeCounter returns a count of UserRepositoryMock.CheckInviteLimit invocations
func (mmCheckInviteLimit *UserRepositoryMock) CheckInviteLimitBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmCheckInviteLimit.beforeCheckInviteLimitCounter)
}

// Calls returns a list of arguments used in each call to UserRepositoryMock.CheckInviteLimit.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) Calls() []*UserRepositoryMockCheckInviteLimitParams {
	mmCheckInviteLimit.mutex.RLock()

	argCopy := make([]*UserRepositoryMockCheckInviteLimitParams, len(mmCheckInviteLimit.callArgs))
	copy(argCopy, mmCheckInviteLimit.callArgs)

	mmCheckInviteLimit.mutex.RUnlock()

	return argCopy
}

// MinimockCheckInviteLimitDone returns true if the count of the CheckInviteLimit invocations corresponds
// the number of defined expectations
func (m *UserRepositoryMock) MinimockCheckInviteLimitDone() bool {
	if m.CheckInviteLimitMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.CheckInviteLimitMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.CheckInviteLimitMock.invocationsDone()
}

// MinimockCheckInviteLimitInspect logs each unmet expectation
func (m *UserRepositoryMock) MinimockCheckInviteLimitInspect() {
	for _, e := range m.CheckInviteLimitMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to UserRepositoryMock.CheckInviteLimit at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterCheckInviteLimitCounter := mm_atomic.LoadUint64(&m.afterCheckInviteLimitCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.CheckInviteLimitMock.defaultExpectation != nil && afterCheckInviteLimitCounter < 1 {
		if m.CheckInviteLimitMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to UserRepositoryMock.CheckInviteLimit at\n%s", m.CheckInviteLimitMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to UserRepositoryMock.CheckInviteLimit at\n%s with params: %#v", m.CheckInviteLimitMock.defaultExpectation.expectationOrigins.origin, *m.CheckInviteLimitMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcCheckInviteLimit != nil && afterCheckInviteLimitCounter < 1 {
		m.t.Errorf("Expected call to UserRepositoryMock.CheckInviteLimit at\n%s", m.funcCheckInviteLimitOrigin)
	}

	if !m.CheckInviteLimitMock.invocationsDone() && afterCheckInviteLimitCounter > 0 {
		m.t.Errorf("Expected %d calls to UserRepositoryMock.CheckInviteLimit at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.CheckInviteLimitMock.expectedInvocations), m.CheckInviteLimitMock.expectedInvocationsOrigin, afterCheckInviteLimitCounter)
	}
}

type mUserRepositoryMockCheckInviteLimitTx struct {
	optional           bool
	mock               *UserRepositoryMock
	defaultExpectation *UserRepositoryMockCheckInviteLimitTxExpectation
	expectations       []*UserRepositoryMockCheckInviteLimitTxExpectation

	callArgs []*UserRepositoryMockCheckInviteLimitTxParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// UserRepositoryMockCheckInviteLimitTxExpectation specifies expectation struct of the UserRepository.CheckInviteLimitTx
type UserRepositoryMockCheckInviteLimitTxExpectation struct {
	mock               *UserRepositoryMock
	params             *UserRepositoryMockCheckInviteLimitTxParams
	paramPtrs          *UserRepositoryMockCheckInviteLimitTxParamPtrs
	expectationOrigins UserRepositoryMockCheckInviteLimitTxExpectationOrigins
	results            *UserRepositoryMockCheckInviteLimitTxResults
	returnOrigin       string
	Counter            uint64
}

// UserRepositoryMockCheckInviteLimitTxParams contains parameters of the UserRepository.CheckInviteLimitTx
type UserRepositoryMockCheckInviteLimitTxParams struct {
	ctx    context.Context
	tx     pgx.Tx
	userID int
}

// UserRepositoryMockCheckInviteLimitTxParamPtrs contains pointers to parameters of the UserRepository.CheckInviteLimitTx
type UserRepositoryMockCheckInviteLimitTxParamPtrs struct {
	ctx    *context.Context
	tx     *pgx.Tx
	userID *int
}

// UserRepositoryMockCheckInviteLimitTxResults contains results of the UserRepository.CheckInviteLimitTx
type UserRepositoryMockCheckInviteLimitTxResults struct {
	b1  bool
	err error
}

// UserRepositoryMockCheckInviteLimitTxOrigins contains origins of expectations of the UserRepository.CheckInviteLimitTx
type UserRepositoryMockCheckInviteLimitTxExpectationOrigins struct {
	origin       string
	originCtx    string
	originTx     string
	originUserID string
}

// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
// Optional() makes method check to work in '0 or more' mode.
// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
// catch the problems when the expected method call is totally skipped during test run.
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) Optional() *mUserRepositoryMockCheckInviteLimitTx {
	mmCheckInviteLimitTx.optional = true
	return mmCheckInviteLimitTx
}

// Expect sets up expected params for UserRepository.CheckInviteLimitTx
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) Expect(ctx context.Context, tx pgx.Tx, userID int) *mUserRepositoryMockCheckInviteLimitTx {
	if mmCheckInviteLimitTx.mock.funcCheckInviteLimitTx != nil {
		mmCheckInviteLimitTx.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimitTx mock is already set by Set")
	}

	if mmCheckInviteLimitTx.defaultExpectation == nil {
		mmCheckInviteLimitTx.defaultExpectation = &UserRepositoryMockCheckInviteLimitTxExpectation{}
	}

	if mmCheckInviteLimitTx.defaultExpectation.paramPtrs != nil {
		mmCheckInviteLimitTx.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimitTx mock is already set by ExpectParams functions")
	}

	mmCheckInviteLimitTx.defaultExpectation.params = &UserRepositoryMockCheckInviteLimitTxParams{ctx, tx, userID}
	mmCheckInviteLimitTx.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmCheckInviteLimitTx.expectations {
		if minimock.Equal(e.params, mmCheckInviteLimitTx.defaultExpectation.params) {
			mmCheckInviteLimitTx.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCheckInviteLimitTx.defaultExpectation.params)
		}
	}

	return mmCheckInviteLimitTx
}

// ExpectCtxParam1 sets up expected param ctx for UserRepository.CheckInviteLimitTx
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockCheckInviteLimitTx {
	if mmCheckInviteLimitTx.mock.funcCheckInviteLimitTx != nil {
		mmCheckInviteLimitTx.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimitTx mock is already set by Set")
	}

	if mmCheckInviteLimitTx.defaultExpectation == nil {
		mmCheckInviteLimitTx.defaultExpectation = &UserRepositoryMockCheckInviteLimitTxExpectation{}
	}

	if mmCheckInviteLimitTx.defaultExpectation.params != nil {
		mmCheckInviteLimitTx.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimitTx mock is already set by Expect")
	}

	if mmCheckInviteLimitTx.defaultExpectation.paramPtrs == nil {
		mmCheckInviteLimitTx.defaultExpectation.paramPtrs = &UserRepositoryMockCheckInviteLimitTxParamPtrs{}
	}
	mmCheckInviteLimitTx.defaultExpectation.paramPtrs.ctx = &ctx
	mmCheckInviteLimitTx.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmCheckInviteLimitTx
}

// ExpectTxParam2 sets up expected param tx for UserRepository.CheckInviteLimitTx
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) ExpectTxParam2(tx pgx.Tx) *mUserRepositoryMockCheckInviteLimitTx {
	if mmCheckInviteLimitTx.mock.funcCheckInviteLimitTx != nil {
		mmCheckInviteLimitTx.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimitTx mock is already set by Set")
	}

	if mmCheckInviteLimitTx.defaultExpectation == nil {
		mmCheckInviteLimitTx.defaultExpectation = &UserRepositoryMockCheckInviteLimitTxExpectation{}
	}

	if mmCheckInviteLimitTx.defaultExpectation.params != nil {
		mmCheckInviteLimitTx.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimitTx mock is already set by Expect")
	}

	if mmCheckInviteLimitTx.defaultExpectation.paramPtrs == nil {
		mmCheckInviteLimitTx.defaultExpectation.paramPtrs = &UserRepositoryMockCheckInviteLimitTxParamPtrs{}
	}
	mmCheckInviteLimitTx.defaultExpectation.paramPtrs.tx = &tx
	mmCheckInviteLimitTx.defaultExpectation.expectationOrigins.originTx = minimock.CallerInfo(1)

	return mmCheckInviteLimitTx
}

// ExpectUserIDParam3 sets up expected param userID for UserRepository.CheckInviteLimitTx
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) ExpectUserIDParam3(userID int) *mUserRepositoryMockCheckInviteLimitTx {
	if mmCheckInviteLimitTx.mock.funcCheckInviteLimitTx != nil {
		mmCheckInviteLimitTx.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimitTx mock is already set by Set")
	}

	if mmCheckInviteLimitTx.defaultExpectation == nil {
		mmCheckInviteLimitTx.defaultExpectation = &UserRepositoryMockCheckInviteLimitTxExpectation{}
	}

	if mmCheckInviteLimitTx.defaultExpectation.params != nil {
		mmCheckInviteLimitTx.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimitTx mock is already set by Expect")
	}

	if mmCheckInviteLimitTx.defaultExpectation.paramPtrs == nil {
		mmCheckInviteLimitTx.defaultExpectation.paramPtrs = &UserRepositoryMockCheckInviteLimitTxParamPtrs{}
	}
	mmCheckInviteLimitTx.defaultExpectation.paramPtrs.userID = &userID
	mmCheckInviteLimitTx.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)

	return mmCheckInviteLimitTx
}

// Inspect accepts an inspector function that has same arguments as the UserRepository.CheckInviteLimitTx
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) Inspect(f func(ctx context.Context, tx pgx.Tx, userID int)) *mUserRepositoryMockCheckInviteLimitTx {
	if mmCheckInviteLimitTx.mock.inspectFuncCheckInviteLimitTx != nil {
		mmCheckInviteLimitTx.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.CheckInviteLimitTx")
	}

	mmCheckInviteLimitTx.mock.inspectFuncCheckInviteLimitTx = f

	return mmCheckInviteLimitTx
}

// Return sets up results that will be returned by UserRepository.CheckInviteLimitTx
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) Return(b1 bool, err error) *UserRepositoryMock {
	if mmCheckInviteLimitTx.mock.funcCheckInviteLimitTx != nil {
		mmCheckInviteLimitTx.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimitTx mock is already set by Set")
	}

	if mmCheckInviteLimitTx.defaultExpectation == nil {
		mmCheckInviteLimitTx.defaultExpectation = &UserRepositoryMockCheckInviteLimitTxExpectation{mock: mmCheckInviteLimitTx.mock}
	}
	mmCheckInviteLimitTx.defaultExpectation.results = &UserRepositoryMockCheckInviteLimitTxResults{b1, err}
	mmCheckInviteLimitTx.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmCheckInviteLimitTx.mock
}

// Set uses given function f to mock the UserRepository.CheckInviteLimitTx method
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) Set(f func(ctx context.Context, tx pgx.Tx, userID int) (b1 bool, err error)) *UserRepositoryMock {
	if mmCheckInviteLimitTx.defaultExpectation != nil {
		mmCheckInviteLimitTx.mock.t.Fatalf("Default expectation is already set for the UserRepository.CheckInviteLimitTx method")
	}

	if len(mmCheckInviteLimitTx.expectations) > 0 {
		mmCheckInviteLimitTx.mock.t.Fatalf("Some expectations are already set for the UserRepository.CheckInviteLimitTx method")
	}

	mmCheckInviteLimitTx.mock.funcCheckInviteLimitTx = f
	mmCheckInviteLimitTx.mock.funcCheckInviteLimitTxOrigin = minimock.CallerInfo(1)
	return mmCheckInviteLimitTx.mock
}

// When sets expectation for the UserRepository.CheckInviteLimitTx which will trigger the result defined by the following
// Then helper
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) When(ctx context.Context, tx pgx.Tx, userID int) *UserRepositoryMockCheckInviteLimitTxExpectation {
	if mmCheckInviteLimitTx.mock.funcCheckInviteLimitTx != nil {
		mmCheckInviteLimitTx.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimitTx mock is already set by Set")
	}

	expectation := &UserRepositoryMockCheckInviteLimitTxExpectation{
		mock:               mmCheckInviteLimitTx.mock,
		params:             &UserRepositoryMockCheckInviteLimitTxParams{ctx, tx, userID},
		expectationOrigins: UserRepositoryMockCheckInviteLimitTxExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmCheckInviteLimitTx.expectations = append(mmCheckInviteLimitTx.expectations, expectation)
	return expectation
}

// Then sets up UserRepository.CheckInviteLimitTx return parameters for the expectation previously defined by the When method
func (e *UserRepositoryMockCheckInviteLimitTxExpectation) Then(b1 bool, err error) *UserRepositoryMock {
	e.results = &UserRepositoryMockCheckInviteLimitTxResults{b1, err}
	return e.mock
}

// Times sets number of times UserRepository.CheckInviteLimitTx should be invoked
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) Times(n uint64) *mUserRepositoryMockCheckInviteLimitTx {
	if n == 0 {
		mmCheckInviteLimitTx.mock.t.Fatalf("Times of UserRepositoryMock.CheckInviteLimitTx mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmCheckInviteLimitTx.expectedInvocations, n)
	mmCheckInviteLimitTx.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmCheckInviteLimitTx
}

func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) invocationsDone() bool {
	if len(mmCheckInviteLimitTx.expectations) == 0 && mmCheckInviteLimitTx.defaultExpectation == nil && mmCheckInviteLimitTx.mock.funcCheckInviteLimitTx == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmCheckInviteLimitTx.mock.afterCheckInviteLimitTxCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmCheckInviteLimitTx.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// CheckInviteLimitTx implements mm_repository.UserRepository
func (mmCheckInviteLimitTx *UserRepositoryMock) CheckInviteLimitTx(ctx context.Context, tx pgx.Tx, userID int) (b1 bool, err error) {
	mm_atomic.AddUint64(&mmCheckInviteLimitTx.beforeCheckInviteLimitTxCounter, 1)
	defer mm_atomic.AddUint64(&mmCheckInviteLimitTx.afterCheckInviteLimitTxCounter, 1)

	mmCheckInviteLimitTx.t.Helper()

	if mmCheckInviteLimitTx.inspectFuncCheckInviteLimitTx != nil {
		mmCheckInviteLimitTx.inspectFuncCheckInviteLimitTx(ctx, tx, userID)
	}

	mm_params := UserRepositoryMockCheckInviteLimitTxParams{ctx, tx, userID}

	// Record call args
	mmCheckInviteLimitTx.CheckInviteLimitTxMock.mutex.Lock()
	mmCheckInviteLimitTx.CheckInviteLimitTxMock.callArgs = append(mmCheckInviteLimitTx.CheckInviteLimitTxMock.callArgs, &mm_params)
	mmCheckInviteLimitTx.CheckInviteLimitTxMock.mutex.Unlock()

	for _, e := range mmCheckInviteLimitTx.CheckInviteLimitTxMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.b1, e.results.err
		}
	}

	if mmCheckInviteLimitTx.CheckInviteLimitTxMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmCheckInviteLimitTx.CheckInviteLimitTxMock.defaultExpectation.Counter, 1)
		mm_want := mmCheckInviteLimitTx.CheckInviteLimitTxMock.defaultExpectation.params
		mm_want_ptrs := mmCheckInviteLimitTx.CheckInviteLimitTxMock.defaultExpectation.paramPtrs

		mm_got := UserRepositoryMockCheckInviteLimitTxParams{ctx, tx, userID}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmCheckInviteLimitTx.t.Errorf("UserRepositoryMock.CheckInviteLimitTx got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmCheckInviteLimitTx.CheckInviteLimitTxMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
			}

			if mm_want_ptrs.tx != nil && !minimock.Equal(*mm_want_ptrs.tx, mm_got.tx) {
				mmCheckInviteLimitTx.t.Errorf("UserRepositoryMock.CheckInviteLimitTx got unexpected parameter tx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmCheckInviteLimitTx.CheckInviteLimitTxMock.defaultExpectation.expectationOrigins.originTx, *mm_want_ptrs.tx, mm_got.tx, minimock.Diff(*mm_want_ptrs.tx, mm_got.tx))
			}

			if mm_want_ptrs.userID != nil && !minimock.Equal(*mm_want_ptrs.userID, mm_got.userID) {
				mmCheckInviteLimitTx.t.Errorf("UserRepositoryMock.CheckInviteLimitTx got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmCheckInviteLimitTx.CheckInviteLimitTxMock.defaultExpectation.expectationOrigins.originUserID, *mm_want_ptrs.userID, mm_got.userID, minimock.Diff(*mm_want_ptrs.userID, mm_got.userID))
			}

		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmCheckInviteLimitTx.t.Errorf("UserRepositoryMock.CheckInviteLimitTx got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmCheckInviteLimitTx.CheckInviteLimitTxMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmCheckInviteLimitTx.CheckInviteLimitTxMock.defaultExpectation.results
		if mm_results == nil {
			mmCheckInviteLimitTx.t.Fatal("No results are set for the UserRepositoryMock.CheckInviteLimitTx")
		}
		return (*mm_results).b1, (*mm_results).err
	}
	if mmCheckInviteLimitTx.funcCheckInviteLimitTx != nil {
		return mmCheckInviteLimitTx.funcCheckInviteLimitTx(ctx, tx, userID)
	}
	mmCheckInviteLimitTx.t.Fatalf("Unexpected call to UserRepositoryMock.CheckInviteLimitTx. %v %v %v", ctx, tx, userID)
	return
}

// CheckInviteLimitTxAfterCounter returns a count of finished UserRepositoryMock.CheckInviteLimitTx invocations
func (mmCheckInviteLimitTx *UserRepositoryMock) CheckInviteLimitTxAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmCheckInviteLimitTx.afterCheckInviteLimitTxCounter)
}

// CheckInviteLimitTxBeforeCounter returns a count of UserRepositoryMock.CheckInviteLimitTx invocations
func (mmCheckInviteLimitTx *UserRepositoryMock) CheckInviteLimitTxBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmCheckInviteLimitTx.beforeCheckInviteLimitTxCounter)
}

// Calls returns a list of arguments used in each call to UserRepositoryMock.CheckInviteLimitTx.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) Calls() []*UserRepositoryMockCheckInviteLimitTxParams {
	mmCheckInviteLimitTx.mutex.RLock()

	argCopy := make([]*UserRepositoryMockCheckInviteLimitTxParams, len(mmCheckInviteLimitTx.callArgs))
	copy(argCopy, mmCheckInviteLimitTx.callArgs)

	mmCheckInviteLimitTx.mutex.RUnlock()

	return argCopy
}

// MinimockCheckInviteLimitTxDone returns true if the count of the CheckInviteLimitTx invocations corresponds
// the number of defined expectations
func (m *UserRepositoryMock) MinimockCheckInviteLimitTxDone() bool {
	if m.CheckInviteLimitTxMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.CheckInviteLimitTxMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.CheckInviteLimitTxMock.invocationsDone()
}

// MinimockCheckInviteLimitTxInspect logs each unmet expectation
func (m *UserRepositoryMock) MinimockCheckInviteLimitTxInspect() {
	for _, e := range m.CheckInviteLimitTxMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to UserRepositoryMock.CheckInviteLimitTx at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterCheckInviteLimitTxCounter := mm_atomic.LoadUint64(&m.afterCheckInviteLimitTxCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.CheckInviteLimitTxMock.defaultExpectation != nil && afterCheckInviteLimitTxCounter < 1 {
		if m.CheckInviteLimitTxMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to UserRepositoryMock.CheckInviteLimitTx at\n%s", m.CheckInviteLimitTxMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to UserRepositoryMock.CheckInviteLimitTx at\n%s with params: %#v", m.CheckInviteLimitTxMock.defaultExpectation.expectationOrigins.origin, *m.CheckInviteLimitTxMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcCheckInviteLimitTx != nil && afterCheckInviteLimitTxCounter < 1 {
		m.t.Errorf("Expected call to UserRepositoryMock.CheckInviteLimitTx at\n%s", m.funcCheckInviteLimitTxOrigin)
	}

	if !m.CheckInviteLimitTxMock.invocationsDone() && afterCheckInviteLimitTxCounter > 0 {
		m.t.Errorf("Expected %d calls to UserRepositoryMock.CheckInviteLimitTx at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.CheckInviteLimitTxMock.expectedInvocations), m.CheckInviteLimitTxMock.expectedInvocationsOrigin, afterCheckInviteLimitTxCounter)
	}
}

type mUserRepositoryMockCreate struct {
	optional           bool
	mock               *UserRepositoryMock
	defaultExpectation *UserRepositoryMockCreateExpectation
	expectations       []*UserRepositoryMockCreateExpectation

	callArgs []*UserRepositoryMockCreateParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// UserRepositoryMockCreateExpectation specifies expectation struct of the UserRepository.Create
type UserRepositoryMockCreateExpectation struct {
	mock               *UserRepositoryMock
	params             *UserRepositoryMockCreateParams
	paramPtrs          *UserRepositoryMockCreateParamPtrs
	expectationOrigins UserRepositoryMockCreateExpectationOrigins
	results            *UserRepositoryMockCreateResults
	returnOrigin       string
	Counter            uint64
}

// UserRepositoryMockCreateParams contains parameters of the UserRepository.Create
type UserRepositoryMockCreateParams struct {
	ctx  context.Context
	user *model.User
}

// UserRepositoryMockCreateParamPtrs contains pointers to parameters of the UserRepository.Create
type UserRepositoryMockCreateParamPtrs struct {
	ctx  *context.Context
	user **model.User
}

// UserRepositoryMockCreateResults contains results of the UserRepository.Create
type UserRepositoryMockCreateResults struct {
	err error
}

// UserRepositoryMockCreateOrigins contains origins of expectations of the UserRepository.Create
type UserRepositoryMockCreateExpectationOrigins struct {
	origin     string
	originCtx  string
	originUser string
}

// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
// Optional() makes method check to work in '0 or more' mode.
// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
// catch the problems when the expected method call is totally skipped during test run.
func (mmCreate *mUserRepositoryMockCreate) Optional() *mUserRepositoryMockCreate {
	mmCreate.optional = true
	return mmCreate
}

// Expect sets up expected params for UserRepository.Create
func (mmCreate *mUserRepositoryMockCreate) Expect(ctx context.Context, user *model.User) *mUserRepositoryMockCreate {
	if mmCreate.mock.funcCreate != nil {
		mmCreate.mock.t.Fatalf("UserRepositoryMock.Create mock is already set by Set")
	}

	if mmCreate.defaultExpectation == nil {
		mmCreate.defaultExpectation = &UserRepositoryMockCreateExpectation{}
	}

	if mmCreate.defaultExpectation.paramPtrs != nil {
		mmCreate.mock.t.Fatalf("UserRepositoryMock.Create mock is already set by ExpectParams functions")
	}

	mmCreate.defaultExpectation.params = &UserRepositoryMockCreateParams{ctx, user}
	mmCreate.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmCreate.expectations {
		if minimock.Equal(e.params, mmCreate.defaultExpectation.params) {
			mmCreate.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreate.defaultExpectation.params)
		}
	}

	return mmCreate
}

// ExpectCtxParam1 sets up expected param ctx for UserRepository.Create
func (mmCreate *mUserRepositoryMockCreate) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockCreate {
	if mmCreate.mock.funcCreate != nil {
		mmCreate.mock.t.Fatalf("UserRepositoryMock.Create mock is already set by Set")
	}

	if mmCreate.defaultExpectation == nil {
		mmCreate.defaultExpectation = &UserRepositoryMockCreateExpectation{}
	}

	if mmCreate.defaultExpectation.params != nil {
		mmCreate.mock.t.Fatalf("UserRepositoryMock.Create mock is already set by Expect")
	}

	if mmCreate.defaultExpectation.paramPtrs == nil {
		mmCreate.defaultExpectation.paramPtrs = &UserRepositoryMockCreateParamPtrs{}
	}
	mmCreate.defaultExpectation.paramPtrs.ctx = &ctx
	mmCreate.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmCreate
}

// ExpectUserParam2 sets up expected param user for UserRepository.Create
func (mmCreate *mUserRepositoryMockCreate) ExpectUserParam2(user *model.User) *mUserRepositoryMockCreate {
	if mmCreate.mock.funcCreate != nil {
		mmCreate.mock.t.Fatalf("UserRepositoryMock.Create mock is already set by Set")
	}

	if mmCreate.defaultExpectation == nil {
		mmCreate.defaultExpectation = &UserRepositoryMockCreateExpectation{}
	}

	if mmCreate.defaultExpectation.params != nil {
		mmCreate.mock.t.Fatalf("UserRepositoryMock.Create mock is already set by Expect")
	}

	if mmCreate.defaultExpectation.paramPtrs == nil {
		mmCreate.defaultExpectation.paramPtrs = &UserRepositoryMockCreateParamPtrs{}
	}
	mmCreate.defaultExpectation.paramPtrs.user = &user
	mmCreate.defaultExpectation.expectationOrigins.originUser = minimock.CallerInfo(1)

	return mmCreate
}

// Inspect accepts an inspector function that has same arguments as the UserRepository.Create
func (mmCreate *mUserRepositoryMockCreate) Inspect(f func(ctx context.Context, user *model.User)) *mUserRepositoryMockCreate {
	if mmCreate.mock.inspectFuncCreate != nil {
		mmCreate.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.Create")
	}

	mmCreate.mock.inspectFuncCreate = f

	return mmCreate
}

// Return sets up results that will be returned by UserRepository.Create
func (mmCreate *mUserRepositoryMockCreate) Return(err error) *UserRepositoryMock {
	if mmCreate.mock.funcCreate != nil {
		mmCreate.mock.t.Fatalf("UserRepositoryMock.Create mock is already set by Set")
	}

	if mmCreate.defaultExpectation == nil {
		mmCreate.defaultExpectation = &UserRepositoryMockCreateExpectation{mock: mmCreate.mock}
	}
	mmCreate.defaultExpectation.results = &UserRepositoryMockCreateResults{err}
	mmCreate.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmCreate.mock
}

// Set uses given function f to mock the UserRepository.Create method
func (mmCreate *mUserRepositoryMockCreate) Set(f func(ctx context.Context, user *model.User) (err error)) *UserRepositoryMock {
	if mmCreate.defaultExpectation != nil {
		mmCreate.mock.t.Fatalf("Default expectation is already set for the UserRepository.Create method")
	}

	if len(mmCreate.expectations) > 0 {
		mmCreate.mock.t.Fatalf("Some expectations are already set for the UserRepository.Create method")
	}

	mmCreate.mock.funcCreate = f
	mmCreate.mock.funcCreateOrigin = minimock.CallerInfo(1)
	return mmCreate.mock
}

// When sets expectation for the UserRepository.Create which will trigger the result defined by the following
// Then helper
func (mmCreate *mUserRepositoryMockCreate) When(ctx context.Context, user *model.User) *UserRepositoryMockCreateExpectation {
	if mmCreate.mock.funcCreate != nil {
		mmCreate.mock.t.Fatalf("UserRepositoryMock.Create mock is already set by Set")
	}

	expectation := &UserRepositoryMockCreateExpectation{
		mock:               mmCreate.mock,
		params:             &UserRepositoryMockCreateParams{ctx, user},
		expectationOrigins: UserRepositoryMockCreateExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmCreate.expectations = append(mmCreate.expectations, expectation)
	return expectation
}

// Then sets up UserRepository.Create return parameters for the expectation previously defined by the When method
func (e *UserRepositoryMockCreateExpectation) Then(err error) *UserRepositoryMock {
	e.results = &UserRepositoryMockCreateResults{err}
	return e.mock
}

// Times sets number of times UserRepository.Create should be invoked
func (mmCreate *mUserRepositoryMockCreate) Times(n uint64) *mUserRepositoryMockCreate {
	if n == 0 {
		mmCreate.mock.t.Fatalf("Times of UserRepositoryMock.Create mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmCreate.expectedInvocations, n)
	mmCreate.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmCreate
}

func (mmCreate *mUserRepositoryMockCreate) invocationsDone() bool {
	if len(mmCreate.expectations) == 0 && mmCreate.defaultExpectation == nil && mmCreate.mock.funcCreate == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmCreate.mock.afterCreateCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmCreate.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// Create implements mm_repository.UserRepository
func (mmCreate *UserRepositoryMock) Create(ctx context.Context, user *model.User) (err error) {
	mm_atomic.AddUint64(&mmCreate.beforeCreateCounter, 1)
	defer mm_atomic.AddUint64(&mmCreate.afterCreateCounter, 1)

	mmCreate.t.Helper()

	if mmCreate.inspectFuncCreate != nil {
		mmCreate.inspectFuncCreate(ctx, user)
	}

	mm_params := UserRepositoryMockCreateParams{ctx, user}

	// Record call args
	mmCreate.CreateMock.mutex.Lock()
	mmCreate.CreateMock.callArgs = append(mmCreate.CreateMock.callArgs, &mm_params)
	mmCreate.CreateMock.mutex.Unlock()

	for _, e := range mmCreate.CreateMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.err
		}
	}

	if mmCreate.CreateMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmCreate.CreateMock.defaultExpectation.Counter, 1)
		mm_want := mmCreate.CreateMock.defaultExpectation.params
		mm_want_ptrs := mmCreate.CreateMock.defaultExpectation.paramPtrs

		mm_got := UserRepositoryMockCreateParams{ctx, user}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmCreate.t.Errorf("UserRepositoryMock.Create got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmCreate.CreateMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
			}

			if mm_want_ptrs.user != nil && !minimock.Equal(*mm_want_ptrs.user, mm_got.user) {
				mmCreate.t.Errorf("UserRepositoryMock.Create got unexpected parameter user, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmCreate.CreateMock.defaultExpectation.expectationOrigins.originUser, *mm_want_ptrs.user, mm_got.user, minimock.Diff(*mm_want_ptrs.user, mm_got.user))
			}

		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmCreate.t.Errorf("UserRepositoryMock.Create got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmCreate.CreateMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmCreate.CreateMock.defaultExpectation.results
		if mm_results == nil {
			mmCreate.t.Fatal("No results are set for the UserRepositoryMock.Create")
		}
		return (*mm_results).err
	}
	if mmCreate.funcCreate != nil {
		return mmCreate.funcCreate(ctx, user)
	}
	mmCreate.t.Fatalf("Unexpected call to UserRepositoryMock.Create. %v %v", ctx, user)
	return
}

// CreateAfterCounter returns a count of finished UserRepositoryMock.Create invocations
func (mmCreate *UserRepositoryMock) CreateAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmCreate.afterCreateCounter)
}

// CreateBeforeCounter returns a count of UserRepositoryMock.Create invocations
func (mmCreate *UserRepositoryMock) CreateBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmCreate.beforeCreateCounter)
}

// Calls returns a list of arguments used in each call to UserRepositoryMock.Create.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmCreate *mUserRepositoryMockCreate) Calls() []*UserRepositoryMockCreateParams {
	mmCreate.mutex.RLock()

	argCopy := make([]*UserRepositoryMockCreateParams, len(mmCreate.callArgs))
	copy(argCopy, mmCreate.callArgs)

	mmCreate.mutex.RUnlock()

	return argCopy
}

// MinimockCreateDone returns true if the count of the Create invocations corresponds
// the number of defined expectations
func (m *UserRepositoryMock) MinimockCreateDone() bool {
	if m.CreateMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.CreateMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.CreateMock.invocationsDone()
}

// MinimockCreateInspect logs each unmet expectation
func (m *UserRepositoryMock) MinimockCreateInspect() {
	for _, e := range m.CreateMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to UserRepositoryMock.Create at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterCreateCounter := mm_atomic.LoadUint64(&m.afterCreateCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.CreateMock.defaultExpectation != nil && afterCreateCounter < 1 {
		if m.CreateMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to UserRepositoryMock.Create at\n%s", m.CreateMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to UserRepositoryMock.Create at\n%s with params: %#v", m.CreateMock.defaultExpectation.expectationOrigins.origin, *m.CreateMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcCreate != nil && afterCreateCounter < 1 {
		m.t.Errorf("Expected call to UserRepositoryMock.Create at\n%s", m.funcCreateOrigin)
	}

	if !m.CreateMock.invocationsDone() && afterCreateCounter > 0 {
		m.t.Errorf("Expected %d calls to UserRepositoryMock.Create at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.CreateMock.expectedInvocations), m.CreateMock.expectedInvocationsOrigin, afterCreateCounter)
	}
}

type mUserRepositoryMockCreateTx struct {
	optional           bool
	mock               *UserRepositoryMock
	defaultExpectation *UserRepositoryMockCreateTxExpectation
	expectations       []*UserRepositoryMockCreateTxExpectation

	callArgs []*UserRepositoryMockCreateTxParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// UserRepositoryMockCreateTxExpectation specifies expectation struct of the UserRepository.CreateTx
type UserRepositoryMockCreateTxExpectation struct {
	mock               *UserRepositoryMock
	params             *UserRepositoryMockCreateTxParams
	paramPtrs          *UserRepositoryMockCreateTxParamPtrs
	expectationOrigins UserRepositoryMockCreateTxExpectationOrigins
	results            *UserRepositoryMockCreateTxResults
	returnOrigin       string
	Counter            uint64
}

// UserRepositoryMockCreateTxParams contains parameters of the UserRepository.CreateTx
type UserRepositoryMockCreateTxParams struct {
	ctx  context.Context
	tx   pgx.Tx
	user *model.User
}

// UserRepositoryMockCreateTxParamPtrs contains pointers to parameters of the UserRepository.CreateTx
type UserRepositoryMockCreateTxParamPtrs struct {
	ctx  *context.Context
	tx   *pgx.Tx
	user **model.User
}

// UserRepositoryMockCreateTxResults contains results of the UserRepository.CreateTx
type UserRepositoryMockCreateTxResults struct {
	err error
}

// UserRepositoryMockCreateTxOrigins contains origins of expectations of the UserRepository.CreateTx
type UserRepositoryMockCreateTxExpectationOrigins struct {
	origin     string
	originCtx  string
	originTx   string
	originUser string
}

// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
// Optional() makes method check to work in '0 or more' mode.
// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
// catch the problems when the expected method call is totally skipped during test run.
func (mmCreateTx *mUserRepositoryMockCreateTx) Optional() *mUserRepositoryMockCreateTx {
	mmCreateTx.optional = true
	return mmCreateTx
}

// Expect sets up expected params for UserRepository.CreateTx
func (mmCreateTx *mUserRepositoryMockCreateTx) Expect(ctx context.Context, tx pgx.Tx, user *model.User) *mUserRepositoryMockCreateTx {
	if mmCreateTx.mock.funcCreateTx != nil {
		mmCreateTx.mock.t.Fatalf("UserRepositoryMock.CreateTx mock is already set by Set")
	}

	if mmCreateTx.defaultExpectation == nil {
		mmCreateTx.defaultExpectation = &UserRepositoryMockCreateTxExpectation{}
	}

	if mmCreateTx.defaultExpectation.paramPtrs != nil {
		mmCreateTx.mock.t.Fatalf("UserRepositoryMock.CreateTx mock is already set by ExpectParams functions")
	}

	mmCreateTx.defaultExpectation.params = &UserRepositoryMockCreateTxParams{ctx, tx, user}
	mmCreateTx.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmCreateTx.expectations {
		if minimock.Equal(e.params, mmCreateTx.defaultExpectation.params) {
			mmCreateTx.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreateTx.defaultExpectation.params)
		}
	}

	return mmCreateTx
}

// ExpectCtxParam1 sets up expected param ctx for UserRepository.CreateTx
func (mmCreateTx *mUserRepositoryMockCreateTx) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockCreateTx {
	if mmCreateTx.mock.funcCreateTx != nil {
		mmCreateTx.mock.t.Fatalf("UserRepositoryMock.CreateTx mock is already set by Set")
	}

	if mmCreateTx.defaultExpectation == nil {
		mmCreateTx.defaultExpectation = &UserRepositoryMockCreateTxExpectation{}
	}

	if mmCreateTx.defaultExpectation.params != nil {
		mmCreateTx.mock.t.Fatalf("UserRepositoryMock.CreateTx mock is already set by Expect")
	}

	if mmCreateTx.defaultExpectation.paramPtrs == nil {
		mmCreateTx.defaultExpectation.paramPtrs = &UserRepositoryMockCreateTxParamPtrs{}
	}
	mmCreateTx.defaultExpectation.paramPtrs.ctx = &ctx
	mmCreateTx.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmCreateTx
}

// ExpectTxParam2 sets up expected param tx for UserRepository.CreateTx
func (mmCreateTx *mUserRepositoryMockCreateTx) ExpectTxParam2(tx pgx.Tx) *mUserRepositoryMockCreateTx {
	if mmCreateTx.mock.funcCreateTx != nil {
		mmCreateTx.mock.t.Fatalf("UserRepositoryMock.CreateTx mock is already set by Set")
	}

	if mmCreateTx.defaultExpectation == nil {
		mmCreateTx.defaultExpectation = &UserRepositoryMockCreateTxExpectation{}
	}

	if mmCreateTx.defaultExpectation.params != nil {
		mmCreateTx.mock.t.Fatalf("UserRepositoryMock.CreateTx mock is already set by Expect")
	}

	if mmCreateTx.defaultExpectation.paramPtrs == nil {
		mmCreateTx.defaultExpectation.paramPtrs = &UserRepositoryMockCreateTxParamPtrs{}
	}
	mmCreateTx.defaultExpectation.paramPtrs.tx = &tx
	mmCreateTx.defaultExpectation.expectationOrigins.originTx = minimock.CallerInfo(1)

	return mmCreateTx
}

// ExpectUserParam3 sets up expected param user for UserRepository.CreateTx
func (mmCreateTx *mUserRepositoryMockCreateTx) ExpectUserParam3(user *model.User) *mUserRepositoryMockCreateTx {
	if mmCreateTx.mock.funcCreateTx != nil {
		mmCreateTx.mock.t.Fatalf("UserRepositoryMock.CreateTx mock is already set by Set")
	}

	if mmCreateTx.defaultExpectation == nil {
		mmCreateTx.defaultExpectation = &UserRepositoryMockCreateTxExpectation{}
	}

	if mmCreateTx.defaultExpectation.params != nil {
		mmCreateTx.mock.t.Fatalf("UserRepositoryMock.CreateTx mock is already set by Expect")
	}

	if mmCreateTx.defaultExpectation.paramPtrs == nil {
		mmCreateTx.defaultExpectation.paramPtrs = &UserRepositoryMockCreateTxParamPtrs{}
	}
	mmCreateTx.defaultExpectation.paramPtrs.user = &user
	mmCreateTx.defaultExpectation.expectationOrigins.originUser = minimock.CallerInfo(1)

	return mmCreateTx
}

// Inspect accepts an inspector function that has same arguments as the UserRepository.CreateTx
func (mmCreateTx *mUserRepositoryMockCreateTx) Inspect(f func(ctx context.Context, tx pgx.Tx, user *model.User)) *mUserRepositoryMockCreateTx {
	if mmCreateTx.mock.inspectFuncCreateTx != nil {
		mmCreateTx.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.CreateTx")
	}

	mmCreateTx.mock.inspectFuncCreateTx = f

	return mmCreateTx
}

// Return sets up results that will be returned by UserRepository.CreateTx
func (mmCreateTx *mUserRepositoryMockCreateTx) Return(err error) *UserRepositoryMock {
	if mmCreateTx.mock.funcCreateTx != nil {
		mmCreateTx.mock.t.Fatalf("UserRepositoryMock.CreateTx mock is already set by Set")
	}

	if mmCreateTx.defaultExpectation == nil {
		mmCreateTx.defaultExpectation = &UserRepositoryMockCreateTxExpectation{mock: mmCreateTx.mock}
	}
	mmCreateTx.defaultExpectation.results = &UserRepositoryMockCreateTxResults{err}
	mmCreateTx.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmCreateTx.mock
}

// Set uses given function f to mock the UserRepository.CreateTx method
func (mmCreateTx *mUserRepositoryMockCreateTx) Set(f func(ctx context.Context, tx pgx.Tx, user *model.User) (err error)) *UserRepositoryMock {
	if mmCreateTx.defaultExpectation != nil {
		mmCreateTx.mock.t.Fatalf("Default expectation is already set for the UserRepository.CreateTx method")
	}

	if len(mmCreateTx.expectations) > 0 {
		mmCreateTx.mock.t.Fatalf("Some expectations are already set for the UserRepository.CreateTx method")
	}

	mmCreateTx.mock.funcCreateTx = f
	mmCreateTx.mock.funcCreateTxOrigin = minimock.CallerInfo(1)
	return mmCreateTx.mock
}

// When sets expectation for the UserRepository.CreateTx which will trigger the result defined by the following
// Then helper
func (mmCreateTx *mUserRepositoryMockCreateTx) When(ctx context.Context, tx pgx.Tx, user *model.User) *UserRepositoryMockCreateTxExpectation {
	if mmCreateTx.mock.funcCreateTx != nil {
		mmCreateTx.mock.t.Fatalf("UserRepositoryMock.CreateTx mock is already set by Set")
	}

	expectation := &UserRepositoryMockCreateTxExpectation{
		mock:               mmCreateTx.mock,
		params:             &UserRepositoryMockCreateTxParams{ctx, tx, user},
		expectationOrigins: UserRepositoryMockCreateTxExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmCreateTx.expectations = append(mmCreateTx.expectations, expectation)
	return expectation
}

// Then sets up UserRepository.CreateTx return parameters for the expectation previously defined by the When method
func (e *UserRepositoryMockCreateTxExpectation) Then(err error) *UserRepositoryMock {
	e.results = &UserRepositoryMockCreateTxResults{err}
	return e.mock
}

// Times sets number of times UserRepository.CreateTx should be invoked
func (mmCreateTx *mUserRepositoryMockCreateTx) Times(n uint64) *mUserRepositoryMockCreateTx {
	if n == 0 {
		mmCreateTx.mock.t.Fatalf("Times of UserRepositoryMock.CreateTx mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmCreateTx.expectedInvocations, n)
	mmCreateTx.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmCreateTx
}

func (mmCreateTx *mUserRepositoryMockCreateTx) invocationsDone() bool {
	if len(mmCreateTx.expectations) == 0 && mmCreateTx.defaultExpectation == nil && mmCreateTx.mock.funcCreateTx == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmCreateTx.mock.afterCreateTxCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmCreateTx.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// CreateTx implements mm_repository.UserRepository
func (mmCreateTx *UserRepositoryMock) CreateTx(ctx context.Context, tx pgx.Tx, user *model.User) (err error) {
	mm_atomic.AddUint64(&mmCreateTx.beforeCreateTxCounter, 1)
	defer mm_atomic.AddUint64(&mmCreateTx.afterCreateTxCounter, 1)

	mmCreateTx.t.Helper()

	if mmCreateTx.inspectFuncCreateTx != nil {
		mmCreateTx.inspectFuncCreateTx(ctx, tx, user)
	}

	mm_params := UserRepositoryMockCreateTxParams{ctx, tx, user}

	// Record call args
	mmCreateTx.CreateTxMock.mutex.Lock()
	mmCreateTx.CreateTxMock.callArgs = append(mmCreateTx.CreateTxMock.callArgs, &mm_params)
	mmCreateTx.CreateTxMock.mutex.Unlock()

	for _, e := range mmCreateTx.CreateTxMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.err
		}
	}

	if mmCreateTx.CreateTxMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmCreateTx.CreateTxMock.defaultExpectation.Counter, 1)
		mm_want := mmCreateTx.CreateTxMock.defaultExpectation.params
		mm_want_ptrs := mmCreateTx.CreateTxMock.defaultExpectation.paramPtrs

		mm_got := UserRepositoryMockCreateTxParams{ctx, tx, user}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmCreateTx.t.Errorf("UserRepositoryMock.CreateTx got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmCreateTx.CreateTxMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
			}

			if mm_want_ptrs.tx != nil && !minimock.Equal(*mm_want_ptrs.tx, mm_got.tx) {
				mmCreateTx.t.Errorf("UserRepositoryMock.CreateTx got unexpected parameter tx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmCreateTx.CreateTxMock.defaultExpectation.expectationOrigins.originTx, *mm_want_ptrs.tx, mm_got.tx, minimock.Diff(*mm_want_ptrs.tx, mm_got.tx))
			}

			if mm_want_ptrs.user != nil && !minimock.Equal(*mm_want_ptrs.user, mm_got.user) {
				mmCreateTx.t.Errorf("UserRepositoryMock.CreateTx got unexpected parameter user, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmCreateTx.CreateTxMock.defaultExpectation.expectationOrigins.originUser, *mm_want_ptrs.user, mm_got.user, minimock.Diff(*mm_want_ptrs.user, mm_got.user))
			}

		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmCreateTx.t.Errorf("UserRepositoryMock.CreateTx got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmCreateTx.CreateTxMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmCreateTx.CreateTxMock.defaultExpectation.results
		if mm_results == nil {
			mmCreateTx.t.Fatal("No results are set for the UserRepositoryMock.CreateTx")
		}
		return (*mm_results).err
	}
	if mmCreateTx.funcCreateTx != nil {
		return mmCreateTx.funcCreateTx(ctx, tx, user)
	}
	mmCreateTx.t.Fatalf("Unexpected call to UserRepositoryMock.CreateTx. %v %v %v", ctx, tx, user)
	return
}

// CreateTxAfterCounter returns a count of finished UserRepositoryMock.CreateTx invocations
func (mmCreateTx *UserRepositoryMock) CreateTxAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmCreateTx.afterCreateTxCounter)
}

// CreateTxBeforeCounter returns a count of UserRepositoryMock.CreateTx invocations
func (mmCreateTx *UserRepositoryMock) CreateTxBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmCreateTx.beforeCreateTxCounter)
}

// Calls returns a list of arguments used in each call to UserRepositoryMock.CreateTx.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmCreateTx *mUserRepositoryMockCreateTx) Calls() []*UserRepositoryMockCreateTxParams {
	mmCreateTx.mutex.RLock()

	argCopy := make([]*UserRepositoryMockCreateTxParams, len(mmCreateTx.callArgs))
	copy(argCopy, mmCreateTx.callArgs)

	mmCreateTx.mutex.RUnlock()

	return argCopy
}

// MinimockCreateTxDone returns true if the count of the CreateTx invocations corresponds
// the number of defined expectations
func (m *UserRepositoryMock) MinimockCreateTxDone() bool {
	if m.CreateTxMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.CreateTxMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.CreateTxMock.invocationsDone()
}

// MinimockCreateTxInspect logs each unmet expectation
func (m *UserRepositoryMock) MinimockCreateTxInspect() {
	for _, e := range m.CreateTxMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to UserRepositoryMock.CreateTx at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterCreateTxCounter := mm_atomic.LoadUint64(&m.afterCreateTxCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.CreateTxMock.defaultExpectation != nil && afterCreateTxCounter < 1 {
		if m.CreateTxMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to UserRepositoryMock.CreateTx at\n%s", m.CreateTxMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to UserRepositoryMock.CreateTx at\n%s with params: %#v", m.CreateTxMock.defaultExpectation.expectationOrigins.origin, *m.CreateTxMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcCreateTx != nil && afterCreateTxCounter < 1 {
		m.t.Errorf("Expected call to UserRepositoryMock.CreateTx at\n%s", m.funcCreateTxOrigin)
	}

	if !m.CreateTxMock.invocationsDone() && afterCreateTxCounter > 0 {
		m.t.Errorf("Expected %d calls to UserRepositoryMock.CreateTx at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.CreateTxMock.expectedInvocations), m.CreateTxMock.expectedInvocationsOrigin, afterCreateTxCounter)
	}
}

type mUserRepositoryMockFindByEmailHash struct {
	optional           bool
	mock               *UserRepositoryMock
	defaultExpectation *UserRepositoryMockFindByEmailHashExpectation
	expectations       []*UserRepositoryMockFindByEmailHashExpectation

	callArgs []*UserRepositoryMockFindByEmailHashParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// UserRepositoryMockFindByEmailHashExpectation specifies expectation struct of the UserRepository.FindByEmailHash
type UserRepositoryMockFindByEmailHashExpectation struct {
	mock               *UserRepositoryMock
	params             *UserRepositoryMockFindByEmailHashParams
	paramPtrs          *UserRepositoryMockFindByEmailHashParamPtrs
	expectationOrigins UserRepositoryMockFindByEmailHashExpectationOrigins
	results            *UserRepositoryMockFindByEmailHashResults
	returnOrigin       string
	Counter            uint64
}

// UserRepositoryMockFindByEmailHashParams contains parameters of the UserRepository.FindByEmailHash
type UserRepositoryMockFindByEmailHashParams struct {
	ctx       context.Context
	emailHash string
}

// UserRepositoryMockFindByEmailHashParamPtrs contains pointers to parameters of the UserRepository.FindByEmailHash
type UserRepositoryMockFindByEmailHashParamPtrs struct {
	ctx       *context.Context
	emailHash *string
}

// UserRepositoryMockFindByEmailHashResults contains results of the UserRepository.FindByEmailHash
type UserRepositoryMockFindByEmailHashResults struct {
	up1 *model.User
	err error
}

// UserRepositoryMockFindByEmailHashOrigins contains origins of expectations of the UserRepository.FindByEmailHash
type UserRepositoryMockFindByEmailHashExpectationOrigins struct {
	origin          string
	originCtx       string
	originEmailHash string
}

// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
// Optional() makes method check to work in '0 or more' mode.
// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
// catch the problems when the expected method call is totally skipped during test run.
func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) Optional() *mUserRepositoryMockFindByEmailHash {
	mmFindByEmailHash.optional = true
	return mmFindByEmailHash
}

// Expect sets up expected params for UserRepository.FindByEmailHash
func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) Expect(ctx context.Context, emailHash string) *mUserRepositoryMockFindByEmailHash {
	if mmFindByEmailHash.mock.funcFindByEmailHash != nil {
		mmFindByEmailHash.mock.t.Fatalf("UserRepositoryMock.FindByEmailHash mock is already set by Set")
	}

	if mmFindByEmailHash.defaultExpectation == nil {
		mmFindByEmailHash.defaultExpectation = &UserRepositoryMockFindByEmailHashExpectation{}
	}

	if mmFindByEmailHash.defaultExpectation.paramPtrs != nil {
		mmFindByEmailHash.mock.t.Fatalf("UserRepositoryMock.FindByEmailHash mock is already set by ExpectParams functions")
	}

	mmFindByEmailHash.defaultExpectation.params = &UserRepositoryMockFindByEmailHashParams{ctx, emailHash}
	mmFindByEmailHash.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmFindByEmailHash.expectations {
		if minimock.Equal(e.params, mmFindByEmailHash.defaultExpectation.params) {
			mmFindByEmailHash.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmFindByEmailHash.defaultExpectation.params)
		}
	}

	return mmFindByEmailHash
}

// ExpectCtxParam1 sets up expected param ctx for UserRepository.FindByEmailHash
func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockFindByEmailHash {
	if mmFindByEmailHash.mock.funcFindByEmailHash != nil {
		mmFindByEmailHash.mock.t.Fatalf("UserRepositoryMock.FindByEmailHash mock is already set by Set")
	}

	if mmFindByEmailHash.defaultExpectation == nil {
		mmFindByEmailHash.defaultExpectation = &UserRepositoryMockFindByEmailHashExpectation{}
	}

	if mmFindByEmailHash.defaultExpectation.params != nil {
		mmFindByEmailHash.mock.t.Fatalf("UserRepositoryMock.FindByEmailHash mock is already set by Expect")
	}

	if mmFindByEmailHash.defaultExpectation.paramPtrs == nil {
		mmFindByEmailHash.defaultExpectation.paramPtrs = &UserRepositoryMockFindByEmailHashParamPtrs{}
	}
	mmFindByEmailHash.defaultExpectation.paramPtrs.ctx = &ctx
	mmFindByEmailHash.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmFindByEmailHash
}

// ExpectEmailHashParam2 sets up expected param emailHash for UserRepository.FindByEmailHash
func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) ExpectEmailHashParam2(emailHash string) *mUserRepositoryMockFindByEmailHash {
	if mmFindByEmailHash.mock.funcFindByEmailHash != nil {
		mmFindByEmailHash.mock.t.Fatalf("UserRepositoryMock.FindByEmailHash mock is already set by Set")
	}

	if mmFindByEmailHash.defaultExpectation == nil {
		mmFindByEmailHash.defaultExpectation = &UserRepositoryMockFindByEmailHashExpectation{}
	}

	if mmFindByEmailHash.defaultExpectation.params != nil {
		mmFindByEmailHash.mock.t.Fatalf("UserRepositoryMock.FindByEmailHash mock is already set by Expect")
	}

	if mmFindByEmailHash.defaultExpectation.paramPtrs == nil {
		mmFindByEmailHash.defaultExpectation.paramPtrs = &UserRepositoryMockFindByEmailHashParamPtrs{}
	}
	mmFindByEmailHash.defaultExpectation.paramPtrs.emailHash = &emailHash
	mmFindByEmailHash.defaultExpectation.expectationOrigins.originEmailHash = minimock.CallerInfo(1)

	return mmFindByEmailHash
}

// Inspect accepts an inspector function that has same arguments as the UserRepository.FindByEmailHash
func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) Inspect(f func(ctx context.Context, emailHash string)) *mUserRepositoryMockFindByEmailHash {
	if mmFindByEmailHash.mock.inspectFuncFindByEmailHash != nil {
		mmFindByEmailHash.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.FindByEmailHash")
	}

	mmFindByEmailHash.mock.inspectFuncFindByEmailHash = f

	return mmFindByEmailHash
}

// Return sets up results that will be returned by UserRepository.FindByEmailHash
func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) Return(up1 *model.User, err error) *UserRepositoryMock {
	if mmFindByEmailHash.mock.funcFindByEmailHash != nil {
		mmFindByEmailHash.mock.t.Fatalf("UserRepositoryMock.FindByEmailHash mock is already set by Set")
	}

	if mmFindByEmailHash.defaultExpectation == nil {
		mmFindByEmailHash.defaultExpectation = &UserRepositoryMockFindByEmailHashExpectation{mock: mmFindByEmailHash.mock}
	}
	mmFindByEmailHash.defaultExpectation.results = &UserRepositoryMockFindByEmailHashResults{up1, err}
	mmFindByEmailHash.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmFindByEmailHash.mock
}

// Set uses given function f to mock the UserRepository.FindByEmailHash method
func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) Set(f func(ctx context.Context, emailHash string) (up1 *model.User, err error)) *UserRepositoryMock {
	if mmFindByEmailHash.defaultExpectation != nil {
		mmFindByEmailHash.mock.t.Fatalf("Default expectation is already set for the UserRepository.FindByEmailHash method")
	}

	if len(mmFindByEmailHash.expectations) > 0 {
		mmFindByEmailHash.mock.t.Fatalf("Some expectations are already set for the UserRepository.FindByEmailHash method")
	}

	mmFindByEmailHash.mock.funcFindByEmailHash = f
	mmFindByEmailHash.mock.funcFindByEmailHashOrigin = minimock.CallerInfo(1)
	return mmFindByEmailHash.mock
}

// When sets expectation for the UserRepository.FindByEmailHash which will trigger the result defined by the following
// Then helper
func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) When(ctx context.Context, emailHash string) *UserRepositoryMockFindByEmailHashExpectation {
	if mmFindByEmailHash.mock.funcFindByEmailHash != nil {
		mmFindByEmailHash.mock.t.Fatalf("UserRepositoryMock.FindByEmailHash mock is already set by Set")
	}

	expectation := &UserRepositoryMockFindByEmailHashExpectation{
		mock:               mmFindByEmailHash.mock,
		params:             &UserRepositoryMockFindByEmailHashParams{ctx, emailHash},
		expectationOrigins: UserRepositoryMockFindByEmailHashExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmFindByEmailHash.expectations = append(mmFindByEmailHash.expectations, expectation)
	return expectation
}

// Then sets up UserRepository.FindByEmailHash return parameters for the expectation previously defined by the When method
func (e *UserRepositoryMockFindByEmailHashExpectation) Then(up1 *model.User, err error) *UserRepositoryMock {
	e.results = &UserRepositoryMockFindByEmailHashResults{up1, err}
	return e.mock
}

// Times sets number of times UserRepository.FindByEmailHash should be invoked
func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) Times(n uint64) *mUserRepositoryMockFindByEmailHash {
	if n == 0 {
		mmFindByEmailHash.mock.t.Fatalf("Times of UserRepositoryMock.FindByEmailHash mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmFindByEmailHash.expectedInvocations, n)
	mmFindByEmailHash.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmFindByEmailHash
}

func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) invocationsDone() bool {
	if len(mmFindByEmailHash.expectations) == 0 && mmFindByEmailHash.defaultExpectation == nil && mmFindByEmailHash.mock.funcFindByEmailHash == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmFindByEmailHash.mock.afterFindByEmailHashCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmFindByEmailHash.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// FindByEmailHash implements mm_repository.UserRepository
func (mmFindByEmailHash *UserRepositoryMock) FindByEmailHash(ctx context.Context, emailHash string) (up1 *model.User, err error) {
	mm_atomic.AddUint64(&mmFindByEmailHash.beforeFindByEmailHashCounter, 1)
	defer mm_atomic.AddUint64(&mmFindByEmailHash.afterFindByEmailHashCounter, 1)

	mmFindByEmailHash.t.Helper()

	if mmFindByEmailHash.inspectFuncFindByEmailHash != nil {
		mmFindByEmailHash.inspectFuncFindByEmailHash(ctx, emailHash)
	}

	mm_params := UserRepositoryMockFindByEmailHashParams{ctx, emailHash}

	// Record call args
	mmFindByEmailHash.FindByEmailHashMock.mutex.Lock()
	mmFindByEmailHash.FindByEmailHashMock.callArgs = append(mmFindByEmailHash.FindByEmailHashMock.callArgs, &mm_params)
	mmFindByEmailHash.FindByEmailHashMock.mutex.Unlock()

	for _, e := range mmFindByEmailHash.FindByEmailHashMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.up1, e.results.err
		}
	}

	if mmFindByEmailHash.FindByEmailHashMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmFindByEmailHash.FindByEmailHashMock.defaultExpectation.Counter, 1)
		mm_want := mmFindByEmailHash.FindByEmailHashMock.defaultExpectation.params
		mm_want_ptrs := mmFindByEmailHash.FindByEmailHashMock.defaultExpectation.paramPtrs

		mm_got := UserRepositoryMockFindByEmailHashParams{ctx, emailHash}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmFindByEmailHash.t.Errorf("UserRepositoryMock.FindByEmailHash got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmFindByEmailHash.FindByEmailHashMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
			}

			if mm_want_ptrs.emailHash != nil && !minimock.Equal(*mm_want_ptrs.emailHash, mm_got.emailHash) {
				mmFindByEmailHash.t.Errorf("UserRepositoryMock.FindByEmailHash got unexpected parameter emailHash, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmFindByEmailHash.FindByEmailHashMock.defaultExpectation.expectationOrigins.originEmailHash, *mm_want_ptrs.emailHash, mm_got.emailHash, minimock.Diff(*mm_want_ptrs.emailHash, mm_got.emailHash))
			}

		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmFindByEmailHash.t.Errorf("UserRepositoryMock.FindByEmailHash got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmFindByEmailHash.FindByEmailHashMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmFindByEmailHash.FindByEmailHashMock.defaultExpectation.results
		if mm_results == nil {
			mmFindByEmailHash.t.Fatal("No results are set for the UserRepositoryMock.FindByEmailHash")
		}
		return (*mm_results).up1, (*mm_results).err
	}
	if mmFindByEmailHash.funcFindByEmailHash != nil {
		return mmFindByEmailHash.funcFindByEmailHash(ctx, emailHash)
	}
	mmFindByEmailHash.t.Fatalf("Unexpected call to UserRepositoryMock.FindByEmailHash. %v %v", ctx, emailHash)
	return
}

// FindByEmailHashAfterCounter returns a count of finished UserRepositoryMock.FindByEmailHash invocations
func (mmFindByEmailHash *UserRepositoryMock) FindByEmailHashAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmFindByEmailHash.afterFindByEmailHashCounter)
}

// FindByEmailHashBeforeCounter returns a count of UserRepositoryMock.FindByEmailHash invocations
func (mmFindByEmailHash *UserRepositoryMock) FindByEmailHashBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmFindByEmailHash.beforeFindByEmailHashCounter)
}

// Calls returns a list of arguments used in each call to UserRepositoryMock.FindByEmailHash.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) Calls() []*UserRepositoryMockFindByEmailHashParams {
	mmFindByEmailHash.mutex.RLock()

	argCopy := make([]*UserRepositoryMockFindByEmailHashParams, len(mmFindByEmailHash.callArgs))
	copy(argCopy, mmFindByEmailHash.callArgs)

	mmFindByEmailHash.mutex.RUnlock()

	return argCopy
}

// MinimockFindByEmailHashDone returns true if the count of the FindByEmailHash invocations corresponds
// the number of defined expectations
func (m *UserRepositoryMock) MinimockFindByEmailHashDone() bool {
	if m.FindByEmailHashMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.FindByEmailHashMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.FindByEmailHashMock.invocationsDone()
}

// MinimockFindByEmailHashInspect logs each unmet expectation
func (m *UserRepositoryMock) MinimockFindByEmailHashInspect() {
	for _, e := range m.FindByEmailHashMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to UserRepositoryMock.FindByEmailHash at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterFindByEmailHashCounter := mm_atomic.LoadUint64(&m.afterFindByEmailHashCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.FindByEmailHashMock.defaultExpectation != nil && afterFindByEmailHashCounter < 1 {
		if m.FindByEmailHashMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to UserRepositoryMock.FindByEmailHash at\n%s", m.FindByEmailHashMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to UserRepositoryMock.FindByEmailHash at\n%s with params: %#v", m.FindByEmailHashMock.defaultExpectation.expectationOrigins.origin, *m.FindByEmailHashMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcFindByEmailHash != nil && afterFindByEmailHashCounter < 1 {
		m.t.Errorf("Expected call to UserRepositoryMock.FindByEmailHash at\n%s", m.funcFindByEmailHashOrigin)
	}

	if !m.FindByEmailHashMock.invocationsDone() && afterFindByEmailHashCounter > 0 {
		m.t.Errorf("Expected %d calls to UserRepositoryMock.FindByEmailHash at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.FindByEmailHashMock.expectedInvocations), m.FindByEmailHashMock.expectedInvocationsOrigin, afterFindByEmailHashCounter)
	}
}

type mUserRepositoryMockFindByID struct {
	optional           bool
	mock               *UserRepositoryMock
	defaultExpectation *UserRepositoryMockFindByIDExpectation
	expectations       []*UserRepositoryMockFindByIDExpectation

	callArgs []*UserRepositoryMockFindByIDParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// UserRepositoryMockFindByIDExpectation specifies expectation struct of the UserRepository.FindByID
type UserRepositoryMockFindByIDExpectation struct {
	mock               *UserRepositoryMock
	params             *UserRepositoryMockFindByIDParams
	paramPtrs          *UserRepositoryMockFindByIDParamPtrs
	expectationOrigins UserRepositoryMockFindByIDExpectationOrigins
	results            *UserRepositoryMockFindByIDResults
	returnOrigin       string
	Counter            uint64
}

// UserRepositoryMockFindByIDParams contains parameters of the UserRepository.FindByID
type UserRepositoryMockFindByIDParams struct {
	ctx    context.Context
	userID int
}

// UserRepositoryMockFindByIDParamPtrs contains pointers to parameters of the UserRepository.FindByID
type UserRepositoryMockFindByIDParamPtrs struct {
	ctx    *context.Context
	userID *int
}

// UserRepositoryMockFindByIDResults contains results of the UserRepository.FindByID
type UserRepositoryMockFindByIDResults struct {
	up1 *model.User
	err error
}

// UserRepositoryMockFindByIDOrigins contains origins of expectations of the UserRepository.FindByID
type UserRepositoryMockFindByIDExpectationOrigins struct {
	origin       string
	originCtx    string
	originUserID string
}

// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
// Optional() makes method check to work in '0 or more' mode.
// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
// catch the problems when the expected method call is totally skipped during test run.
func (mmFindByID *mUserRepositoryMockFindByID) Optional() *mUserRepositoryMockFindByID {
	mmFindByID.optional = true
	return mmFindByID
}

// Expect sets up expected params for UserRepository.FindByID
func (mmFindByID *mUserRepositoryMockFindByID) Expect(ctx context.Context, userID int) *mUserRepositoryMockFindByID {
	if mmFindByID.mock.funcFindByID != nil {
		mmFindByID.mock.t.Fatalf("UserRepositoryMock.FindByID mock is already set by Set")
	}

	if mmFindByID.defaultExpectation == nil {
		mmFindByID.defaultExpectation = &UserRepositoryMockFindByIDExpectation{}
	}

	if mmFindByID.defaultExpectation.paramPtrs != nil {
		mmFindByID.mock.t.Fatalf("UserRepositoryMock.FindByID mock is already set by ExpectParams functions")
	}

	mmFindByID.defaultExpectation.params = &UserRepositoryMockFindByIDParams{ctx, userID}
	mmFindByID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmFindByID.expectations {
		if minimock.Equal(e.params, mmFindByID.defaultExpectation.params) {
			mmFindByID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmFindByID.defaultExpectation.params)
		}
	}

	return mmFindByID
}

// ExpectCtxParam1 sets up expected param ctx for UserRepository.FindByID
func (mmFindByID *mUserRepositoryMockFindByID) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockFindByID {
	if mmFindByID.mock.funcFindByID != nil {
		mmFindByID.mock.t.Fatalf("UserRepositoryMock.FindByID mock is already set by Set")
	}

	if mmFindByID.defaultExpectation == nil {
		mmFindByID.defaultExpectation = &UserRepositoryMockFindByIDExpectation{}
	}

	if mmFindByID.defaultExpectation.params != nil {
		mmFindByID.mock.t.Fatalf("UserRepositoryMock.FindByID mock is already set by Expect")
	}

	if mmFindByID.defaultExpectation.paramPtrs == nil {
		mmFindByID.defaultExpectation.paramPtrs = &UserRepositoryMockFindByIDParamPtrs{}
	}
	mmFindByID.defaultExpectation.paramPtrs.ctx = &ctx
	mmFindByID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmFindByID
}

// ExpectUserIDParam2 sets up expected param userID for UserRepository.FindByID
func (mmFindByID *mUserRepositoryMockFindByID) ExpectUserIDParam2(userID int) *mUserRepositoryMockFindByID {
	if mmFindByID.mock.funcFindByID != nil {
		mmFindByID.mock.t.Fatalf("UserRepositoryMock.FindByID mock is already set by Set")
	}

	if mmFindByID.defaultExpectation == nil {
		mmFindByID.defaultExpectation = &UserRepositoryMockFindByIDExpectation{}
	}

	if mmFindByID.defaultExpectation.params != nil {
		mmFindByID.mock.t.Fatalf("UserRepositoryMock.FindByID mock is already set by Expect")
	}

	if mmFindByID.defaultExpectation.paramPtrs == nil {
		mmFindByID.defaultExpectation.paramPtrs = &UserRepositoryMockFindByIDParamPtrs{}
	}
	mmFindByID.defaultExpectation.paramPtrs.userID = &userID
	mmFindByID.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)

	return mmFindByID
}

// Inspect accepts an inspector function that has same arguments as the UserRepository.FindByID
func (mmFindByID *mUserRepositoryMockFindByID) Inspect(f func(ctx context.Context, userID int)) *mUserRepositoryMockFindByID {
	if mmFindByID.mock.inspectFuncFindByID != nil {
		mmFindByID.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.FindByID")
	}

	mmFindByID.mock.inspectFuncFindByID = f

	return mmFindByID
}

// Return sets up results that will be returned by UserRepository.FindByID
func (mmFindByID *mUserRepositoryMockFindByID) Return(up1 *model.User, err error) *UserRepositoryMock {
	if mmFindByID.mock.funcFindByID != nil {
		mmFindByID.mock.t.Fatalf("UserRepositoryMock.FindByID mock is already set by Set")
	}

	if mmFindByID.defaultExpectation == nil {
		mmFindByID.defaultExpectation = &UserRepositoryMockFindByIDExpectation{mock: mmFindByID.mock}
	}
	mmFindByID.defaultExpectation.results = &UserRepositoryMockFindByIDResults{up1, err}
	mmFindByID.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmFindByID.mock
}

// Set uses given function f to mock the UserRepository.FindByID method
func (mmFindByID *mUserRepositoryMockFindByID) Set(f func(ctx context.Context, userID int) (up1 *model.User, err error)) *UserRepositoryMock {
	if mmFindByID.defaultExpectation != nil {
		mmFindByID.mock.t.Fatalf("Default expectation is already set for the UserRepository.FindByID method")
	}

	if len(mmFindByID.expectations) > 0 {
		mmFindByID.mock.t.Fatalf("Some expectations are already set for the UserRepository.FindByID method")
	}

	mmFindByID.mock.funcFindByID = f
	mmFindByID.mock.funcFindByIDOrigin = minimock.CallerInfo(1)
	return mmFindByID.mock
}

// When sets expectation for the UserRepository.FindByID which will trigger the result defined by the following
// Then helper
func (mmFindByID *mUserRepositoryMockFindByID) When(ctx context.Context, userID int) *UserRepositoryMockFindByIDExpectation {
	if mmFindByID.mock.funcFindByID != nil {
		mmFindByID.mock.t.Fatalf("UserRepositoryMock.FindByID mock is already set by Set")
	}

	expectation := &UserRepositoryMockFindByIDExpectation{
		mock:               mmFindByID.mock,
		params:             &UserRepositoryMockFindByIDParams{ctx, userID},
		expectationOrigins: UserRepositoryMockFindByIDExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmFindByID.expectations = append(mmFindByID.expectations, expectation)
	return expectation
}

// Then sets up UserRepository.FindByID return parameters for the expectation previously defined by the When method
func (e *UserRepositoryMockFindByIDExpectation) Then(up1 *model.User, err error) *UserRepositoryMock {
	e.results = &UserRepositoryMockFindByIDResults{up1, err}
	return e.mock
}

// Times sets number of times UserRepository.FindByID should be invoked
func (mmFindByID *mUserRepositoryMockFindByID) Times(n uint64) *mUserRepositoryMockFindByID {
	if n == 0 {
		mmFindByID.mock.t.Fatalf("Times of UserRepositoryMock.FindByID mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmFindByID.expectedInvocations, n)
	mmFindByID.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmFindByID
}

func (mmFindByID *mUserRepositoryMockFindByID) invocationsDone() bool {
	if len(mmFindByID.expectations) == 0 && mmFindByID.defaultExpectation == nil && mmFindByID.mock.funcFindByID == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmFindByID.mock.afterFindByIDCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmFindByID.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// FindByID implements mm_repository.UserRepository
func (mmFindByID *UserRepositoryMock) FindByID(ctx context.Context, userID int) (up1 *model.User, err error) {
	mm_atomic.AddUint64(&mmFindByID.beforeFindByIDCounter, 1)
	defer mm_atomic.AddUint64(&mmFindByID.afterFindByIDCounter, 1)

	mmFindByID.t.Helper()

	if mmFindByID.inspectFuncFindByID != nil {
		mmFindByID.inspectFuncFindByID(ctx, userID)
	}

	mm_params := UserRepositoryMockFindByIDParams{ctx, userID}

	// Record call args
	mmFindByID.FindByIDMock.mutex.Lock()
	mmFindByID.FindByIDMock.callArgs = append(mmFindByID.FindByIDMock.callArgs, &mm_params)
	mmFindByID.FindByIDMock.mutex.Unlock()

	for _, e := range mmFindByID.FindByIDMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.up1, e.results.err
		}
	}

	if mmFindByID.FindByIDMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmFindByID.FindByIDMock.defaultExpectation.Counter, 1)
		mm_want := mmFindByID.FindByIDMock.defaultExpectation.params
		mm_want_ptrs := mmFindByID.FindByIDMock.defaultExpectation.paramPtrs

		mm_got := UserRepositoryMockFindByIDParams{ctx, userID}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmFindByID.t.Errorf("UserRepositoryMock.FindByID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmFindByID.FindByIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
			}

			if mm_want_ptrs.userID != nil && !minimock.Equal(*mm_want_ptrs.userID, mm_got.userID) {
				mmFindByID.t.Errorf("UserRepositoryMock.FindByID got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmFindByID.FindByIDMock.defaultExpectation.expectationOrigins.originUserID, *mm_want_ptrs.userID, mm_got.userID, minimock.Diff(*mm_want_ptrs.userID, mm_got.userID))
			}

		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmFindByID.t.Errorf("UserRepositoryMock.FindByID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmFindByID.FindByIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmFindByID.FindByIDMock.defaultExpectation.results
		if mm_results == nil {
			mmFindByID.t.Fatal("No results are set for the UserRepositoryMock.FindByID")
		}
		return (*mm_results).up1, (*mm_results).err
	}
	if mmFindByID.funcFindByID != nil {
		return mmFindByID.funcFindByID(ctx, userID)
	}
	mmFindByID.t.Fatalf("Unexpected call to UserRepositoryMock.FindByID. %v %v", ctx, userID)
	return
}

// FindByIDAfterCounter returns a count of finished UserRepositoryMock.FindByID invocations
func (mmFindByID *UserRepositoryMock) FindByIDAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmFindByID.afterFindByIDCounter)
}

// FindByIDBeforeCounter returns a count of UserRepositoryMock.FindByID invocations
func (mmFindByID *UserRepositoryMock) FindByIDBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmFindByID.beforeFindByIDCounter)
}

// Calls returns a list of arguments used in each call to UserRepositoryMock.FindByID.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmFindByID *mUserRepositoryMockFindByID) Calls() []*UserRepositoryMockFindByIDParams {
	mmFindByID.mutex.RLock()

	argCopy := make([]*UserRepositoryMockFindByIDParams, len(mmFindByID.callArgs))
	copy(argCopy, mmFindByID.callArgs)

	mmFindByID.mutex.RUnlock()

	return argCopy
}

// MinimockFindByIDDone returns true if the count of the FindByID invocations corresponds
// the number of defined expectations
func (m *UserRepositoryMock) MinimockFindByIDDone() bool {
	if m.FindByIDMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.FindByIDMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.FindByIDMock.invocationsDone()
}

// MinimockFindByIDInspect logs each unmet expectation
func (m *UserRepositoryMock) MinimockFindByIDInspect() {
	for _, e := range m.FindByIDMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to UserRepositoryMock.FindByID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterFindByIDCounter := mm_atomic.LoadUint64(&m.afterFindByIDCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.FindByIDMock.defaultExpectation != nil && afterFindByIDCounter < 1 {
		if m.FindByIDMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to UserRepositoryMock.FindByID at\n%s", m.FindByIDMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to UserRepositoryMock.FindByID at\n%s with params: %#v", m.FindByIDMock.defaultExpectation.expectationOrigins.origin, *m.FindByIDMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcFindByID != nil && afterFindByIDCounter < 1 {
		m.t.Errorf("Expected call to UserRepositoryMock.FindByID at\n%s", m.funcFindByIDOrigin)
	}

	if !m.FindByIDMock.invocationsDone() && afterFindByIDCounter > 0 {
		m.t.Errorf("Expected %d calls to UserRepositoryMock.FindByID at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.FindByIDMock.expectedInvocations), m.FindByIDMock.expectedInvocationsOrigin, afterFindByIDCounter)
	}
}

type mUserRepositoryMockGetBalance struct {
	optional           bool
	mock               *UserRepositoryMock
	defaultExpectation *UserRepositoryMockGetBalanceExpectation
	expectations       []*UserRepositoryMockGetBalanceExpectation

	callArgs []*UserRepositoryMockGetBalanceParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// UserRepositoryMockGetBalanceExpectation specifies expectation struct of the UserRepository.GetBalance
type UserRepositoryMockGetBalanceExpectation struct {
	mock               *UserRepositoryMock
	params             *UserRepositoryMockGetBalanceParams
	paramPtrs          *UserRepositoryMockGetBalanceParamPtrs
	expectationOrigins UserRepositoryMockGetBalanceExpectationOrigins
	results            *UserRepositoryMockGetBalanceResults
	returnOrigin       string
	Counter            uint64
}

// UserRepositoryMockGetBalanceParams contains parameters of the UserRepository.GetBalance
type UserRepositoryMockGetBalanceParams struct {
	ctx    context.Context
	userID int
}

// UserRepositoryMockGetBalanceParamPtrs contains pointers to parameters of the UserRepository.GetBalance
type UserRepositoryMockGetBalanceParamPtrs struct {
	ctx    *context.Context
	userID *int
}

// UserRepositoryMockGetBalanceResults contains results of the UserRepository.GetBalance
type UserRepositoryMockGetBalanceResults struct {
	f1  float64
	err error
}

// UserRepositoryMockGetBalanceOrigins contains origins of expectations of the UserRepository.GetBalance
type UserRepositoryMockGetBalanceExpectationOrigins struct {
	origin       string
	originCtx    string
	originUserID string
}

// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
// Optional() makes method check to work in '0 or more' mode.
// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
// catch the problems when the expected method call is totally skipped during test run.
func (mmGetBalance *mUserRepositoryMockGetBalance) Optional() *mUserRepositoryMockGetBalance {
	mmGetBalance.optional = true
	return mmGetBalance
}

// Expect sets up expected params for UserRepository.GetBalance
func (mmGetBalance *mUserRepositoryMockGetBalance) Expect(ctx context.Context, userID int) *mUserRepositoryMockGetBalance {
	if mmGetBalance.mock.funcGetBalance != nil {
		mmGetBalance.mock.t.Fatalf("UserRepositoryMock.GetBalance mock is already set by Set")
	}

	if mmGetBalance.defaultExpectation == nil {
		mmGetBalance.defaultExpectation = &UserRepositoryMockGetBalanceExpectation{}
	}

	if mmGetBalance.defaultExpectation.paramPtrs != nil {
		mmGetBalance.mock.t.Fatalf("UserRepositoryMock.GetBalance mock is already set by ExpectParams functions")
	}

	mmGetBalance.defaultExpectation.params = &UserRepositoryMockGetBalanceParams{ctx, userID}
	mmGetBalance.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmGetBalance.expectations {
		if minimock.Equal(e.params, mmGetBalance.defaultExpectation.params) {
			mmGetBalance.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetBalance.defaultExpectation.params)
		}
	}

	return mmGetBalance
}

// ExpectCtxParam1 sets up expected param ctx for UserRepository.GetBalance
func (mmGetBalance *mUserRepositoryMockGetBalance) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockGetBalance {
	if mmGetBalance.mock.funcGetBalance != nil {
		mmGetBalance.mock.t.Fatalf("UserRepositoryMock.GetBalance mock is already set by Set")
	}

	if mmGetBalance.defaultExpectation == nil {
		mmGetBalance.defaultExpectation = &UserRepositoryMockGetBalanceExpectation{}
	}

	if mmGetBalance.defaultExpectation.params != nil {
		mmGetBalance.mock.t.Fatalf("UserRepositoryMock.GetBalance mock is already set by Expect")
	}

	if mmGetBalance.defaultExpectation.paramPtrs == nil {
		mmGetBalance.defaultExpectation.paramPtrs = &UserRepositoryMockGetBalanceParamPtrs{}
	}
	mmGetBalance.defaultExpectation.paramPtrs.ctx = &ctx
	mmGetBalance.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmGetBalance
}

// ExpectUserIDParam2 sets up expected param userID for UserRepository.GetBalance
func (mmGetBalance *mUserRepositoryMockGetBalance) ExpectUserIDParam2(userID int) *mUserRepositoryMockGetBalance {
	if mmGetBalance.mock.funcGetBalance != nil {
		mmGetBalance.mock.t.Fatalf("UserRepositoryMock.GetBalance mock is already set by Set")
	}

	if mmGetBalance.defaultExpectation == nil {
		mmGetBalance.defaultExpectation = &UserRepositoryMockGetBalanceExpectation{}
	}

	if mmGetBalance.defaultExpectation.params != nil {
		mmGetBalance.mock.t.Fatalf("UserRepositoryMock.GetBalance mock is already set by Expect")
	}

	if mmGetBalance.defaultExpectation.paramPtrs == nil {
		mmGetBalance.defaultExpectation.paramPtrs = &UserRepositoryMockGetBalanceParamPtrs{}
	}
	mmGetBalance.defaultExpectation.paramPtrs.userID = &userID
	mmGetBalance.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)

	return mmGetBalance
}

// Inspect accepts an inspector function that has same arguments as the UserRepository.GetBalance
func (mmGetBalance *mUserRepositoryMockGetBalance) Inspect(f func(ctx context.Context, userID int)) *mUserRepositoryMockGetBalance {
	if mmGetBalance.mock.inspectFuncGetBalance != nil {
		mmGetBalance.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.GetBalance")
	}

	mmGetBalance.mock.inspectFuncGetBalance = f

	return mmGetBalance
}

// Return sets up results that will be returned by UserRepository.GetBalance
func (mmGetBalance *mUserRepositoryMockGetBalance) Return(f1 float64, err error) *UserRepositoryMock {
	if mmGetBalance.mock.funcGetBalance != nil {
		mmGetBalance.mock.t.Fatalf("UserRepositoryMock.GetBalance mock is already set by Set")
	}

	if mmGetBalance.defaultExpectation == nil {
		mmGetBalance.defaultExpectation = &UserRepositoryMockGetBalanceExpectation{mock: mmGetBalance.mock}
	}
	mmGetBalance.defaultExpectation.results = &UserRepositoryMockGetBalanceResults{f1, err}
	mmGetBalance.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmGetBalance.mock
}

// Set uses given function f to mock the UserRepository.GetBalance method
func (mmGetBalance *mUserRepositoryMockGetBalance) Set(f func(ctx context.Context, userID int) (f1 float64, err error)) *UserRepositoryMock {
	if mmGetBalance.defaultExpectation != nil {
		mmGetBalance.mock.t.Fatalf("Default expectation is already set for the UserRepository.GetBalance method")
	}

	if len(mmGetBalance.expectations) > 0 {
		mmGetBalance.mock.t.Fatalf("Some expectations are already set for the UserRepository.GetBalance method")
	}

	mmGetBalance.mock.funcGetBalance = f
	mmGetBalance.mock.funcGetBalanceOrigin = minimock.CallerInfo(1)
	return mmGetBalance.mock
}

// When sets expectation for the UserRepository.GetBalance which will trigger the result defined by the following
// Then helper
func (mmGetBalance *mUserRepositoryMockGetBalance) When(ctx context.Context, userID int) *UserRepositoryMockGetBalanceExpectation {
	if mmGetBalance.mock.funcGetBalance != nil {
		mmGetBalance.mock.t.Fatalf("UserRepositoryMock.GetBalance mock is already set by Set")
	}

	expectation := &UserRepositoryMockGetBalanceExpectation{
		mock:               mmGetBalance.mock,
		params:             &UserRepositoryMockGetBalanceParams{ctx, userID},
		expectationOrigins: UserRepositoryMockGetBalanceExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmGetBalance.expectations = append(mmGetBalance.expectations, expectation)
	return expectation
}

// Then sets up UserRepository.GetBalance return parameters for the expectation previously defined by the When method
func (e *UserRepositoryMockGetBalanceExpectation) Then(f1 float64, err error) *UserRepositoryMock {
	e.results = &UserRepositoryMockGetBalanceResults{f1, err}
	return e.mock
}

// Times sets number of times UserRepository.GetBalance should be invoked
func (mmGetBalance *mUserRepositoryMockGetBalance) Times(n uint64) *mUserRepositoryMockGetBalance {
	if n == 0 {
		mmGetBalance.mock.t.Fatalf("Times of UserRepositoryMock.GetBalance mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmGetBalance.expectedInvocations, n)
	mmGetBalance.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmGetBalance
}

func (mmGetBalance *mUserRepositoryMockGetBalance) invocationsDone() bool {
	if len(mmGetBalance.expectations) == 0 && mmGetBalance.defaultExpectation == nil && mmGetBalance.mock.funcGetBalance == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmGetBalance.mock.afterGetBalanceCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmGetBalance.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// GetBalance implements mm_repository.UserRepository
func (mmGetBalance *UserRepositoryMock) GetBalance(ctx context.Context, userID int) (f1 float64, err error) {
	mm_atomic.AddUint64(&mmGetBalance.beforeGetBalanceCounter, 1)
	defer mm_atomic.AddUint64(&mmGetBalance.afterGetBalanceCounter, 1)

	mmGetBalance.t.Helper()

	if mmGetBalance.inspectFuncGetBalance != nil {
		mmGetBalance.inspectFuncGetBalance(ctx, userID)
	}

	mm_params := UserRepositoryMockGetBalanceParams{ctx, userID}

	// Record call args
	mmGetBalance.GetBalanceMock.mutex.Lock()
	mmGetBalance.GetBalanceMock.callArgs = append(mmGetBalance.GetBalanceMock.callArgs, &mm_params)
	mmGetBalance.GetBalanceMock.mutex.Unlock()

	for _, e := range mmGetBalance.GetBalanceMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.f1, e.results.err
		}
	}

	if mmGetBalance.GetBalanceMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmGetBalance.GetBalanceMock.defaultExpectation.Counter, 1)
		mm_want := mmGetBalance.GetBalanceMock.defaultExpectation.params
		mm_want_ptrs := mmGetBalance.GetBalanceMock.defaultExpectation.paramPtrs

		mm_got := UserRepositoryMockGetBalanceParams{ctx, userID}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmGetBalance.t.Errorf("UserRepositoryMock.GetBalance got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmGetBalance.GetBalanceMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
			}

			if mm_want_ptrs.userID != nil && !minimock.Equal(*mm_want_ptrs.userID, mm_got.userID) {
				mmGetBalance.t.Errorf("UserRepositoryMock.GetBalance got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmGetBalance.GetBalanceMock.defaultExpectation.expectationOrigins.originUserID, *mm_want_ptrs.userID, mm_got.userID, minimock.Diff(*mm_want_ptrs.userID, mm_got.userID))
			}

		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmGetBalance.t.Errorf("UserRepositoryMock.GetBalance got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmGetBalance.GetBalanceMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmGetBalance.GetBalanceMock.defaultExpectation.results
		if mm_results == nil {
			mmGetBalance.t.Fatal("No results are set for the UserRepositoryMock.GetBalance")
		}
		return (*mm_results).f1, (*mm_results).err
	}
	if mmGetBalance.funcGetBalance != nil {
		return mmGetBalance.funcGetBalance(ctx, userID)
	}
	mmGetBalance.t.Fatalf("Unexpected call to UserRepositoryMock.GetBalance. %v %v", ctx, userID)
	return
}

// GetBalanceAfterCounter returns a count of finished UserRepositoryMock.GetBalance invocations
func (mmGetBalance *UserRepositoryMock) GetBalanceAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGetBalance.afterGetBalanceCounter)
}

// GetBalanceBeforeCounter returns a count of UserRepositoryMock.GetBalance invocations
func (mmGetBalance *UserRepositoryMock) GetBalanceBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGetBalance.beforeGetBalanceCounter)
}

// Calls returns a list of arguments used in each call to UserRepositoryMock.GetBalance.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmGetBalance *mUserRepositoryMockGetBalance) Calls() []*UserRepositoryMockGetBalanceParams {
	mmGetBalance.mutex.RLock()

	argCopy := make([]*UserRepositoryMockGetBalanceParams, len(mmGetBalance.callArgs))
	copy(argCopy, mmGetBalance.callArgs)

	mmGetBalance.mutex.RUnlock()

	return argCopy
}

// MinimockGetBalanceDone returns true if the count of the GetBalance invocations corresponds
// the number of defined expectations
func (m *UserRepositoryMock) MinimockGetBalanceDone() bool {
	if m.GetBalanceMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.GetBalanceMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.GetBalanceMock.invocationsDone()
}

// MinimockGetBalanceInspect logs each unmet expectation
func (m *UserRepositoryMock) MinimockGetBalanceInspect() {
	for _, e := range m.GetBalanceMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to UserRepositoryMock.GetBalance at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterGetBalanceCounter := mm_atomic.LoadUint64(&m.afterGetBalanceCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.GetBalanceMock.defaultExpectation != nil && afterGetBalanceCounter < 1 {
		if m.GetBalanceMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to UserRepositoryMock.GetBalance at\n%s", m.GetBalanceMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to UserRepositoryMock.GetBalance at\n%s with params: %#v", m.GetBalanceMock.defaultExpectation.expectationOrigins.origin, *m.GetBalanceMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcGetBalance != nil && afterGetBalanceCounter < 1 {
		m.t.Errorf("Expected call to UserRepositoryMock.GetBalance at\n%s", m.funcGetBalanceOrigin)
	}

	if !m.GetBalanceMock.invocationsDone() && afterGetBalanceCounter > 0 {
		m.t.Errorf("Expected %d calls to UserRepositoryMock.GetBalance at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.GetBalanceMock.expectedInvocations), m.GetBalanceMock.expectedInvocationsOrigin, afterGetBalanceCounter)
	}
}

type mUserRepositoryMockIncrementInvitesIssued struct {
	optional           bool
	mock               *UserRepositoryMock
	defaultExpectation *UserRepositoryMockIncrementInvitesIssuedExpectation
	expectations       []*UserRepositoryMockIncrementInvitesIssuedExpectation

	callArgs []*UserRepositoryMockIncrementInvitesIssuedParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// UserRepositoryMockIncrementInvitesIssuedExpectation specifies expectation struct of the UserRepository.IncrementInvitesIssued
type UserRepositoryMockIncrementInvitesIssuedExpectation struct {
	mock               *UserRepositoryMock
	params             *UserRepositoryMockIncrementInvitesIssuedParams
	paramPtrs          *UserRepositoryMockIncrementInvitesIssuedParamPtrs
	expectationOrigins UserRepositoryMockIncrementInvitesIssuedExpectationOrigins
	results            *UserRepositoryMockIncrementInvitesIssuedResults
	returnOrigin       string
	Counter            uint64
}

// UserRepositoryMockIncrementInvitesIssuedParams contains parameters of the UserRepository.IncrementInvitesIssued
type UserRepositoryMockIncrementInvitesIssuedParams struct {
	ctx    context.Context
	userID int
}

// UserRepositoryMockIncrementInvitesIssuedParamPtrs contains pointers to parameters of the UserRepository.IncrementInvitesIssued
type UserRepositoryMockIncrementInvitesIssuedParamPtrs struct {
	ctx    *context.Context
	userID *int
}

// UserRepositoryMockIncrementInvitesIssuedResults contains results of the UserRepository.IncrementInvitesIssued
type UserRepositoryMockIncrementInvitesIssuedResults struct {
	err error
}

// UserRepositoryMockIncrementInvitesIssuedOrigins contains origins of expectations of the UserRepository.IncrementInvitesIssued
type UserRepositoryMockIncrementInvitesIssuedExpectationOrigins struct {
	origin       string
	originCtx    string
	originUserID string
}

// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
// Optional() makes method check to work in '0 or more' mode.
// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
// catch the problems when the expected method call is totally skipped during test run.
func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) Optional() *mUserRepositoryMockIncrementInvitesIssued {
	mmIncrementInvitesIssued.optional = true
	return mmIncrementInvitesIssued
}

// Expect sets up expected params for UserRepository.IncrementInvitesIssued
func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) Expect(ctx context.Context, userID int) *mUserRepositoryMockIncrementInvitesIssued {
	if mmIncrementInvitesIssued.mock.funcIncrementInvitesIssued != nil {
		mmIncrementInvitesIssued.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssued mock is already set by Set")
	}

	if mmIncrementInvitesIssued.defaultExpectation == nil {
		mmIncrementInvitesIssued.defaultExpectation = &UserRepositoryMockIncrementInvitesIssuedExpectation{}
	}

	if mmIncrementInvitesIssued.defaultExpectation.paramPtrs != nil {
		mmIncrementInvitesIssued.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssued mock is already set by ExpectParams functions")
	}

	mmIncrementInvitesIssued.defaultExpectation.params = &UserRepositoryMockIncrementInvitesIssuedParams{ctx, userID}
	mmIncrementInvitesIssued.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmIncrementInvitesIssued.expectations {
		if minimock.Equal(e.params, mmIncrementInvitesIssued.defaultExpectation.params) {
			mmIncrementInvitesIssued.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmIncrementInvitesIssued.defaultExpectation.params)
		}
	}

	return mmIncrementInvitesIssued
}

// ExpectCtxParam1 sets up expected param ctx for UserRepository.IncrementInvitesIssued
func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockIncrementInvitesIssued {
	if mmIncrementInvitesIssued.mock.funcIncrementInvitesIssued != nil {
		mmIncrementInvitesIssued.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssued mock is already set by Set")
	}

	if mmIncrementInvitesIssued.defaultExpectation == nil {
		mmIncrementInvitesIssued.defaultExpectation = &UserRepositoryMockIncrementInvitesIssuedExpectation{}
	}

	if mmIncrementInvitesIssued.defaultExpectation.params != nil {
		mmIncrementInvitesIssued.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssued mock is already set by Expect")
	}

	if mmIncrementInvitesIssued.defaultExpectation.paramPtrs == nil {
		mmIncrementInvitesIssued.defaultExpectation.paramPtrs = &UserRepositoryMockIncrementInvitesIssuedParamPtrs{}
	}
	mmIncrementInvitesIssued.defaultExpectation.paramPtrs.ctx = &ctx
	mmIncrementInvitesIssued.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmIncrementInvitesIssued
}

// ExpectUserIDParam2 sets up expected param userID for UserRepository.IncrementInvitesIssued
func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) ExpectUserIDParam2(userID int) *mUserRepositoryMockIncrementInvitesIssued {
	if mmIncrementInvitesIssued.mock.funcIncrementInvitesIssued != nil {
		mmIncrementInvitesIssued.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssued mock is already set by Set")
	}

	if mmIncrementInvitesIssued.defaultExpectation == nil {
		mmIncrementInvitesIssued.defaultExpectation = &UserRepositoryMockIncrementInvitesIssuedExpectation{}
	}

	if mmIncrementInvitesIssued.defaultExpectation.params != nil {
		mmIncrementInvitesIssued.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssued mock is already set by Expect")
	}

	if mmIncrementInvitesIssued.defaultExpectation.paramPtrs == nil {
		mmIncrementInvitesIssued.defaultExpectation.paramPtrs = &UserRepositoryMockIncrementInvitesIssuedParamPtrs{}
	}
	mmIncrementInvitesIssued.defaultExpectation.paramPtrs.userID = &userID
	mmIncrementInvitesIssued.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)

	return mmIncrementInvitesIssued
}

// Inspect accepts an inspector function that has same arguments as the UserRepository.IncrementInvitesIssued
func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) Inspect(f func(ctx context.Context, userID int)) *mUserRepositoryMockIncrementInvitesIssued {
	if mmIncrementInvitesIssued.mock.inspectFuncIncrementInvitesIssued != nil {
		mmIncrementInvitesIssued.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.IncrementInvitesIssued")
	}

	mmIncrementInvitesIssued.mock.inspectFuncIncrementInvitesIssued = f

	return mmIncrementInvitesIssued
}

// Return sets up results that will be returned by UserRepository.IncrementInvitesIssued
func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) Return(err error) *UserRepositoryMock {
	if mmIncrementInvitesIssued.mock.funcIncrementInvitesIssued != nil {
		mmIncrementInvitesIssued.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssued mock is already set by Set")
	}

	if mmIncrementInvitesIssued.defaultExpectation == nil {
		mmIncrementInvitesIssued.defaultExpectation = &UserRepositoryMockIncrementInvitesIssuedExpectation{mock: mmIncrementInvitesIssued.mock}
	}
	mmIncrementInvitesIssued.defaultExpectation.results = &UserRepositoryMockIncrementInvitesIssuedResults{err}
	mmIncrementInvitesIssued.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmIncrementInvitesIssued.mock
}

// Set uses given function f to mock the UserRepository.IncrementInvitesIssued method
func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) Set(f func(ctx context.Context, userID int) (err error)) *UserRepositoryMock {
	if mmIncrementInvitesIssued.defaultExpectation != nil {
		mmIncrementInvitesIssued.mock.t.Fatalf("Default expectation is already set for the UserRepository.IncrementInvitesIssued method")
	}

	if len(mmIncrementInvitesIssued.expectations) > 0 {
		mmIncrementInvitesIssued.mock.t.Fatalf("Some expectations are already set for the UserRepository.IncrementInvitesIssued method")
	}

	mmIncrementInvitesIssued.mock.funcIncrementInvitesIssued = f
	mmIncrementInvitesIssued.mock.funcIncrementInvitesIssuedOrigin = minimock.CallerInfo(1)
	return mmIncrementInvitesIssued.mock
}

// When sets expectation for the UserRepository.IncrementInvitesIssued which will trigger the result defined by the following
// Then helper
func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) When(ctx context.Context, userID int) *UserRepositoryMockIncrementInvitesIssuedExpectation {
	if mmIncrementInvitesIssued.mock.funcIncrementInvitesIssued != nil {
		mmIncrementInvitesIssued.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssued mock is already set by Set")
	}

	expectation := &UserRepositoryMockIncrementInvitesIssuedExpectation{
		mock:               mmIncrementInvitesIssued.mock,
		params:             &UserRepositoryMockIncrementInvitesIssuedParams{ctx, userID},
		expectationOrigins: UserRepositoryMockIncrementInvitesIssuedExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmIncrementInvitesIssued.expectations = append(mmIncrementInvitesIssued.expectations, expectation)
	return expectation
}

// Then sets up UserRepository.IncrementInvitesIssued return parameters for the expectation previously defined by the When method
func (e *UserRepositoryMockIncrementInvitesIssuedExpectation) Then(err error) *UserRepositoryMock {
	e.results = &UserRepositoryMockIncrementInvitesIssuedResults{err}
	return e.mock
}

// Times sets number of times UserRepository.IncrementInvitesIssued should be invoked
func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) Times(n uint64) *mUserRepositoryMockIncrementInvitesIssued {
	if n == 0 {
		mmIncrementInvitesIssued.mock.t.Fatalf("Times of UserRepositoryMock.IncrementInvitesIssued mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmIncrementInvitesIssued.expectedInvocations, n)
	mmIncrementInvitesIssued.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmIncrementInvitesIssued
}

func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) invocationsDone() bool {
	if len(mmIncrementInvitesIssued.expectations) == 0 && mmIncrementInvitesIssued.defaultExpectation == nil && mmIncrementInvitesIssued.mock.funcIncrementInvitesIssued == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmIncrementInvitesIssued.mock.afterIncrementInvitesIssuedCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmIncrementInvitesIssued.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// IncrementInvitesIssued implements mm_repository.UserRepository
func (mmIncrementInvitesIssued *UserRepositoryMock) IncrementInvitesIssued(ctx context.Context, userID int) (err error) {
	mm_atomic.AddUint64(&mmIncrementInvitesIssued.beforeIncrementInvitesIssuedCounter, 1)
	defer mm_atomic.AddUint64(&mmIncrementInvitesIssued.afterIncrementInvitesIssuedCounter, 1)

	mmIncrementInvitesIssued.t.Helper()

	if mmIncrementInvitesIssued.inspectFuncIncrementInvitesIssued != nil {
		mmIncrementInvitesIssued.inspectFuncIncrementInvitesIssued(ctx, userID)
	}

	mm_params := UserRepositoryMockIncrementInvitesIssuedParams{ctx, userID}

	// Record call args
	mmIncrementInvitesIssued.IncrementInvitesIssuedMock.mutex.Lock()
	mmIncrementInvitesIssued.IncrementInvitesIssuedMock.callArgs = append(mmIncrementInvitesIssued.IncrementInvitesIssuedMock.callArgs, &mm_params)
	mmIncrementInvitesIssued.IncrementInvitesIssuedMock.mutex.Unlock()

	for _, e := range mmIncrementInvitesIssued.IncrementInvitesIssuedMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.err
		}
	}

	if mmIncrementInvitesIssued.IncrementInvitesIssuedMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmIncrementInvitesIssued.IncrementInvitesIssuedMock.defaultExpectation.Counter, 1)
		mm_want := mmIncrementInvitesIssued.IncrementInvitesIssuedMock.defaultExpectation.params
		mm_want_ptrs := mmIncrementInvitesIssued.IncrementInvitesIssuedMock.defaultExpectation.paramPtrs

		mm_got := UserRepositoryMockIncrementInvitesIssuedParams{ctx, userID}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmIncrementInvitesIssued.t.Errorf("UserRepositoryMock.IncrementInvitesIssued got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmIncrementInvitesIssued.IncrementInvitesIssuedMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
			}

			if mm_want_ptrs.userID != nil && !minimock.Equal(*mm_want_ptrs.userID, mm_got.userID) {
				mmIncrementInvitesIssued.t.Errorf("UserRepositoryMock.IncrementInvitesIssued got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmIncrementInvitesIssued.IncrementInvitesIssuedMock.defaultExpectation.expectationOrigins.originUserID, *mm_want_ptrs.userID, mm_got.userID, minimock.Diff(*mm_want_ptrs.userID, mm_got.userID))
			}

		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmIncrementInvitesIssued.t.Errorf("UserRepositoryMock.IncrementInvitesIssued got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmIncrementInvitesIssued.IncrementInvitesIssuedMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmIncrementInvitesIssued.IncrementInvitesIssuedMock.defaultExpectation.results
		if mm_results == nil {
			mmIncrementInvitesIssued.t.Fatal("No results are set for the UserRepositoryMock.IncrementInvitesIssued")
		}
		return (*mm_results).err
	}
	if mmIncrementInvitesIssued.funcIncrementInvitesIssued != nil {
		return mmIncrementInvitesIssued.funcIncrementInvitesIssued(ctx, userID)
	}
	mmIncrementInvitesIssued.t.Fatalf("Unexpected call to UserRepositoryMock.IncrementInvitesIssued. %v %v", ctx, userID)
	return
}

// IncrementInvitesIssuedAfterCounter returns a count of finished UserRepositoryMock.IncrementInvitesIssued invocations
func (mmIncrementInvitesIssued *UserRepositoryMock) IncrementInvitesIssuedAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmIncrementInvitesIssued.afterIncrementInvitesIssuedCounter)
}

// IncrementInvitesIssuedBeforeCounter returns a count of UserRepositoryMock.IncrementInvitesIssued invocations
func (mmIncrementInvitesIssued *UserRepositoryMock) IncrementInvitesIssuedBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmIncrementInvitesIssued.beforeIncrementInvitesIssuedCounter)
}

// Calls returns a list of arguments used in each call to UserRepositoryMock.IncrementInvitesIssued.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) Calls() []*UserRepositoryMockIncrementInvitesIssuedParams {
	mmIncrementInvitesIssued.mutex.RLock()

	argCopy := make([]*UserRepositoryMockIncrementInvitesIssuedParams, len(mmIncrementInvitesIssued.callArgs))
	copy(argCopy, mmIncrementInvitesIssued.callArgs)

	mmIncrementInvitesIssued.mutex.RUnlock()

	return argCopy
}

// MinimockIncrementInvitesIssuedDone returns true if the count of the IncrementInvitesIssued invocations corresponds
// the number of defined expectations
func (m *UserRepositoryMock) MinimockIncrementInvitesIssuedDone() bool {
	if m.IncrementInvitesIssuedMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.IncrementInvitesIssuedMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.IncrementInvitesIssuedMock.invocationsDone()
}

// MinimockIncrementInvitesIssuedInspect logs each unmet expectation
func (m *UserRepositoryMock) MinimockIncrementInvitesIssuedInspect() {
	for _, e := range m.IncrementInvitesIssuedMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to UserRepositoryMock.IncrementInvitesIssued at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterIncrementInvitesIssuedCounter := mm_atomic.LoadUint64(&m.afterIncrementInvitesIssuedCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.IncrementInvitesIssuedMock.defaultExpectation != nil && afterIncrementInvitesIssuedCounter < 1 {
		if m.IncrementInvitesIssuedMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to UserRepositoryMock.IncrementInvitesIssued at\n%s", m.IncrementInvitesIssuedMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to UserRepositoryMock.IncrementInvitesIssued at\n%s with params: %#v", m.IncrementInvitesIssuedMock.defaultExpectation.expectationOrigins.origin, *m.IncrementInvitesIssuedMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcIncrementInvitesIssued != nil && afterIncrementInvitesIssuedCounter < 1 {
		m.t.Errorf("Expected call to UserRepositoryMock.IncrementInvitesIssued at\n%s", m.funcIncrementInvitesIssuedOrigin)
	}

	if !m.IncrementInvitesIssuedMock.invocationsDone() && afterIncrementInvitesIssuedCounter > 0 {
		m.t.Errorf("Expected %d calls to UserRepositoryMock.IncrementInvitesIssued at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.IncrementInvitesIssuedMock.expectedInvocations), m.IncrementInvitesIssuedMock.expectedInvocationsOrigin, afterIncrementInvitesIssuedCounter)
	}
}

type mUserRepositoryMockIncrementInvitesIssuedTx struct {
	optional           bool
	mock               *UserRepositoryMock
	defaultExpectation *UserRepositoryMockIncrementInvitesIssuedTxExpectation
	expectations       []*UserRepositoryMockIncrementInvitesIssuedTxExpectation

	callArgs []*UserRepositoryMockIncrementInvitesIssuedTxParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// UserRepositoryMockIncrementInvitesIssuedTxExpectation specifies expectation struct of the UserRepository.IncrementInvitesIssuedTx
type UserRepositoryMockIncrementInvitesIssuedTxExpectation struct {
	mock               *UserRepositoryMock
	params             *UserRepositoryMockIncrementInvitesIssuedTxParams
	paramPtrs          *UserRepositoryMockIncrementInvitesIssuedTxParamPtrs
	expectationOrigins UserRepositoryMockIncrementInvitesIssuedTxExpectationOrigins
	results            *UserRepositoryMockIncrementInvitesIssuedTxResults
	returnOrigin       string
	Counter            uint64
}

// UserRepositoryMockIncrementInvitesIssuedTxParams contains parameters of the UserRepository.IncrementInvitesIssuedTx
type UserRepositoryMockIncrementInvitesIssuedTxParams struct {
	ctx    context.Context
	tx     pgx.Tx
	userID int
}

// UserRepositoryMockIncrementInvitesIssuedTxParamPtrs contains pointers to parameters of the UserRepository.IncrementInvitesIssuedTx
type UserRepositoryMockIncrementInvitesIssuedTxParamPtrs struct {
	ctx    *context.Context
	tx     *pgx.Tx
	userID *int
}

// UserRepositoryMockIncrementInvitesIssuedTxResults contains results of the UserRepository.IncrementInvitesIssuedTx
type UserRepositoryMockIncrementInvitesIssuedTxResults struct {
	err error
}

// UserRepositoryMockIncrementInvitesIssuedTxOrigins contains origins of expectations of the UserRepository.IncrementInvitesIssuedTx
type UserRepositoryMockIncrementInvitesIssuedTxExpectationOrigins struct {
	origin       string
	originCtx    string
	originTx     string
	originUserID string
}

// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
// Optional() makes method check to work in '0 or more' mode.
// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
// catch the problems when the expected method call is totally skipped during test run.
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) Optional() *mUserRepositoryMockIncrementInvitesIssuedTx {
	mmIncrementInvitesIssuedTx.optional = true
	return mmIncrementInvitesIssuedTx
}

// Expect sets up expected params for UserRepository.IncrementInvitesIssuedTx
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) Expect(ctx context.Context, tx pgx.Tx, userID int) *mUserRepositoryMockIncrementInvitesIssuedTx {
	if mmIncrementInvitesIssuedTx.mock.funcIncrementInvitesIssuedTx != nil {
		mmIncrementInvitesIssuedTx.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssuedTx mock is already set by Set")
	}

	if mmIncrementInvitesIssuedTx.defaultExpectation == nil {
		mmIncrementInvitesIssuedTx.defaultExpectation = &UserRepositoryMockIncrementInvitesIssuedTxExpectation{}
	}

	if mmIncrementInvitesIssuedTx.defaultExpectation.paramPtrs != nil {
		mmIncrementInvitesIssuedTx.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssuedTx mock is already set by ExpectParams functions")
	}

	mmIncrementInvitesIssuedTx.defaultExpectation.params = &UserRepositoryMockIncrementInvitesIssuedTxParams{ctx, tx, userID}
	mmIncrementInvitesIssuedTx.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmIncrementInvitesIssuedTx.expectations {
		if minimock.Equal(e.params, mmIncrementInvitesIssuedTx.defaultExpectation.params) {
			mmIncrementInvitesIssuedTx.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmIncrementInvitesIssuedTx.defaultExpectation.params)
		}
	}

	return mmIncrementInvitesIssuedTx
}

// ExpectCtxParam1 sets up expected param ctx for UserRepository.IncrementInvitesIssuedTx
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockIncrementInvitesIssuedTx {
	if mmIncrementInvitesIssuedTx.mock.funcIncrementInvitesIssuedTx != nil {
		mmIncrementInvitesIssuedTx.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssuedTx mock is already set by Set")
	}

	if mmIncrementInvitesIssuedTx.defaultExpectation == nil {
		mmIncrementInvitesIssuedTx.defaultExpectation = &UserRepositoryMockIncrementInvitesIssuedTxExpectation{}
	}

	if mmIncrementInvitesIssuedTx.defaultExpectation.params != nil {
		mmIncrementInvitesIssuedTx.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssuedTx mock is already set by Expect")
	}

	if mmIncrementInvitesIssuedTx.defaultExpectation.paramPtrs == nil {
		mmIncrementInvitesIssuedTx.defaultExpectation.paramPtrs = &UserRepositoryMockIncrementInvitesIssuedTxParamPtrs{}
	}
	mmIncrementInvitesIssuedTx.defaultExpectation.paramPtrs.ctx = &ctx
	mmIncrementInvitesIssuedTx.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmIncrementInvitesIssuedTx
}

// ExpectTxParam2 sets up expected param tx for UserRepository.IncrementInvitesIssuedTx
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) ExpectTxParam2(tx pgx.Tx) *mUserRepositoryMockIncrementInvitesIssuedTx {
	if mmIncrementInvitesIssuedTx.mock.funcIncrementInvitesIssuedTx != nil {
		mmIncrementInvitesIssuedTx.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssuedTx mock is already set by Set")
	}

	if mmIncrementInvitesIssuedTx.defaultExpectation == nil {
		mmIncrementInvitesIssuedTx.defaultExpectation = &UserRepositoryMockIncrementInvitesIssuedTxExpectation{}
	}

	if mmIncrementInvitesIssuedTx.defaultExpectation.params != nil {
		mmIncrementInvitesIssuedTx.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssuedTx mock is already set by Expect")
	}

	if mmIncrementInvitesIssuedTx.defaultExpectation.paramPtrs == nil {
		mmIncrementInvitesIssuedTx.defaultExpectation.paramPtrs = &UserRepositoryMockIncrementInvitesIssuedTxParamPtrs{}
	}
	mmIncrementInvitesIssuedTx.defaultExpectation.paramPtrs.tx = &tx
	mmIncrementInvitesIssuedTx.defaultExpectation.expectationOrigins.originTx = minimock.CallerInfo(1)

	return mmIncrementInvitesIssuedTx
}

// ExpectUserIDParam3 sets up expected param userID for UserRepository.IncrementInvitesIssuedTx
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) ExpectUserIDParam3(userID int) *mUserRepositoryMockIncrementInvitesIssuedTx {
	if mmIncrementInvitesIssuedTx.mock.funcIncrementInvitesIssuedTx != nil {
		mmIncrementInvitesIssuedTx.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssuedTx mock is already set by Set")
	}

	if mmIncrementInvitesIssuedTx.defaultExpectation == nil {
		mmIncrementInvitesIssuedTx.defaultExpectation = &UserRepositoryMockIncrementInvitesIssuedTxExpectation{}
	}

	if mmIncrementInvitesIssuedTx.defaultExpectation.params != nil {
		mmIncrementInvitesIssuedTx.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssuedTx mock is already set by Expect")
	}

	if mmIncrementInvitesIssuedTx.defaultExpectation.paramPtrs == nil {
		mmIncrementInvitesIssuedTx.defaultExpectation.paramPtrs = &UserRepositoryMockIncrementInvitesIssuedTxParamPtrs{}
	}
	mmIncrementInvitesIssuedTx.defaultExpectation.paramPtrs.userID = &userID
	mmIncrementInvitesIssuedTx.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)

	return mmIncrementInvitesIssuedTx
}

// Inspect accepts an inspector function that has same arguments as the UserRepository.IncrementInvitesIssuedTx
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) Inspect(f func(ctx context.Context, tx pgx.Tx, userID int)) *mUserRepositoryMockIncrementInvitesIssuedTx {
	if mmIncrementInvitesIssuedTx.mock.inspectFuncIncrementInvitesIssuedTx != nil {
		mmIncrementInvitesIssuedTx.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.IncrementInvitesIssuedTx")
	}

	mmIncrementInvitesIssuedTx.mock.inspectFuncIncrementInvitesIssuedTx = f

	return mmIncrementInvitesIssuedTx
}

// Return sets up results that will be returned by UserRepository.IncrementInvitesIssuedTx
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) Return(err error) *UserRepositoryMock {
	if mmIncrementInvitesIssuedTx.mock.funcIncrementInvitesIssuedTx != nil {
		mmIncrementInvitesIssuedTx.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssuedTx mock is already set by Set")
	}

	if mmIncrementInvitesIssuedTx.defaultExpectation == nil {
		mmIncrementInvitesIssuedTx.defaultExpectation = &UserRepositoryMockIncrementInvitesIssuedTxExpectation{mock: mmIncrementInvitesIssuedTx.mock}
	}
	mmIncrementInvitesIssuedTx.defaultExpectation.results = &UserRepositoryMockIncrementInvitesIssuedTxResults{err}
	mmIncrementInvitesIssuedTx.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmIncrementInvitesIssuedTx.mock
}

// Set uses given function f to mock the UserRepository.IncrementInvitesIssuedTx method
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) Set(f func(ctx context.Context, tx pgx.Tx, userID int) (err error)) *UserRepositoryMock {
	if mmIncrementInvitesIssuedTx.defaultExpectation != nil {
		mmIncrementInvitesIssuedTx.mock.t.Fatalf("Default expectation is already set for the UserRepository.IncrementInvitesIssuedTx method")
	}

	if len(mmIncrementInvitesIssuedTx.expectations) > 0 {
		mmIncrementInvitesIssuedTx.mock.t.Fatalf("Some expectations are already set for the UserRepository.IncrementInvitesIssuedTx method")
	}

	mmIncrementInvitesIssuedTx.mock.funcIncrementInvitesIssuedTx = f
	mmIncrementInvitesIssuedTx.mock.funcIncrementInvitesIssuedTxOrigin = minimock.CallerInfo(1)
	return mmIncrementInvitesIssuedTx.mock
}

// When sets expectation for the UserRepository.IncrementInvitesIssuedTx which will trigger the result defined by the following
// Then helper
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) When(ctx context.Context, tx pgx.Tx, userID int) *UserRepositoryMockIncrementInvitesIssuedTxExpectation {
	if mmIncrementInvitesIssuedTx.mock.funcIncrementInvitesIssuedTx != nil {
		mmIncrementInvitesIssuedTx.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssuedTx mock is already set by Set")
	}

	expectation := &UserRepositoryMockIncrementInvitesIssuedTxExpectation{
		mock:               mmIncrementInvitesIssuedTx.mock,
		params:             &UserRepositoryMockIncrementInvitesIssuedTxParams{ctx, tx, userID},
		expectationOrigins: UserRepositoryMockIncrementInvitesIssuedTxExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmIncrementInvitesIssuedTx.expectations = append(mmIncrementInvitesIssuedTx.expectations, expectation)
	return expectation
}

// Then sets up UserRepository.IncrementInvitesIssuedTx return parameters for the expectation previously defined by the When method
func (e *UserRepositoryMockIncrementInvitesIssuedTxExpectation) Then(err error) *UserRepositoryMock {
	e.results = &UserRepositoryMockIncrementInvitesIssuedTxResults{err}
	return e.mock
}

// Times sets number of times UserRepository.IncrementInvitesIssuedTx should be invoked
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) Times(n uint64) *mUserRepositoryMockIncrementInvitesIssuedTx {
	if n == 0 {
		mmIncrementInvitesIssuedTx.mock.t.Fatalf("Times of UserRepositoryMock.IncrementInvitesIssuedTx mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmIncrementInvitesIssuedTx.expectedInvocations, n)
	mmIncrementInvitesIssuedTx.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmIncrementInvitesIssuedTx
}

func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) invocationsDone() bool {
	if len(mmIncrementInvitesIssuedTx.expectations) == 0 && mmIncrementInvitesIssuedTx.defaultExpectation == nil && mmIncrementInvitesIssuedTx.mock.funcIncrementInvitesIssuedTx == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmIncrementInvitesIssuedTx.mock.afterIncrementInvitesIssuedTxCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmIncrementInvitesIssuedTx.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// IncrementInvitesIssuedTx implements mm_repository.UserRepository
func (mmIncrementInvitesIssuedTx *UserRepositoryMock) IncrementInvitesIssuedTx(ctx context.Context, tx pgx.Tx, userID int) (err error) {
	mm_atomic.AddUint64(&mmIncrementInvitesIssuedTx.beforeIncrementInvitesIssuedTxCounter, 1)
	defer mm_atomic.AddUint64(&mmIncrementInvitesIssuedTx.afterIncrementInvitesIssuedTxCounter, 1)

	mmIncrementInvitesIssuedTx.t.Helper()

	if mmIncrementInvitesIssuedTx.inspectFuncIncrementInvitesIssuedTx != nil {
		mmIncrementInvitesIssuedTx.inspectFuncIncrementInvitesIssuedTx(ctx, tx, userID)
	}

	mm_params := UserRepositoryMockIncrementInvitesIssuedTxParams{ctx, tx, userID}

	// Record call args
	mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.mutex.Lock()
	mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.callArgs = append(mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.callArgs, &mm_params)
	mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.mutex.Unlock()

	for _, e := range mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.err
		}
	}

	if mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.defaultExpectation.Counter, 1)
		mm_want := mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.defaultExpectation.params
		mm_want_ptrs := mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.defaultExpectation.paramPtrs

		mm_got := UserRepositoryMockIncrementInvitesIssuedTxParams{ctx, tx, userID}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmIncrementInvitesIssuedTx.t.Errorf("UserRepositoryMock.IncrementInvitesIssuedTx got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
			}

			if mm_want_ptrs.tx != nil && !minimock.Equal(*mm_want_ptrs.tx, mm_got.tx) {
				mmIncrementInvitesIssuedTx.t.Errorf("UserRepositoryMock.IncrementInvitesIssuedTx got unexpected parameter tx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.defaultExpectation.expectationOrigins.originTx, *mm_want_ptrs.tx, mm_got.tx, minimock.Diff(*mm_want_ptrs.tx, mm_got.tx))
			}

			if mm_want_ptrs.userID != nil && !minimock.Equal(*mm_want_ptrs.userID, mm_got.userID) {
				mmIncrementInvitesIssuedTx.t.Errorf("UserRepositoryMock.IncrementInvitesIssuedTx got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.defaultExpectation.expectationOrigins.originUserID, *mm_want_ptrs.userID, mm_got.userID, minimock.Diff(*mm_want_ptrs.userID, mm_got.userID))
			}

		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmIncrementInvitesIssuedTx.t.Errorf("UserRepositoryMock.IncrementInvitesIssuedTx got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.defaultExpectation.results
		if mm_results == nil {
			mmIncrementInvitesIssuedTx.t.Fatal("No results are set for the UserRepositoryMock.IncrementInvitesIssuedTx")
		}
		return (*mm_results).err
	}
	if mmIncrementInvitesIssuedTx.funcIncrementInvitesIssuedTx != nil {
		return mmIncrementInvitesIssuedTx.funcIncrementInvitesIssuedTx(ctx, tx, userID)
	}
	mmIncrementInvitesIssuedTx.t.Fatalf("Unexpected call to UserRepositoryMock.IncrementInvitesIssuedTx. %v %v %v", ctx, tx, userID)
	return
}

// IncrementInvitesIssuedTxAfterCounter returns a count of finished UserRepositoryMock.IncrementInvitesIssuedTx invocations
func (mmIncrementInvitesIssuedTx *UserRepositoryMock) IncrementInvitesIssuedTxAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmIncrementInvitesIssuedTx.afterIncrementInvitesIssuedTxCounter)
}

// IncrementInvitesIssuedTxBeforeCounter returns a count of UserRepositoryMock.IncrementInvitesIssuedTx invocations
func (mmIncrementInvitesIssuedTx *UserRepositoryMock) IncrementInvitesIssuedTxBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmIncrementInvitesIssuedTx.beforeIncrementInvitesIssuedTxCounter)
}

// Calls returns a list of arguments used in each call to UserRepositoryMock.IncrementInvitesIssuedTx.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) Calls() []*UserRepositoryMockIncrementInvitesIssuedTxParams {
	mmIncrementInvitesIssuedTx.mutex.RLock()

	argCopy := make([]*UserRepositoryMockIncrementInvitesIssuedTxParams, len(mmIncrementInvitesIssuedTx.callArgs))
	copy(argCopy, mmIncrementInvitesIssuedTx.callArgs)

	mmIncrementInvitesIssuedTx.mutex.RUnlock()

	return argCopy
}

// MinimockIncrementInvitesIssuedTxDone returns true if the count of the IncrementInvitesIssuedTx invocations corresponds
// the number of defined expectations
func (m *UserRepositoryMock) MinimockIncrementInvitesIssuedTxDone() bool {
	if m.IncrementInvitesIssuedTxMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.IncrementInvitesIssuedTxMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.IncrementInvitesIssuedTxMock.invocationsDone()
}

// MinimockIncrementInvitesIssuedTxInspect logs each unmet expectation
func (m *UserRepositoryMock) MinimockIncrementInvitesIssuedTxInspect() {
	for _, e := range m.IncrementInvitesIssuedTxMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to UserRepositoryMock.IncrementInvitesIssuedTx at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterIncrementInvitesIssuedTxCounter := mm_atomic.LoadUint64(&m.afterIncrementInvitesIssuedTxCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.IncrementInvitesIssuedTxMock.defaultExpectation != nil && afterIncrementInvitesIssuedTxCounter < 1 {
		if m.IncrementInvitesIssuedTxMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to UserRepositoryMock.IncrementInvitesIssuedTx at\n%s", m.IncrementInvitesIssuedTxMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to UserRepositoryMock.IncrementInvitesIssuedTx at\n%s with params: %#v", m.IncrementInvitesIssuedTxMock.defaultExpectation.expectationOrigins.origin, *m.IncrementInvitesIssuedTxMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcIncrementInvitesIssuedTx != nil && afterIncrementInvitesIssuedTxCounter < 1 {
		m.t.Errorf("Expected call to UserRepositoryMock.IncrementInvitesIssuedTx at\n%s", m.funcIncrementInvitesIssuedTxOrigin)
	}

	if !m.IncrementInvitesIssuedTxMock.invocationsDone() && afterIncrementInvitesIssuedTxCounter > 0 {
		m.t.Errorf("Expected %d calls to UserRepositoryMock.IncrementInvitesIssuedTx at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.IncrementInvitesIssuedTxMock.expectedInvocations), m.IncrementInvitesIssuedTxMock.expectedInvocationsOrigin, afterIncrementInvitesIssuedTxCounter)
	}
}

type mUserRepositoryMockUpdateBalance struct {
	optional           bool
	mock               *UserRepositoryMock
	defaultExpectation *UserRepositoryMockUpdateBalanceExpectation
	expectations       []*UserRepositoryMockUpdateBalanceExpectation

	callArgs []*UserRepositoryMockUpdateBalanceParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// UserRepositoryMockUpdateBalanceExpectation specifies expectation struct of the UserRepository.UpdateBalance
type UserRepositoryMockUpdateBalanceExpectation struct {
	mock               *UserRepositoryMock
	params             *UserRepositoryMockUpdateBalanceParams
	paramPtrs          *UserRepositoryMockUpdateBalanceParamPtrs
	expectationOrigins UserRepositoryMockUpdateBalanceExpectationOrigins
	results            *UserRepositoryMockUpdateBalanceResults
	returnOrigin       string
	Counter            uint64
}

// UserRepositoryMockUpdateBalanceParams contains parameters of the UserRepository.UpdateBalance
type UserRepositoryMockUpdateBalanceParams struct {
	ctx    context.Context
	userID int
	delta  float64
}

// UserRepositoryMockUpdateBalanceParamPtrs contains pointers to parameters of the UserRepository.UpdateBalance
type UserRepositoryMockUpdateBalanceParamPtrs struct {
	ctx    *context.Context
	userID *int
	delta  *float64
}

// UserRepositoryMockUpdateBalanceResults contains results of the UserRepository.UpdateBalance
type UserRepositoryMockUpdateBalanceResults struct {
	err error
}

// UserRepositoryMockUpdateBalanceOrigins contains origins of expectations of the UserRepository.UpdateBalance
type UserRepositoryMockUpdateBalanceExpectationOrigins struct {
	origin       string
	originCtx    string
	originUserID string
	originDelta  string
}

// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
// Optional() makes method check to work in '0 or more' mode.
// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
// catch the problems when the expected method call is totally skipped during test run.
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) Optional() *mUserRepositoryMockUpdateBalance {
	mmUpdateBalance.optional = true
	return mmUpdateBalance
}

// Expect sets up expected params for UserRepository.UpdateBalance
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) Expect(ctx context.Context, userID int, delta float64) *mUserRepositoryMockUpdateBalance {
	if mmUpdateBalance.mock.funcUpdateBalance != nil {
		mmUpdateBalance.mock.t.Fatalf("UserRepositoryMock.UpdateBalance mock is already set by Set")
	}

	if mmUpdateBalance.defaultExpectation == nil {
		mmUpdateBalance.defaultExpectation = &UserRepositoryMockUpdateBalanceExpectation{}
	}

	if mmUpdateBalance.defaultExpectation.paramPtrs != nil {
		mmUpdateBalance.mock.t.Fatalf("UserRepositoryMock.UpdateBalance mock is already set by ExpectParams functions")
	}

	mmUpdateBalance.defaultExpectation.params = &UserRepositoryMockUpdateBalanceParams{ctx, userID, delta}
	mmUpdateBalance.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmUpdateBalance.expectations {
		if minimock.Equal(e.params, mmUpdateBalance.defaultExpectation.params) {
			mmUpdateBalance.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateBalance.defaultExpectation.params)
		}
	}

	return mmUpdateBalance
}

// ExpectCtxParam1 sets up expected param ctx for UserRepository.UpdateBalance
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockUpdateBalance {
	if mmUpdateBalance.mock.funcUpdateBalance != nil {
		mmUpdateBalance.mock.t.Fatalf("UserRepositoryMock.UpdateBalance mock is already set by Set")
	}

	if mmUpdateBalance.defaultExpectation == nil {
		mmUpdateBalance.defaultExpectation = &UserRepositoryMockUpdateBalanceExpectation{}
	}

	if mmUpdateBalance.defaultExpectation.params != nil {
		mmUpdateBalance.mock.t.Fatalf("UserRepositoryMock.UpdateBalance mock is already set by Expect")
	}

	if mmUpdateBalance.defaultExpectation.paramPtrs == nil {
		mmUpdateBalance.defaultExpectation.paramPtrs = &UserRepositoryMockUpdateBalanceParamPtrs{}
	}
	mmUpdateBalance.defaultExpectation.paramPtrs.ctx = &ctx
	mmUpdateBalance.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmUpdateBalance
}

// ExpectUserIDParam2 sets up expected param userID for UserRepository.UpdateBalance
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) ExpectUserIDParam2(userID int) *mUserRepositoryMockUpdateBalance {
	if mmUpdateBalance.mock.funcUpdateBalance != nil {
		mmUpdateBalance.mock.t.Fatalf("UserRepositoryMock.UpdateBalance mock is already set by Set")
	}

	if mmUpdateBalance.defaultExpectation == nil {
		mmUpdateBalance.defaultExpectation = &UserRepositoryMockUpdateBalanceExpectation{}
	}

	if mmUpdateBalance.defaultExpectation.params != nil {
		mmUpdateBalance.mock.t.Fatalf("UserRepositoryMock.UpdateBalance mock is already set by Expect")
	}

	if mmUpdateBalance.defaultExpectation.paramPtrs == nil {
		mmUpdateBalance.defaultExpectation.paramPtrs = &UserRepositoryMockUpdateBalanceParamPtrs{}
	}
	mmUpdateBalance.defaultExpectation.paramPtrs.userID = &userID
	mmUpdateBalance.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)

	return mmUpdateBalance
}

// ExpectDeltaParam3 sets up expected param delta for UserRepository.UpdateBalance
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) ExpectDeltaParam3(delta float64) *mUserRepositoryMockUpdateBalance {
	if mmUpdateBalance.mock.funcUpdateBalance != nil {
		mmUpdateBalance.mock.t.Fatalf("UserRepositoryMock.UpdateBalance mock is already set by Set")
	}

	if mmUpdateBalance.defaultExpectation == nil {
		mmUpdateBalance.defaultExpectation = &UserRepositoryMockUpdateBalanceExpectation{}
	}

	if mmUpdateBalance.defaultExpectation.params != nil {
		mmUpdateBalance.mock.t.Fatalf("UserRepositoryMock.UpdateBalance mock is already set by Expect")
	}

	if mmUpdateBalance.defaultExpectation.paramPtrs == nil {
		mmUpdateBalance.defaultExpectation.paramPtrs = &UserRepositoryMockUpdateBalanceParamPtrs{}
	}
	mmUpdateBalance.defaultExpectation.paramPtrs.delta = &delta
	mmUpdateBalance.defaultExpectation.expectationOrigins.originDelta = minimock.CallerInfo(1)

	return mmUpdateBalance
}

// Inspect accepts an inspector function that has same arguments as the UserRepository.UpdateBalance
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) Inspect(f func(ctx context.Context, userID int, delta float64)) *mUserRepositoryMockUpdateBalance {
	if mmUpdateBalance.mock.inspectFuncUpdateBalance != nil {
		mmUpdateBalance.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.UpdateBalance")
	}

	mmUpdateBalance.mock.inspectFuncUpdateBalance = f

	return mmUpdateBalance
}

// Return sets up results that will be returned by UserRepository.UpdateBalance
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) Return(err error) *UserRepositoryMock {
	if mmUpdateBalance.mock.funcUpdateBalance != nil {
		mmUpdateBalance.mock.t.Fatalf("UserRepositoryMock.UpdateBalance mock is already set by Set")
	}

	if mmUpdateBalance.defaultExpectation == nil {
		mmUpdateBalance.defaultExpectation = &UserRepositoryMockUpdateBalanceExpectation{mock: mmUpdateBalance.mock}
	}
	mmUpdateBalance.defaultExpectation.results = &UserRepositoryMockUpdateBalanceResults{err}
	mmUpdateBalance.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmUpdateBalance.mock
}

// Set uses given function f to mock the UserRepository.UpdateBalance method
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) Set(f func(ctx context.Context, userID int, delta float64) (err error)) *UserRepositoryMock {
	if mmUpdateBalance.defaultExpectation != nil {
		mmUpdateBalance.mock.t.Fatalf("Default expectation is already set for the UserRepository.UpdateBalance method")
	}

	if len(mmUpdateBalance.expectations) > 0 {
		mmUpdateBalance.mock.t.Fatalf("Some expectations are already set for the UserRepository.UpdateBalance method")
	}

	mmUpdateBalance.mock.funcUpdateBalance = f
	mmUpdateBalance.mock.funcUpdateBalanceOrigin = minimock.CallerInfo(1)
	return mmUpdateBalance.mock
}

// When sets expectation for the UserRepository.UpdateBalance which will trigger the result defined by the following
// Then helper
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) When(ctx context.Context, userID int, delta float64) *UserRepositoryMockUpdateBalanceExpectation {
	if mmUpdateBalance.mock.funcUpdateBalance != nil {
		mmUpdateBalance.mock.t.Fatalf("UserRepositoryMock.UpdateBalance mock is already set by Set")
	}

	expectation := &UserRepositoryMockUpdateBalanceExpectation{
		mock:               mmUpdateBalance.mock,
		params:             &UserRepositoryMockUpdateBalanceParams{ctx, userID, delta},
		expectationOrigins: UserRepositoryMockUpdateBalanceExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmUpdateBalance.expectations = append(mmUpdateBalance.expectations, expectation)
	return expectation
}

// Then sets up UserRepository.UpdateBalance return parameters for the expectation previously defined by the When method
func (e *UserRepositoryMockUpdateBalanceExpectation) Then(err error) *UserRepositoryMock {
	e.results = &UserRepositoryMockUpdateBalanceResults{err}
	return e.mock
}

// Times sets number of times UserRepository.UpdateBalance should be invoked
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) Times(n uint64) *mUserRepositoryMockUpdateBalance {
	if n == 0 {
		mmUpdateBalance.mock.t.Fatalf("Times of UserRepositoryMock.UpdateBalance mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmUpdateBalance.expectedInvocations, n)
	mmUpdateBalance.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmUpdateBalance
}

func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) invocationsDone() bool {
	if len(mmUpdateBalance.expectations) == 0 && mmUpdateBalance.defaultExpectation == nil && mmUpdateBalance.mock.funcUpdateBalance == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmUpdateBalance.mock.afterUpdateBalanceCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmUpdateBalance.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// UpdateBalance implements mm_repository.UserRepository
func (mmUpdateBalance *UserRepositoryMock) UpdateBalance(ctx context.Context, userID int, delta float64) (err error) {
	mm_atomic.AddUint64(&mmUpdateBalance.beforeUpdateBalanceCounter, 1)
	defer mm_atomic.AddUint64(&mmUpdateBalance.afterUpdateBalanceCounter, 1)

	mmUpdateBalance.t.Helper()

	if mmUpdateBalance.inspectFuncUpdateBalance != nil {
		mmUpdateBalance.inspectFuncUpdateBalance(ctx, userID, delta)
	}

	mm_params := UserRepositoryMockUpdateBalanceParams{ctx, userID, delta}

	// Record call args
	mmUpdateBalance.UpdateBalanceMock.mutex.Lock()
	mmUpdateBalance.UpdateBalanceMock.callArgs = append(mmUpdateBalance.UpdateBalanceMock.callArgs, &mm_params)
	mmUpdateBalance.UpdateBalanceMock.mutex.Unlock()

	for _, e := range mmUpdateBalance.UpdateBalanceMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.err
		}
	}

	if mmUpdateBalance.UpdateBalanceMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmUpdateBalance.UpdateBalanceMock.defaultExpectation.Counter, 1)
		mm_want := mmUpdateBalance.UpdateBalanceMock.defaultExpectation.params
		mm_want_ptrs := mmUpdateBalance.UpdateBalanceMock.defaultExpectation.paramPtrs

		mm_got := UserRepositoryMockUpdateBalanceParams{ctx, userID, delta}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmUpdateBalance.t.Errorf("UserRepositoryMock.UpdateBalance got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmUpdateBalance.UpdateBalanceMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
			}

			if mm_want_ptrs.userID != nil && !minimock.Equal(*mm_want_ptrs.userID, mm_got.userID) {
				mmUpdateBalance.t.Errorf("UserRepositoryMock.UpdateBalance got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmUpdateBalance.UpdateBalanceMock.defaultExpectation.expectationOrigins.originUserID, *mm_want_ptrs.userID, mm_got.userID, minimock.Diff(*mm_want_ptrs.userID, mm_got.userID))
			}

			if mm_want_ptrs.delta != nil && !minimock.Equal(*mm_want_ptrs.delta, mm_got.delta) {
				mmUpdateBalance.t.Errorf("UserRepositoryMock.UpdateBalance got unexpected parameter delta, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmUpdateBalance.UpdateBalanceMock.defaultExpectation.expectationOrigins.originDelta, *mm_want_ptrs.delta, mm_got.delta, minimock.Diff(*mm_want_ptrs.delta, mm_got.delta))
			}

		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmUpdateBalance.t.Errorf("UserRepositoryMock.UpdateBalance got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmUpdateBalance.UpdateBalanceMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmUpdateBalance.UpdateBalanceMock.defaultExpectation.results
		if mm_results == nil {
			mmUpdateBalance.t.Fatal("No results are set for the UserRepositoryMock.UpdateBalance")
		}
		return (*mm_results).err
	}
	if mmUpdateBalance.funcUpdateBalance != nil {
		return mmUpdateBalance.funcUpdateBalance(ctx, userID, delta)
	}
	mmUpdateBalance.t.Fatalf("Unexpected call to UserRepositoryMock.UpdateBalance. %v %v %v", ctx, userID, delta)
	return
}

// UpdateBalanceAfterCounter returns a count of finished UserRepositoryMock.UpdateBalance invocations
func (mmUpdateBalance *UserRepositoryMock) UpdateBalanceAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmUpdateBalance.afterUpdateBalanceCounter)
}

// UpdateBalanceBeforeCounter returns a count of UserRepositoryMock.UpdateBalance invocations
func (mmUpdateBalance *UserRepositoryMock) UpdateBalanceBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmUpdateBalance.beforeUpdateBalanceCounter)
}

// Calls returns a list of arguments used in each call to UserRepositoryMock.UpdateBalance.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) Calls() []*UserRepositoryMockUpdateBalanceParams {
	mmUpdateBalance.mutex.RLock()

	argCopy := make([]*UserRepositoryMockUpdateBalanceParams, len(mmUpdateBalance.callArgs))
	copy(argCopy, mmUpdateBalance.callArgs)

	mmUpdateBalance.mutex.RUnlock()

	return argCopy
}

// MinimockUpdateBalanceDone returns true if the count of the UpdateBalance invocations corresponds
// the number of defined expectations
func (m *UserRepositoryMock) MinimockUpdateBalanceDone() bool {
	if m.UpdateBalanceMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.UpdateBalanceMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.UpdateBalanceMock.invocationsDone()
}

// MinimockUpdateBalanceInspect logs each unmet expectation
func (m *UserRepositoryMock) MinimockUpdateBalanceInspect() {
	for _, e := range m.UpdateBalanceMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to UserRepositoryMock.UpdateBalance at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterUpdateBalanceCounter := mm_atomic.LoadUint64(&m.afterUpdateBalanceCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.UpdateBalanceMock.defaultExpectation != nil && afterUpdateBalanceCounter < 1 {
		if m.UpdateBalanceMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to UserRepositoryMock.UpdateBalance at\n%s", m.UpdateBalanceMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to UserRepositoryMock.UpdateBalance at\n%s with params: %#v", m.UpdateBalanceMock.defaultExpectation.expectationOrigins.origin, *m.UpdateBalanceMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcUpdateBalance != nil && afterUpdateBalanceCounter < 1 {
		m.t.Errorf("Expected call to UserRepositoryMock.UpdateBalance at\n%s", m.funcUpdateBalanceOrigin)
	}

	if !m.UpdateBalanceMock.invocationsDone() && afterUpdateBalanceCounter > 0 {
		m.t.Errorf("Expected %d calls to UserRepositoryMock.UpdateBalance at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.UpdateBalanceMock.expectedInvocations), m.UpdateBalanceMock.expectedInvocationsOrigin, afterUpdateBalanceCounter)
	}
}

type mUserRepositoryMockUpdateBalanceTx struct {
	optional           bool
	mock               *UserRepositoryMock
	defaultExpectation *UserRepositoryMockUpdateBalanceTxExpectation
	expectations       []*UserRepositoryMockUpdateBalanceTxExpectation

	callArgs []*UserRepositoryMockUpdateBalanceTxParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// UserRepositoryMockUpdateBalanceTxExpectation specifies expectation struct of the UserRepository.UpdateBalanceTx
type UserRepositoryMockUpdateBalanceTxExpectation struct {
	mock               *UserRepositoryMock
	params             *UserRepositoryMockUpdateBalanceTxParams
	paramPtrs          *UserRepositoryMockUpdateBalanceTxParamPtrs
	expectationOrigins UserRepositoryMockUpdateBalanceTxExpectationOrigins
	results            *UserRepositoryMockUpdateBalanceTxResults
	returnOrigin       string
	Counter            uint64
}

// UserRepositoryMockUpdateBalanceTxParams contains parameters of the UserRepository.UpdateBalanceTx
type UserRepositoryMockUpdateBalanceTxParams struct {
	ctx    context.Context
	tx     pgx.Tx
	userID int
	delta  float64
}

// UserRepositoryMockUpdateBalanceTxParamPtrs contains pointers to parameters of the UserRepository.UpdateBalanceTx
type UserRepositoryMockUpdateBalanceTxParamPtrs struct {
	ctx    *context.Context
	tx     *pgx.Tx
	userID *int
	delta  *float64
}

// UserRepositoryMockUpdateBalanceTxResults contains results of the UserRepository.UpdateBalanceTx
type UserRepositoryMockUpdateBalanceTxResults struct {
	err error
}

// UserRepositoryMockUpdateBalanceTxOrigins contains origins of expectations of the UserRepository.UpdateBalanceTx
type UserRepositoryMockUpdateBalanceTxExpectationOrigins struct {
	origin       string
	originCtx    string
	originTx     string
	originUserID string
	originDelta  string
}

// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
// Optional() makes method check to work in '0 or more' mode.
// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
// catch the problems when the expected method call is totally skipped during test run.
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) Optional() *mUserRepositoryMockUpdateBalanceTx {
	mmUpdateBalanceTx.optional = true
	return mmUpdateBalanceTx
}

// Expect sets up expected params for UserRepository.UpdateBalanceTx
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) Expect(ctx context.Context, tx pgx.Tx, userID int, delta float64) *mUserRepositoryMockUpdateBalanceTx {
	if mmUpdateBalanceTx.mock.funcUpdateBalanceTx != nil {
		mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Set")
	}

	if mmUpdateBalanceTx.defaultExpectation == nil {
		mmUpdateBalanceTx.defaultExpectation = &UserRepositoryMockUpdateBalanceTxExpectation{}
	}

	if mmUpdateBalanceTx.defaultExpectation.paramPtrs != nil {
		mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by ExpectParams functions")
	}

	mmUpdateBalanceTx.defaultExpectation.params = &UserRepositoryMockUpdateBalanceTxParams{ctx, tx, userID, delta}
	mmUpdateBalanceTx.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmUpdateBalanceTx.expectations {
		if minimock.Equal(e.params, mmUpdateBalanceTx.defaultExpectation.params) {
			mmUpdateBalanceTx.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateBalanceTx.defaultExpectation.params)
		}
	}

	return mmUpdateBalanceTx
}

// ExpectCtxParam1 sets up expected param ctx for UserRepository.UpdateBalanceTx
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockUpdateBalanceTx {
	if mmUpdateBalanceTx.mock.funcUpdateBalanceTx != nil {
		mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Set")
	}

	if mmUpdateBalanceTx.defaultExpectation == nil {
		mmUpdateBalanceTx.defaultExpectation = &UserRepositoryMockUpdateBalanceTxExpectation{}
	}

	if mmUpdateBalanceTx.defaultExpectation.params != nil {
		mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Expect")
	}

	if mmUpdateBalanceTx.defaultExpectation.paramPtrs == nil {
		mmUpdateBalanceTx.defaultExpectation.paramPtrs = &UserRepositoryMockUpdateBalanceTxParamPtrs{}
	}
	mmUpdateBalanceTx.defaultExpectation.paramPtrs.ctx = &ctx
	mmUpdateBalanceTx.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmUpdateBalanceTx
}

// ExpectTxParam2 sets up expected param tx for UserRepository.UpdateBalanceTx
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) ExpectTxParam2(tx pgx.Tx) *mUserRepositoryMockUpdateBalanceTx {
	if mmUpdateBalanceTx.mock.funcUpdateBalanceTx != nil {
		mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Set")
	}

	if mmUpdateBalanceTx.defaultExpectation == nil {
		mmUpdateBalanceTx.defaultExpectation = &UserRepositoryMockUpdateBalanceTxExpectation{}
	}

	if mmUpdateBalanceTx.defaultExpectation.params != nil {
		mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Expect")
	}

	if mmUpdateBalanceTx.defaultExpectation.paramPtrs == nil {
		mmUpdateBalanceTx.defaultExpectation.paramPtrs = &UserRepositoryMockUpdateBalanceTxParamPtrs{}
	}
	mmUpdateBalanceTx.defaultExpectation.paramPtrs.tx = &tx
	mmUpdateBalanceTx.defaultExpectation.expectationOrigins.originTx = minimock.CallerInfo(1)

	return mmUpdateBalanceTx
}

// ExpectUserIDParam3 sets up expected param userID for UserRepository.UpdateBalanceTx
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) ExpectUserIDParam3(userID int) *mUserRepositoryMockUpdateBalanceTx {
	if mmUpdateBalanceTx.mock.funcUpdateBalanceTx != nil {
		mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Set")
	}

	if mmUpdateBalanceTx.defaultExpectation == nil {
		mmUpdateBalanceTx.defaultExpectation = &UserRepositoryMockUpdateBalanceTxExpectation{}
	}

	if mmUpdateBalanceTx.defaultExpectation.params != nil {
		mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Expect")
	}

	if mmUpdateBalanceTx.defaultExpectation.paramPtrs == nil {
		mmUpdateBalanceTx.defaultExpectation.paramPtrs = &UserRepositoryMockUpdateBalanceTxParamPtrs{}
	}
	mmUpdateBalanceTx.defaultExpectation.paramPtrs.userID = &userID
	mmUpdateBalanceTx.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)

	return mmUpdateBalanceTx
}

// ExpectDeltaParam4 sets up expected param delta for UserRepository.UpdateBalanceTx
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) ExpectDeltaParam4(delta float64) *mUserRepositoryMockUpdateBalanceTx {
	if mmUpdateBalanceTx.mock.funcUpdateBalanceTx != nil {
		mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Set")
	}

	if mmUpdateBalanceTx.defaultExpectation == nil {
		mmUpdateBalanceTx.defaultExpectation = &UserRepositoryMockUpdateBalanceTxExpectation{}
	}

	if mmUpdateBalanceTx.defaultExpectation.params != nil {
		mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Expect")
	}

	if mmUpdateBalanceTx.defaultExpectation.paramPtrs == nil {
		mmUpdateBalanceTx.defaultExpectation.paramPtrs = &UserRepositoryMockUpdateBalanceTxParamPtrs{}
	}
	mmUpdateBalanceTx.defaultExpectation.paramPtrs.delta = &delta
	mmUpdateBalanceTx.defaultExpectation.expectationOrigins.originDelta = minimock.CallerInfo(1)

	return mmUpdateBalanceTx
}

// Inspect accepts an inspector function that has same arguments as the UserRepository.UpdateBalanceTx
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) Inspect(f func(ctx context.Context, tx pgx.Tx, userID int, delta float64)) *mUserRepositoryMockUpdateBalanceTx {
	if mmUpdateBalanceTx.mock.inspectFuncUpdateBalanceTx != nil {
		mmUpdateBalanceTx.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.UpdateBalanceTx")
	}

	mmUpdateBalanceTx.mock.inspectFuncUpdateBalanceTx = f

	return mmUpdateBalanceTx
}

// Return sets up results that will be returned by UserRepository.UpdateBalanceTx
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) Return(err error) *UserRepositoryMock {
	if mmUpdateBalanceTx.mock.funcUpdateBalanceTx != nil {
		mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Set")
	}

	if mmUpdateBalanceTx.defaultExpectation == nil {
		mmUpdateBalanceTx.defaultExpectation = &UserRepositoryMockUpdateBalanceTxExpectation{mock: mmUpdateBalanceTx.mock}
	}
	mmUpdateBalanceTx.defaultExpectation.results = &UserRepositoryMockUpdateBalanceTxResults{err}
	mmUpdateBalanceTx.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmUpdateBalanceTx.mock
}

// Set uses given function f to mock the UserRepository.UpdateBalanceTx method
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) Set(f func(ctx context.Context, tx pgx.Tx, userID int, delta float64) (err error)) *UserRepositoryMock {
	if mmUpdateBalanceTx.defaultExpectation != nil {
		mmUpdateBalanceTx.mock.t.Fatalf("Default expectation is already set for the UserRepository.UpdateBalanceTx method")
	}

	if len(mmUpdateBalanceTx.expectations) > 0 {
		mmUpdateBalanceTx.mock.t.Fatalf("Some expectations are already set for the UserRepository.UpdateBalanceTx method")
	}

	mmUpdateBalanceTx.mock.funcUpdateBalanceTx = f
	mmUpdateBalanceTx.mock.funcUpdateBalanceTxOrigin = minimock.CallerInfo(1)
	return mmUpdateBalanceTx.mock
}

// When sets expectation for the UserRepository.UpdateBalanceTx which will trigger the result defined by the following
// Then helper
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) When(ctx context.Context, tx pgx.Tx, userID int, delta float64) *UserRepositoryMockUpdateBalanceTxExpectation {
	if mmUpdateBalanceTx.mock.funcUpdateBalanceTx != nil {
		mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Set")
	}

	expectation := &UserRepositoryMockUpdateBalanceTxExpectation{
		mock:               mmUpdateBalanceTx.mock,
		params:             &UserRepositoryMockUpdateBalanceTxParams{ctx, tx, userID, delta},
		expectationOrigins: UserRepositoryMockUpdateBalanceTxExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmUpdateBalanceTx.expectations = append(mmUpdateBalanceTx.expectations, expectation)
	return expectation
}

// Then sets up UserRepository.UpdateBalanceTx return parameters for the expectation previously defined by the When method
func (e *UserRepositoryMockUpdateBalanceTxExpectation) Then(err error) *UserRepositoryMock {
	e.results = &UserRepositoryMockUpdateBalanceTxResults{err}
	return e.mock
}

// Times sets number of times UserRepository.UpdateBalanceTx should be invoked
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) Times(n uint64) *mUserRepositoryMockUpdateBalanceTx {
	if n == 0 {
		mmUpdateBalanceTx.mock.t.Fatalf("Times of UserRepositoryMock.UpdateBalanceTx mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmUpdateBalanceTx.expectedInvocations, n)
	mmUpdateBalanceTx.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmUpdateBalanceTx
}

func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) invocationsDone() bool {
	if len(mmUpdateBalanceTx.expectations) == 0 && mmUpdateBalanceTx.defaultExpectation == nil && mmUpdateBalanceTx.mock.funcUpdateBalanceTx == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmUpdateBalanceTx.mock.afterUpdateBalanceTxCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmUpdateBalanceTx.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// UpdateBalanceTx implements mm_repository.UserRepository
func (mmUpdateBalanceTx *UserRepositoryMock) UpdateBalanceTx(ctx context.Context, tx pgx.Tx, userID int, delta float64) (err error) {
	mm_atomic.AddUint64(&mmUpdateBalanceTx.beforeUpdateBalanceTxCounter, 1)
	defer mm_atomic.AddUint64(&mmUpdateBalanceTx.afterUpdateBalanceTxCounter, 1)

	mmUpdateBalanceTx.t.Helper()

	if mmUpdateBalanceTx.inspectFuncUpdateBalanceTx != nil {
		mmUpdateBalanceTx.inspectFuncUpdateBalanceTx(ctx, tx, userID, delta)
	}

	mm_params := UserRepositoryMockUpdateBalanceTxParams{ctx, tx, userID, delta}

	// Record call args
	mmUpdateBalanceTx.UpdateBalanceTxMock.mutex.Lock()
	mmUpdateBalanceTx.UpdateBalanceTxMock.callArgs = append(mmUpdateBalanceTx.UpdateBalanceTxMock.callArgs, &mm_params)
	mmUpdateBalanceTx.UpdateBalanceTxMock.mutex.Unlock()

	for _, e := range mmUpdateBalanceTx.UpdateBalanceTxMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.err
		}
	}

	if mmUpdateBalanceTx.UpdateBalanceTxMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmUpdateBalanceTx.UpdateBalanceTxMock.defaultExpectation.Counter, 1)
		mm_want := mmUpdateBalanceTx.UpdateBalanceTxMock.defaultExpectation.params
		mm_want_ptrs := mmUpdateBalanceTx.UpdateBalanceTxMock.defaultExpectation.paramPtrs

		mm_got := UserRepositoryMockUpdateBalanceTxParams{ctx, tx, userID, delta}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmUpdateBalanceTx.t.Errorf("UserRepositoryMock.UpdateBalanceTx got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmUpdateBalanceTx.UpdateBalanceTxMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
			}

			if mm_want_ptrs.tx != nil && !minimock.Equal(*mm_want_ptrs.tx, mm_got.tx) {
				mmUpdateBalanceTx.t.Errorf("UserRepositoryMock.UpdateBalanceTx got unexpected parameter tx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmUpdateBalanceTx.UpdateBalanceTxMock.defaultExpectation.expectationOrigins.originTx, *mm_want_ptrs.tx, mm_got.tx, minimock.Diff(*mm_want_ptrs.tx, mm_got.tx))
			}

			if mm_want_ptrs.userID != nil && !minimock.Equal(*mm_want_ptrs.userID, mm_got.userID) {
				mmUpdateBalanceTx.t.Errorf("UserRepositoryMock.UpdateBalanceTx got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmUpdateBalanceTx.UpdateBalanceTxMock.defaultExpectation.expectationOrigins.originUserID, *mm_want_ptrs.userID, mm_got.userID, minimock.Diff(*mm_want_ptrs.userID, mm_got.userID))
			}

			if mm_want_ptrs.delta != nil && !minimock.Equal(*mm_want_ptrs.delta, mm_got.delta) {
				mmUpdateBalanceTx.t.Errorf("UserRepositoryMock.UpdateBalanceTx got unexpected parameter delta, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmUpdateBalanceTx.UpdateBalanceTxMock.defaultExpectation.expectationOrigins.originDelta, *mm_want_ptrs.delta, mm_got.delta, minimock.Diff(*mm_want_ptrs.delta, mm_got.delta))
			}

		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmUpdateBalanceTx.t.Errorf("UserRepositoryMock.UpdateBalanceTx got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmUpdateBalanceTx.UpdateBalanceTxMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmUpdateBalanceTx.UpdateBalanceTxMock.defaultExpectation.results
		if mm_results == nil {
			mmUpdateBalanceTx.t.Fatal("No results are set for the UserRepositoryMock.UpdateBalanceTx")
		}
		return (*mm_results).err
	}
	if mmUpdateBalanceTx.funcUpdateBalanceTx != nil {
		return mmUpdateBalanceTx.funcUpdateBalanceTx(ctx, tx, userID, delta)
	}
	mmUpdateBalanceTx.t.Fatalf("Unexpected call to UserRepositoryMock.UpdateBalanceTx. %v %v %v %v", ctx, tx, userID, delta)
	return
}

// UpdateBalanceTxAfterCounter returns a count of finished UserRepositoryMock.UpdateBalanceTx invocations
func (mmUpdateBalanceTx *UserRepositoryMock) UpdateBalanceTxAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmUpdateBalanceTx.afterUpdateBalanceTxCounter)
}

// UpdateBalanceTxBeforeCounter returns a count of UserRepositoryMock.UpdateBalanceTx invocations
func (mmUpdateBalanceTx *UserRepositoryMock) UpdateBalanceTxBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmUpdateBalanceTx.beforeUpdateBalanceTxCounter)
}

// Calls returns a list of arguments used in each call to UserRepositoryMock.UpdateBalanceTx.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) Calls() []*UserRepositoryMockUpdateBalanceTxParams {
	mmUpdateBalanceTx.mutex.RLock()

	argCopy := make([]*UserRepositoryMockUpdateBalanceTxParams, len(mmUpdateBalanceTx.callArgs))
	copy(argCopy, mmUpdateBalanceTx.callArgs)

	mmUpdateBalanceTx.mutex.RUnlock()

	return argCopy
}

// MinimockUpdateBalanceTxDone returns true if the count of the UpdateBalanceTx invocations corresponds
// the number of defined expectations
func (m *UserRepositoryMock) MinimockUpdateBalanceTxDone() bool {
	if m.UpdateBalanceTxMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.UpdateBalanceTxMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.UpdateBalanceTxMock.invocationsDone()
}

// MinimockUpdateBalanceTxInspect logs each unmet expectation
func (m *UserRepositoryMock) MinimockUpdateBalanceTxInspect() {
	for _, e := range m.UpdateBalanceTxMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to UserRepositoryMock.UpdateBalanceTx at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterUpdateBalanceTxCounter := mm_atomic.LoadUint64(&m.afterUpdateBalanceTxCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.UpdateBalanceTxMock.defaultExpectation != nil && afterUpdateBalanceTxCounter < 1 {
		if m.UpdateBalanceTxMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to UserRepositoryMock.UpdateBalanceTx at\n%s", m.UpdateBalanceTxMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to UserRepositoryMock.UpdateBalanceTx at\n%s with params: %#v", m.UpdateBalanceTxMock.defaultExpectation.expectationOrigins.origin, *m.UpdateBalanceTxMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcUpdateBalanceTx != nil && afterUpdateBalanceTxCounter < 1 {
		m.t.Errorf("Expected call to UserRepositoryMock.UpdateBalanceTx at\n%s", m.funcUpdateBalanceTxOrigin)
	}

	if !m.UpdateBalanceTxMock.invocationsDone() && afterUpdateBalanceTxCounter > 0 {
		m.t.Errorf("Expected %d calls to UserRepositoryMock.UpdateBalanceTx at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.UpdateBalanceTxMock.expectedInvocations), m.UpdateBalanceTxMock.expectedInvocationsOrigin, afterUpdateBalanceTxCounter)
	}
}

// MinimockFinish checks that all mocked methods have been called the expected number of times
func (m *UserRepositoryMock) MinimockFinish() {
	m.finishOnce.Do(func() {
		if !m.minimockDone() {
			m.MinimockCheckInviteLimitInspect()

			m.MinimockCheckInviteLimitTxInspect()

			m.MinimockCreateInspect()

			m.MinimockCreateTxInspect()

			m.MinimockFindByEmailHashInspect()

			m.MinimockFindByIDInspect()

			m.MinimockGetBalanceInspect()

			m.MinimockIncrementInvitesIssuedInspect()

			m.MinimockIncrementInvitesIssuedTxInspect()

			m.MinimockUpdateBalanceInspect()

			m.MinimockUpdateBalanceTxInspect()
		}
	})
}

// MinimockWait waits for all mocked methods to be called the expected number of times
func (m *UserRepositoryMock) MinimockWait(timeout mm_time.Duration) {
	timeoutCh := mm_time.After(timeout)
	for {
		if m.minimockDone() {
			return
		}
		select {
		case <-timeoutCh:
			m.MinimockFinish()
			return
		case <-mm_time.After(10 * mm_time.Millisecond):
		}
	}
}

func (m *UserRepositoryMock) minimockDone() bool {
	done := true
	return done &&
		m.MinimockCheckInviteLimitDone() &&
		m.MinimockCheckInviteLimitTxDone() &&
		m.MinimockCreateDone() &&
		m.MinimockCreateTxDone() &&
		m.MinimockFindByEmailHashDone() &&
		m.MinimockFindByIDDone() &&
		m.MinimockGetBalanceDone() &&
		m.MinimockIncrementInvitesIssuedDone() &&
		m.MinimockIncrementInvitesIssuedTxDone() &&
		m.MinimockUpdateBalanceDone() &&
		m.MinimockUpdateBalanceTxDone()
}