// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"context"

	"github.com/google/uuid"
	mock "github.com/stretchr/testify/mock"
	"gitlab.golang-school.ru/potok-2/lessons/lesson-24/internal/domain"
	"gitlab.golang-school.ru/potok-2/lessons/lesson-24/internal/dto"
)

// NewRedis creates a new instance of Redis. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewRedis(t interface {
	mock.TestingT
	Cleanup(func())
}) *Redis {
	mock := &Redis{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

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

type Redis_Expecter struct {
	mock *mock.Mock
}

func (_m *Redis) EXPECT() *Redis_Expecter {
	return &Redis_Expecter{mock: &_m.Mock}
}

// IsExists provides a mock function for the type Redis
func (_mock *Redis) IsExists(ctx context.Context, idempotencyKey string) bool {
	ret := _mock.Called(ctx, idempotencyKey)

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

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
		r0 = returnFunc(ctx, idempotencyKey)
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

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

// IsExists is a helper method to define mock.On call
//   - ctx
//   - idempotencyKey
func (_e *Redis_Expecter) IsExists(ctx interface{}, idempotencyKey interface{}) *Redis_IsExists_Call {
	return &Redis_IsExists_Call{Call: _e.mock.On("IsExists", ctx, idempotencyKey)}
}

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

func (_c *Redis_IsExists_Call) Return(b bool) *Redis_IsExists_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *Redis_IsExists_Call) RunAndReturn(run func(ctx context.Context, idempotencyKey string) bool) *Redis_IsExists_Call {
	_c.Call.Return(run)
	return _c
}

// NewPostgres creates a new instance of Postgres. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewPostgres(t interface {
	mock.TestingT
	Cleanup(func())
}) *Postgres {
	mock := &Postgres{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

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

type Postgres_Expecter struct {
	mock *mock.Mock
}

func (_m *Postgres) EXPECT() *Postgres_Expecter {
	return &Postgres_Expecter{mock: &_m.Mock}
}

// CreateProfile provides a mock function for the type Postgres
func (_mock *Postgres) CreateProfile(ctx context.Context, profile domain.Profile) error {
	ret := _mock.Called(ctx, profile)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Profile) error); ok {
		r0 = returnFunc(ctx, profile)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// CreateProfile is a helper method to define mock.On call
//   - ctx
//   - profile
func (_e *Postgres_Expecter) CreateProfile(ctx interface{}, profile interface{}) *Postgres_CreateProfile_Call {
	return &Postgres_CreateProfile_Call{Call: _e.mock.On("CreateProfile", ctx, profile)}
}

func (_c *Postgres_CreateProfile_Call) Run(run func(ctx context.Context, profile domain.Profile)) *Postgres_CreateProfile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(domain.Profile))
	})
	return _c
}

func (_c *Postgres_CreateProfile_Call) Return(err error) *Postgres_CreateProfile_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Postgres_CreateProfile_Call) RunAndReturn(run func(ctx context.Context, profile domain.Profile) error) *Postgres_CreateProfile_Call {
	_c.Call.Return(run)
	return _c
}

// CreateProperty provides a mock function for the type Postgres
func (_mock *Postgres) CreateProperty(ctx context.Context, property domain.Property) error {
	ret := _mock.Called(ctx, property)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Property) error); ok {
		r0 = returnFunc(ctx, property)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// CreateProperty is a helper method to define mock.On call
//   - ctx
//   - property
func (_e *Postgres_Expecter) CreateProperty(ctx interface{}, property interface{}) *Postgres_CreateProperty_Call {
	return &Postgres_CreateProperty_Call{Call: _e.mock.On("CreateProperty", ctx, property)}
}

func (_c *Postgres_CreateProperty_Call) Run(run func(ctx context.Context, property domain.Property)) *Postgres_CreateProperty_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(domain.Property))
	})
	return _c
}

func (_c *Postgres_CreateProperty_Call) Return(err error) *Postgres_CreateProperty_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Postgres_CreateProperty_Call) RunAndReturn(run func(ctx context.Context, property domain.Property) error) *Postgres_CreateProperty_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteProfile provides a mock function for the type Postgres
func (_mock *Postgres) DeleteProfile(ctx context.Context, id uuid.UUID) error {
	ret := _mock.Called(ctx, id)

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

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

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

// DeleteProfile is a helper method to define mock.On call
//   - ctx
//   - id
func (_e *Postgres_Expecter) DeleteProfile(ctx interface{}, id interface{}) *Postgres_DeleteProfile_Call {
	return &Postgres_DeleteProfile_Call{Call: _e.mock.On("DeleteProfile", ctx, id)}
}

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

func (_c *Postgres_DeleteProfile_Call) Return(err error) *Postgres_DeleteProfile_Call {
	_c.Call.Return(err)
	return _c
}

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

// GetProfile provides a mock function for the type Postgres
func (_mock *Postgres) GetProfile(ctx context.Context, profileID uuid.UUID) (domain.Profile, error) {
	ret := _mock.Called(ctx, profileID)

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

	var r0 domain.Profile
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID) (domain.Profile, error)); ok {
		return returnFunc(ctx, profileID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID) domain.Profile); ok {
		r0 = returnFunc(ctx, profileID)
	} else {
		r0 = ret.Get(0).(domain.Profile)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uuid.UUID) error); ok {
		r1 = returnFunc(ctx, profileID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetProfile is a helper method to define mock.On call
//   - ctx
//   - profileID
func (_e *Postgres_Expecter) GetProfile(ctx interface{}, profileID interface{}) *Postgres_GetProfile_Call {
	return &Postgres_GetProfile_Call{Call: _e.mock.On("GetProfile", ctx, profileID)}
}

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

func (_c *Postgres_GetProfile_Call) Return(profile domain.Profile, err error) *Postgres_GetProfile_Call {
	_c.Call.Return(profile, err)
	return _c
}

func (_c *Postgres_GetProfile_Call) RunAndReturn(run func(ctx context.Context, profileID uuid.UUID) (domain.Profile, error)) *Postgres_GetProfile_Call {
	_c.Call.Return(run)
	return _c
}

// GetProfiles provides a mock function for the type Postgres
func (_mock *Postgres) GetProfiles(ctx context.Context, input dto.GetProfilesInput) ([]domain.Profile, error) {
	ret := _mock.Called(ctx, input)

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

	var r0 []domain.Profile
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, dto.GetProfilesInput) ([]domain.Profile, error)); ok {
		return returnFunc(ctx, input)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, dto.GetProfilesInput) []domain.Profile); ok {
		r0 = returnFunc(ctx, input)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]domain.Profile)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, dto.GetProfilesInput) error); ok {
		r1 = returnFunc(ctx, input)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetProfiles is a helper method to define mock.On call
//   - ctx
//   - input
func (_e *Postgres_Expecter) GetProfiles(ctx interface{}, input interface{}) *Postgres_GetProfiles_Call {
	return &Postgres_GetProfiles_Call{Call: _e.mock.On("GetProfiles", ctx, input)}
}

func (_c *Postgres_GetProfiles_Call) Run(run func(ctx context.Context, input dto.GetProfilesInput)) *Postgres_GetProfiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(dto.GetProfilesInput))
	})
	return _c
}

func (_c *Postgres_GetProfiles_Call) Return(profiles []domain.Profile, err error) *Postgres_GetProfiles_Call {
	_c.Call.Return(profiles, err)
	return _c
}

func (_c *Postgres_GetProfiles_Call) RunAndReturn(run func(ctx context.Context, input dto.GetProfilesInput) ([]domain.Profile, error)) *Postgres_GetProfiles_Call {
	_c.Call.Return(run)
	return _c
}

// ReadOutboxKafka provides a mock function for the type Postgres
func (_mock *Postgres) ReadOutboxKafka(ctx context.Context, limit int) ([]domain.Event, error) {
	ret := _mock.Called(ctx, limit)

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

	var r0 []domain.Event
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]domain.Event, error)); ok {
		return returnFunc(ctx, limit)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, int) []domain.Event); ok {
		r0 = returnFunc(ctx, limit)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]domain.Event)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
		r1 = returnFunc(ctx, limit)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ReadOutboxKafka is a helper method to define mock.On call
//   - ctx
//   - limit
func (_e *Postgres_Expecter) ReadOutboxKafka(ctx interface{}, limit interface{}) *Postgres_ReadOutboxKafka_Call {
	return &Postgres_ReadOutboxKafka_Call{Call: _e.mock.On("ReadOutboxKafka", ctx, limit)}
}

func (_c *Postgres_ReadOutboxKafka_Call) Run(run func(ctx context.Context, limit int)) *Postgres_ReadOutboxKafka_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int))
	})
	return _c
}

func (_c *Postgres_ReadOutboxKafka_Call) Return(events []domain.Event, err error) *Postgres_ReadOutboxKafka_Call {
	_c.Call.Return(events, err)
	return _c
}

func (_c *Postgres_ReadOutboxKafka_Call) RunAndReturn(run func(ctx context.Context, limit int) ([]domain.Event, error)) *Postgres_ReadOutboxKafka_Call {
	_c.Call.Return(run)
	return _c
}

// SaveOutboxKafka provides a mock function for the type Postgres
func (_mock *Postgres) SaveOutboxKafka(ctx context.Context, events ...domain.Event) error {
	var tmpRet mock.Arguments
	if len(events) > 0 {
		tmpRet = _mock.Called(ctx, events)
	} else {
		tmpRet = _mock.Called(ctx)
	}
	ret := tmpRet

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ...domain.Event) error); ok {
		r0 = returnFunc(ctx, events...)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SaveOutboxKafka is a helper method to define mock.On call
//   - ctx
//   - events
func (_e *Postgres_Expecter) SaveOutboxKafka(ctx interface{}, events ...interface{}) *Postgres_SaveOutboxKafka_Call {
	return &Postgres_SaveOutboxKafka_Call{Call: _e.mock.On("SaveOutboxKafka",
		append([]interface{}{ctx}, events...)...)}
}

func (_c *Postgres_SaveOutboxKafka_Call) Run(run func(ctx context.Context, events ...domain.Event)) *Postgres_SaveOutboxKafka_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := args[1].([]domain.Event)
		run(args[0].(context.Context), variadicArgs...)
	})
	return _c
}

func (_c *Postgres_SaveOutboxKafka_Call) Return(err error) *Postgres_SaveOutboxKafka_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Postgres_SaveOutboxKafka_Call) RunAndReturn(run func(ctx context.Context, events ...domain.Event) error) *Postgres_SaveOutboxKafka_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateProfile provides a mock function for the type Postgres
func (_mock *Postgres) UpdateProfile(ctx context.Context, profile domain.Profile) error {
	ret := _mock.Called(ctx, profile)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Profile) error); ok {
		r0 = returnFunc(ctx, profile)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// UpdateProfile is a helper method to define mock.On call
//   - ctx
//   - profile
func (_e *Postgres_Expecter) UpdateProfile(ctx interface{}, profile interface{}) *Postgres_UpdateProfile_Call {
	return &Postgres_UpdateProfile_Call{Call: _e.mock.On("UpdateProfile", ctx, profile)}
}

func (_c *Postgres_UpdateProfile_Call) Run(run func(ctx context.Context, profile domain.Profile)) *Postgres_UpdateProfile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(domain.Profile))
	})
	return _c
}

func (_c *Postgres_UpdateProfile_Call) Return(err error) *Postgres_UpdateProfile_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Postgres_UpdateProfile_Call) RunAndReturn(run func(ctx context.Context, profile domain.Profile) error) *Postgres_UpdateProfile_Call {
	_c.Call.Return(run)
	return _c
}

// NewKafka creates a new instance of Kafka. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewKafka(t interface {
	mock.TestingT
	Cleanup(func())
}) *Kafka {
	mock := &Kafka{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

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

type Kafka_Expecter struct {
	mock *mock.Mock
}

func (_m *Kafka) EXPECT() *Kafka_Expecter {
	return &Kafka_Expecter{mock: &_m.Mock}
}

// Produce provides a mock function for the type Kafka
func (_mock *Kafka) Produce(ctx context.Context, events ...domain.Event) error {
	var tmpRet mock.Arguments
	if len(events) > 0 {
		tmpRet = _mock.Called(ctx, events)
	} else {
		tmpRet = _mock.Called(ctx)
	}
	ret := tmpRet

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ...domain.Event) error); ok {
		r0 = returnFunc(ctx, events...)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Produce is a helper method to define mock.On call
//   - ctx
//   - events
func (_e *Kafka_Expecter) Produce(ctx interface{}, events ...interface{}) *Kafka_Produce_Call {
	return &Kafka_Produce_Call{Call: _e.mock.On("Produce",
		append([]interface{}{ctx}, events...)...)}
}

func (_c *Kafka_Produce_Call) Run(run func(ctx context.Context, events ...domain.Event)) *Kafka_Produce_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := args[1].([]domain.Event)
		run(args[0].(context.Context), variadicArgs...)
	})
	return _c
}

func (_c *Kafka_Produce_Call) Return(err error) *Kafka_Produce_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Kafka_Produce_Call) RunAndReturn(run func(ctx context.Context, events ...domain.Event) error) *Kafka_Produce_Call {
	_c.Call.Return(run)
	return _c
}