// Code generated by MockGen. DO NOT EDIT.
// Source: gateway/internal/model/notification/domain/repository (interfaces: NotificationRepository,NotificationDLQRepository,IdempotencyCache,QuotaCounter,RetryQueue)
//
// Generated by this command:
//
//	mockgen -typed -destination=../../mock/repository/repository_mock.go -package=mocknotifrepo gateway/internal/model/notification/domain/repository NotificationRepository,NotificationDLQRepository,IdempotencyCache,QuotaCounter,RetryQueue
//

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

import (
	context "context"
	entity "gateway/internal/model/notification/domain/entity"
	enum "gateway/internal/model/notification/domain/enum"
	repository "gateway/internal/model/notification/domain/repository"
	usecase "gateway/internal/model/notification/domain/usecase"
	reflect "reflect"
	time "time"

	gomock "go.uber.org/mock/gomock"
)

// MockNotificationRepository is a mock of NotificationRepository interface.
type MockNotificationRepository struct {
	ctrl     *gomock.Controller
	recorder *MockNotificationRepositoryMockRecorder
	isgomock struct{}
}

// MockNotificationRepositoryMockRecorder is the mock recorder for MockNotificationRepository.
type MockNotificationRepositoryMockRecorder struct {
	mock *MockNotificationRepository
}

// NewMockNotificationRepository creates a new mock instance.
func NewMockNotificationRepository(ctrl *gomock.Controller) *MockNotificationRepository {
	mock := &MockNotificationRepository{ctrl: ctrl}
	mock.recorder = &MockNotificationRepositoryMockRecorder{mock}
	return mock
}

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

// FindByID mocks base method.
func (m *MockNotificationRepository) FindByID(ctx context.Context, tenantID, id string) (*entity.Notification, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindByID", ctx, tenantID, id)
	ret0, _ := ret[0].(*entity.Notification)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindByID indicates an expected call of FindByID.
func (mr *MockNotificationRepositoryMockRecorder) FindByID(ctx, tenantID, id any) *MockNotificationRepositoryFindByIDCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByID", reflect.TypeOf((*MockNotificationRepository)(nil).FindByID), ctx, tenantID, id)
	return &MockNotificationRepositoryFindByIDCall{Call: call}
}

// MockNotificationRepositoryFindByIDCall wrap *gomock.Call
type MockNotificationRepositoryFindByIDCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockNotificationRepositoryFindByIDCall) Return(arg0 *entity.Notification, arg1 error) *MockNotificationRepositoryFindByIDCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockNotificationRepositoryFindByIDCall) Do(f func(context.Context, string, string) (*entity.Notification, error)) *MockNotificationRepositoryFindByIDCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockNotificationRepositoryFindByIDCall) DoAndReturn(f func(context.Context, string, string) (*entity.Notification, error)) *MockNotificationRepositoryFindByIDCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// FindByIdempotency mocks base method.
func (m *MockNotificationRepository) FindByIdempotency(ctx context.Context, tenantID string, kind enum.NotifyKind, idempotencyKey string) (*entity.Notification, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindByIdempotency", ctx, tenantID, kind, idempotencyKey)
	ret0, _ := ret[0].(*entity.Notification)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindByIdempotency indicates an expected call of FindByIdempotency.
func (mr *MockNotificationRepositoryMockRecorder) FindByIdempotency(ctx, tenantID, kind, idempotencyKey any) *MockNotificationRepositoryFindByIdempotencyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByIdempotency", reflect.TypeOf((*MockNotificationRepository)(nil).FindByIdempotency), ctx, tenantID, kind, idempotencyKey)
	return &MockNotificationRepositoryFindByIdempotencyCall{Call: call}
}

// MockNotificationRepositoryFindByIdempotencyCall wrap *gomock.Call
type MockNotificationRepositoryFindByIdempotencyCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockNotificationRepositoryFindByIdempotencyCall) Return(arg0 *entity.Notification, arg1 error) *MockNotificationRepositoryFindByIdempotencyCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockNotificationRepositoryFindByIdempotencyCall) Do(f func(context.Context, string, enum.NotifyKind, string) (*entity.Notification, error)) *MockNotificationRepositoryFindByIdempotencyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockNotificationRepositoryFindByIdempotencyCall) DoAndReturn(f func(context.Context, string, enum.NotifyKind, string) (*entity.Notification, error)) *MockNotificationRepositoryFindByIdempotencyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Index20260520001UP indicates an expected call of Index20260520001UP.
func (mr *MockNotificationRepositoryMockRecorder) Index20260520001UP(ctx any) *MockNotificationRepositoryIndex20260520001UPCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Index20260520001UP", reflect.TypeOf((*MockNotificationRepository)(nil).Index20260520001UP), ctx)
	return &MockNotificationRepositoryIndex20260520001UPCall{Call: call}
}

// MockNotificationRepositoryIndex20260520001UPCall wrap *gomock.Call
type MockNotificationRepositoryIndex20260520001UPCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockNotificationRepositoryIndex20260520001UPCall) Return(arg0 error) *MockNotificationRepositoryIndex20260520001UPCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockNotificationRepositoryIndex20260520001UPCall) Do(f func(context.Context) error) *MockNotificationRepositoryIndex20260520001UPCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockNotificationRepositoryIndex20260520001UPCall) DoAndReturn(f func(context.Context) error) *MockNotificationRepositoryIndex20260520001UPCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Insert mocks base method.
func (m *MockNotificationRepository) Insert(ctx context.Context, data *entity.Notification) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Insert", ctx, data)
	ret0, _ := ret[0].(error)
	return ret0
}

// Insert indicates an expected call of Insert.
func (mr *MockNotificationRepositoryMockRecorder) Insert(ctx, data any) *MockNotificationRepositoryInsertCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Insert", reflect.TypeOf((*MockNotificationRepository)(nil).Insert), ctx, data)
	return &MockNotificationRepositoryInsertCall{Call: call}
}

// MockNotificationRepositoryInsertCall wrap *gomock.Call
type MockNotificationRepositoryInsertCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockNotificationRepositoryInsertCall) Return(arg0 error) *MockNotificationRepositoryInsertCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockNotificationRepositoryInsertCall) Do(f func(context.Context, *entity.Notification) error) *MockNotificationRepositoryInsertCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockNotificationRepositoryInsertCall) DoAndReturn(f func(context.Context, *entity.Notification) error) *MockNotificationRepositoryInsertCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UpdateDelivery mocks base method.
func (m *MockNotificationRepository) UpdateDelivery(ctx context.Context, tenantID, id string, update *repository.NotificationDeliveryUpdate) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDelivery", ctx, tenantID, id, update)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateDelivery indicates an expected call of UpdateDelivery.
func (mr *MockNotificationRepositoryMockRecorder) UpdateDelivery(ctx, tenantID, id, update any) *MockNotificationRepositoryUpdateDeliveryCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDelivery", reflect.TypeOf((*MockNotificationRepository)(nil).UpdateDelivery), ctx, tenantID, id, update)
	return &MockNotificationRepositoryUpdateDeliveryCall{Call: call}
}

// MockNotificationRepositoryUpdateDeliveryCall wrap *gomock.Call
type MockNotificationRepositoryUpdateDeliveryCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockNotificationRepositoryUpdateDeliveryCall) Return(arg0 error) *MockNotificationRepositoryUpdateDeliveryCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockNotificationRepositoryUpdateDeliveryCall) Do(f func(context.Context, string, string, *repository.NotificationDeliveryUpdate) error) *MockNotificationRepositoryUpdateDeliveryCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockNotificationRepositoryUpdateDeliveryCall) DoAndReturn(f func(context.Context, string, string, *repository.NotificationDeliveryUpdate) error) *MockNotificationRepositoryUpdateDeliveryCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockNotificationDLQRepository is a mock of NotificationDLQRepository interface.
type MockNotificationDLQRepository struct {
	ctrl     *gomock.Controller
	recorder *MockNotificationDLQRepositoryMockRecorder
	isgomock struct{}
}

// MockNotificationDLQRepositoryMockRecorder is the mock recorder for MockNotificationDLQRepository.
type MockNotificationDLQRepositoryMockRecorder struct {
	mock *MockNotificationDLQRepository
}

// NewMockNotificationDLQRepository creates a new mock instance.
func NewMockNotificationDLQRepository(ctrl *gomock.Controller) *MockNotificationDLQRepository {
	mock := &MockNotificationDLQRepository{ctrl: ctrl}
	mock.recorder = &MockNotificationDLQRepositoryMockRecorder{mock}
	return mock
}

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

// FindByID mocks base method.
func (m *MockNotificationDLQRepository) FindByID(ctx context.Context, tenantID, id string) (*entity.NotificationDLQ, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindByID", ctx, tenantID, id)
	ret0, _ := ret[0].(*entity.NotificationDLQ)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindByID indicates an expected call of FindByID.
func (mr *MockNotificationDLQRepositoryMockRecorder) FindByID(ctx, tenantID, id any) *MockNotificationDLQRepositoryFindByIDCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByID", reflect.TypeOf((*MockNotificationDLQRepository)(nil).FindByID), ctx, tenantID, id)
	return &MockNotificationDLQRepositoryFindByIDCall{Call: call}
}

// MockNotificationDLQRepositoryFindByIDCall wrap *gomock.Call
type MockNotificationDLQRepositoryFindByIDCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockNotificationDLQRepositoryFindByIDCall) Return(arg0 *entity.NotificationDLQ, arg1 error) *MockNotificationDLQRepositoryFindByIDCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockNotificationDLQRepositoryFindByIDCall) Do(f func(context.Context, string, string) (*entity.NotificationDLQ, error)) *MockNotificationDLQRepositoryFindByIDCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockNotificationDLQRepositoryFindByIDCall) DoAndReturn(f func(context.Context, string, string) (*entity.NotificationDLQ, error)) *MockNotificationDLQRepositoryFindByIDCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Index20260520001UP indicates an expected call of Index20260520001UP.
func (mr *MockNotificationDLQRepositoryMockRecorder) Index20260520001UP(ctx any) *MockNotificationDLQRepositoryIndex20260520001UPCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Index20260520001UP", reflect.TypeOf((*MockNotificationDLQRepository)(nil).Index20260520001UP), ctx)
	return &MockNotificationDLQRepositoryIndex20260520001UPCall{Call: call}
}

// MockNotificationDLQRepositoryIndex20260520001UPCall wrap *gomock.Call
type MockNotificationDLQRepositoryIndex20260520001UPCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockNotificationDLQRepositoryIndex20260520001UPCall) Return(arg0 error) *MockNotificationDLQRepositoryIndex20260520001UPCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockNotificationDLQRepositoryIndex20260520001UPCall) Do(f func(context.Context) error) *MockNotificationDLQRepositoryIndex20260520001UPCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockNotificationDLQRepositoryIndex20260520001UPCall) DoAndReturn(f func(context.Context) error) *MockNotificationDLQRepositoryIndex20260520001UPCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Insert mocks base method.
func (m *MockNotificationDLQRepository) Insert(ctx context.Context, data *entity.NotificationDLQ) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Insert", ctx, data)
	ret0, _ := ret[0].(error)
	return ret0
}

// Insert indicates an expected call of Insert.
func (mr *MockNotificationDLQRepositoryMockRecorder) Insert(ctx, data any) *MockNotificationDLQRepositoryInsertCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Insert", reflect.TypeOf((*MockNotificationDLQRepository)(nil).Insert), ctx, data)
	return &MockNotificationDLQRepositoryInsertCall{Call: call}
}

// MockNotificationDLQRepositoryInsertCall wrap *gomock.Call
type MockNotificationDLQRepositoryInsertCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockNotificationDLQRepositoryInsertCall) Return(arg0 error) *MockNotificationDLQRepositoryInsertCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockNotificationDLQRepositoryInsertCall) Do(f func(context.Context, *entity.NotificationDLQ) error) *MockNotificationDLQRepositoryInsertCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockNotificationDLQRepositoryInsertCall) DoAndReturn(f func(context.Context, *entity.NotificationDLQ) error) *MockNotificationDLQRepositoryInsertCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListByTenant mocks base method.
func (m *MockNotificationDLQRepository) ListByTenant(ctx context.Context, tenantID string, limit int64) ([]*entity.NotificationDLQ, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListByTenant", ctx, tenantID, limit)
	ret0, _ := ret[0].([]*entity.NotificationDLQ)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListByTenant indicates an expected call of ListByTenant.
func (mr *MockNotificationDLQRepositoryMockRecorder) ListByTenant(ctx, tenantID, limit any) *MockNotificationDLQRepositoryListByTenantCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListByTenant", reflect.TypeOf((*MockNotificationDLQRepository)(nil).ListByTenant), ctx, tenantID, limit)
	return &MockNotificationDLQRepositoryListByTenantCall{Call: call}
}

// MockNotificationDLQRepositoryListByTenantCall wrap *gomock.Call
type MockNotificationDLQRepositoryListByTenantCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockNotificationDLQRepositoryListByTenantCall) Return(arg0 []*entity.NotificationDLQ, arg1 error) *MockNotificationDLQRepositoryListByTenantCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockNotificationDLQRepositoryListByTenantCall) Do(f func(context.Context, string, int64) ([]*entity.NotificationDLQ, error)) *MockNotificationDLQRepositoryListByTenantCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockNotificationDLQRepositoryListByTenantCall) DoAndReturn(f func(context.Context, string, int64) ([]*entity.NotificationDLQ, error)) *MockNotificationDLQRepositoryListByTenantCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockIdempotencyCache is a mock of IdempotencyCache interface.
type MockIdempotencyCache struct {
	ctrl     *gomock.Controller
	recorder *MockIdempotencyCacheMockRecorder
	isgomock struct{}
}

// MockIdempotencyCacheMockRecorder is the mock recorder for MockIdempotencyCache.
type MockIdempotencyCacheMockRecorder struct {
	mock *MockIdempotencyCache
}

// NewMockIdempotencyCache creates a new mock instance.
func NewMockIdempotencyCache(ctrl *gomock.Controller) *MockIdempotencyCache {
	mock := &MockIdempotencyCache{ctrl: ctrl}
	mock.recorder = &MockIdempotencyCacheMockRecorder{mock}
	return mock
}

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

// Get mocks base method.
func (m *MockIdempotencyCache) Get(ctx context.Context, key string) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, key)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockIdempotencyCacheMockRecorder) Get(ctx, key any) *MockIdempotencyCacheGetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockIdempotencyCache)(nil).Get), ctx, key)
	return &MockIdempotencyCacheGetCall{Call: call}
}

// MockIdempotencyCacheGetCall wrap *gomock.Call
type MockIdempotencyCacheGetCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockIdempotencyCacheGetCall) Return(arg0 []byte, arg1 error) *MockIdempotencyCacheGetCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockIdempotencyCacheGetCall) Do(f func(context.Context, string) ([]byte, error)) *MockIdempotencyCacheGetCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIdempotencyCacheGetCall) DoAndReturn(f func(context.Context, string) ([]byte, error)) *MockIdempotencyCacheGetCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Set mocks base method.
func (m *MockIdempotencyCache) Set(ctx context.Context, key string, value []byte, ttl time.Duration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Set", ctx, key, value, ttl)
	ret0, _ := ret[0].(error)
	return ret0
}

// Set indicates an expected call of Set.
func (mr *MockIdempotencyCacheMockRecorder) Set(ctx, key, value, ttl any) *MockIdempotencyCacheSetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockIdempotencyCache)(nil).Set), ctx, key, value, ttl)
	return &MockIdempotencyCacheSetCall{Call: call}
}

// MockIdempotencyCacheSetCall wrap *gomock.Call
type MockIdempotencyCacheSetCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockIdempotencyCacheSetCall) Return(arg0 error) *MockIdempotencyCacheSetCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockIdempotencyCacheSetCall) Do(f func(context.Context, string, []byte, time.Duration) error) *MockIdempotencyCacheSetCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIdempotencyCacheSetCall) DoAndReturn(f func(context.Context, string, []byte, time.Duration) error) *MockIdempotencyCacheSetCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockQuotaCounter is a mock of QuotaCounter interface.
type MockQuotaCounter struct {
	ctrl     *gomock.Controller
	recorder *MockQuotaCounterMockRecorder
	isgomock struct{}
}

// MockQuotaCounterMockRecorder is the mock recorder for MockQuotaCounter.
type MockQuotaCounterMockRecorder struct {
	mock *MockQuotaCounter
}

// NewMockQuotaCounter creates a new mock instance.
func NewMockQuotaCounter(ctrl *gomock.Controller) *MockQuotaCounter {
	mock := &MockQuotaCounter{ctrl: ctrl}
	mock.recorder = &MockQuotaCounterMockRecorder{mock}
	return mock
}

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

// Incr mocks base method.
func (m *MockQuotaCounter) Incr(ctx context.Context, key string, ttl time.Duration) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Incr", ctx, key, ttl)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Incr indicates an expected call of Incr.
func (mr *MockQuotaCounterMockRecorder) Incr(ctx, key, ttl any) *MockQuotaCounterIncrCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Incr", reflect.TypeOf((*MockQuotaCounter)(nil).Incr), ctx, key, ttl)
	return &MockQuotaCounterIncrCall{Call: call}
}

// MockQuotaCounterIncrCall wrap *gomock.Call
type MockQuotaCounterIncrCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockQuotaCounterIncrCall) Return(arg0 int64, arg1 error) *MockQuotaCounterIncrCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQuotaCounterIncrCall) Do(f func(context.Context, string, time.Duration) (int64, error)) *MockQuotaCounterIncrCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQuotaCounterIncrCall) DoAndReturn(f func(context.Context, string, time.Duration) (int64, error)) *MockQuotaCounterIncrCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockRetryQueue is a mock of RetryQueue interface.
type MockRetryQueue struct {
	ctrl     *gomock.Controller
	recorder *MockRetryQueueMockRecorder
	isgomock struct{}
}

// MockRetryQueueMockRecorder is the mock recorder for MockRetryQueue.
type MockRetryQueueMockRecorder struct {
	mock *MockRetryQueue
}

// NewMockRetryQueue creates a new mock instance.
func NewMockRetryQueue(ctrl *gomock.Controller) *MockRetryQueue {
	mock := &MockRetryQueue{ctrl: ctrl}
	mock.recorder = &MockRetryQueueMockRecorder{mock}
	return mock
}

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

// ClaimDue mocks base method.
func (m *MockRetryQueue) ClaimDue(ctx context.Context, nowMs int64, limit int) ([]*usecase.RetryJob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClaimDue", ctx, nowMs, limit)
	ret0, _ := ret[0].([]*usecase.RetryJob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ClaimDue indicates an expected call of ClaimDue.
func (mr *MockRetryQueueMockRecorder) ClaimDue(ctx, nowMs, limit any) *MockRetryQueueClaimDueCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClaimDue", reflect.TypeOf((*MockRetryQueue)(nil).ClaimDue), ctx, nowMs, limit)
	return &MockRetryQueueClaimDueCall{Call: call}
}

// MockRetryQueueClaimDueCall wrap *gomock.Call
type MockRetryQueueClaimDueCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRetryQueueClaimDueCall) Return(arg0 []*usecase.RetryJob, arg1 error) *MockRetryQueueClaimDueCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRetryQueueClaimDueCall) Do(f func(context.Context, int64, int) ([]*usecase.RetryJob, error)) *MockRetryQueueClaimDueCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRetryQueueClaimDueCall) DoAndReturn(f func(context.Context, int64, int) ([]*usecase.RetryJob, error)) *MockRetryQueueClaimDueCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Schedule mocks base method.
func (m *MockRetryQueue) Schedule(ctx context.Context, runAtMs int64, job *usecase.RetryJob) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Schedule", ctx, runAtMs, job)
	ret0, _ := ret[0].(error)
	return ret0
}

// Schedule indicates an expected call of Schedule.
func (mr *MockRetryQueueMockRecorder) Schedule(ctx, runAtMs, job any) *MockRetryQueueScheduleCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Schedule", reflect.TypeOf((*MockRetryQueue)(nil).Schedule), ctx, runAtMs, job)
	return &MockRetryQueueScheduleCall{Call: call}
}

// MockRetryQueueScheduleCall wrap *gomock.Call
type MockRetryQueueScheduleCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRetryQueueScheduleCall) Return(arg0 error) *MockRetryQueueScheduleCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRetryQueueScheduleCall) Do(f func(context.Context, int64, *usecase.RetryJob) error) *MockRetryQueueScheduleCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRetryQueueScheduleCall) DoAndReturn(f func(context.Context, int64, *usecase.RetryJob) error) *MockRetryQueueScheduleCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
