payments/internal/storage/storage_generated.go

// Code generated by MockGen. DO NOT EDIT.
// Source: storage.go
//
// Generated by this command:
//
//	mockgen -source storage.go -destination storage_generated.go -package storage . Storage
//

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

import (
	context "context"
	json "encoding/json"
	reflect "reflect"
	time "time"

	bunpaginate "github.com/formancehq/go-libs/v3/bun/bunpaginate"
	models "github.com/formancehq/payments/internal/models"
	uuid "github.com/google/uuid"
	bun "github.com/uptrace/bun"
	gomock "go.uber.org/mock/gomock"
)

// MockStorage is a mock of Storage interface.
type MockStorage struct {
	ctrl     *gomock.Controller
	recorder *MockStorageMockRecorder
	isgomock struct{}
}

// MockStorageMockRecorder is the mock recorder for MockStorage.
type MockStorageMockRecorder struct {
	mock *MockStorage
}

// NewMockStorage creates a new mock instance.
func NewMockStorage(ctrl *gomock.Controller) *MockStorage {
	mock := &MockStorage{ctrl: ctrl}
	mock.recorder = &MockStorageMockRecorder{mock}
	return mock
}

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

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

// AccountsDelete indicates an expected call of AccountsDelete.
func (mr *MockStorageMockRecorder) AccountsDelete(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountsDelete", reflect.TypeOf((*MockStorage)(nil).AccountsDelete), ctx, id)
}

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

// AccountsDeleteFromConnectorID indicates an expected call of AccountsDeleteFromConnectorID.
func (mr *MockStorageMockRecorder) AccountsDeleteFromConnectorID(ctx, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountsDeleteFromConnectorID", reflect.TypeOf((*MockStorage)(nil).AccountsDeleteFromConnectorID), ctx, connectorID)
}

// AccountsDeleteFromConnectorIDAndPSUID mocks base method.
func (m *MockStorage) AccountsDeleteFromConnectorIDAndPSUID(ctx context.Context, connectorID models.ConnectorID, psuID uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AccountsDeleteFromConnectorIDAndPSUID", ctx, connectorID, psuID)
	ret0, _ := ret[0].(error)
	return ret0
}

// AccountsDeleteFromConnectorIDAndPSUID indicates an expected call of AccountsDeleteFromConnectorIDAndPSUID.
func (mr *MockStorageMockRecorder) AccountsDeleteFromConnectorIDAndPSUID(ctx, connectorID, psuID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountsDeleteFromConnectorIDAndPSUID", reflect.TypeOf((*MockStorage)(nil).AccountsDeleteFromConnectorIDAndPSUID), ctx, connectorID, psuID)
}

// AccountsDeleteFromConnectorIDBatch mocks base method.
func (m *MockStorage) AccountsDeleteFromConnectorIDBatch(ctx context.Context, connectorID models.ConnectorID, batchSize int) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AccountsDeleteFromConnectorIDBatch", ctx, connectorID, batchSize)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AccountsDeleteFromConnectorIDBatch indicates an expected call of AccountsDeleteFromConnectorIDBatch.
func (mr *MockStorageMockRecorder) AccountsDeleteFromConnectorIDBatch(ctx, connectorID, batchSize any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountsDeleteFromConnectorIDBatch", reflect.TypeOf((*MockStorage)(nil).AccountsDeleteFromConnectorIDBatch), ctx, connectorID, batchSize)
}

// AccountsDeleteFromOpenBankingConnectionID mocks base method.
func (m *MockStorage) AccountsDeleteFromOpenBankingConnectionID(ctx context.Context, psuID uuid.UUID, connectorID models.ConnectorID, openBankingConnectionID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AccountsDeleteFromOpenBankingConnectionID", ctx, psuID, connectorID, openBankingConnectionID)
	ret0, _ := ret[0].(error)
	return ret0
}

// AccountsDeleteFromOpenBankingConnectionID indicates an expected call of AccountsDeleteFromOpenBankingConnectionID.
func (mr *MockStorageMockRecorder) AccountsDeleteFromOpenBankingConnectionID(ctx, psuID, connectorID, openBankingConnectionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountsDeleteFromOpenBankingConnectionID", reflect.TypeOf((*MockStorage)(nil).AccountsDeleteFromOpenBankingConnectionID), ctx, psuID, connectorID, openBankingConnectionID)
}

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

// AccountsDeleteFromPSUID indicates an expected call of AccountsDeleteFromPSUID.
func (mr *MockStorageMockRecorder) AccountsDeleteFromPSUID(ctx, psuID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountsDeleteFromPSUID", reflect.TypeOf((*MockStorage)(nil).AccountsDeleteFromPSUID), ctx, psuID)
}

// AccountsGet mocks base method.
func (m *MockStorage) AccountsGet(ctx context.Context, id models.AccountID) (*models.Account, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AccountsGet", ctx, id)
	ret0, _ := ret[0].(*models.Account)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AccountsGet indicates an expected call of AccountsGet.
func (mr *MockStorageMockRecorder) AccountsGet(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountsGet", reflect.TypeOf((*MockStorage)(nil).AccountsGet), ctx, id)
}

// AccountsList mocks base method.
func (m *MockStorage) AccountsList(ctx context.Context, q ListAccountsQuery) (*bunpaginate.Cursor[models.Account], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AccountsList", ctx, q)
	ret0, _ := ret[0].(*bunpaginate.Cursor[models.Account])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AccountsList indicates an expected call of AccountsList.
func (mr *MockStorageMockRecorder) AccountsList(ctx, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountsList", reflect.TypeOf((*MockStorage)(nil).AccountsList), ctx, q)
}

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

// AccountsUpsert indicates an expected call of AccountsUpsert.
func (mr *MockStorageMockRecorder) AccountsUpsert(ctx, accounts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountsUpsert", reflect.TypeOf((*MockStorage)(nil).AccountsUpsert), ctx, accounts)
}

// BalancesGetFromAccountIDs mocks base method.
func (m *MockStorage) BalancesGetFromAccountIDs(ctx context.Context, accountIDs []models.AccountID, at *time.Time) ([]models.AggregatedBalance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BalancesGetFromAccountIDs", ctx, accountIDs, at)
	ret0, _ := ret[0].([]models.AggregatedBalance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BalancesGetFromAccountIDs indicates an expected call of BalancesGetFromAccountIDs.
func (mr *MockStorageMockRecorder) BalancesGetFromAccountIDs(ctx, accountIDs, at any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BalancesGetFromAccountIDs", reflect.TypeOf((*MockStorage)(nil).BalancesGetFromAccountIDs), ctx, accountIDs, at)
}

// BalancesList mocks base method.
func (m *MockStorage) BalancesList(ctx context.Context, q ListBalancesQuery) (*bunpaginate.Cursor[models.Balance], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BalancesList", ctx, q)
	ret0, _ := ret[0].(*bunpaginate.Cursor[models.Balance])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BalancesList indicates an expected call of BalancesList.
func (mr *MockStorageMockRecorder) BalancesList(ctx, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BalancesList", reflect.TypeOf((*MockStorage)(nil).BalancesList), ctx, q)
}

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

// BalancesUpsert indicates an expected call of BalancesUpsert.
func (mr *MockStorageMockRecorder) BalancesUpsert(ctx, balances any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BalancesUpsert", reflect.TypeOf((*MockStorage)(nil).BalancesUpsert), ctx, balances)
}

// BankAccountsAddRelatedAccount mocks base method.
func (m *MockStorage) BankAccountsAddRelatedAccount(ctx context.Context, bID uuid.UUID, relatedAccount models.BankAccountRelatedAccount) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BankAccountsAddRelatedAccount", ctx, bID, relatedAccount)
	ret0, _ := ret[0].(error)
	return ret0
}

// BankAccountsAddRelatedAccount indicates an expected call of BankAccountsAddRelatedAccount.
func (mr *MockStorageMockRecorder) BankAccountsAddRelatedAccount(ctx, bID, relatedAccount any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BankAccountsAddRelatedAccount", reflect.TypeOf((*MockStorage)(nil).BankAccountsAddRelatedAccount), ctx, bID, relatedAccount)
}

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

// BankAccountsDeleteRelatedAccountFromConnectorID indicates an expected call of BankAccountsDeleteRelatedAccountFromConnectorID.
func (mr *MockStorageMockRecorder) BankAccountsDeleteRelatedAccountFromConnectorID(ctx, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BankAccountsDeleteRelatedAccountFromConnectorID", reflect.TypeOf((*MockStorage)(nil).BankAccountsDeleteRelatedAccountFromConnectorID), ctx, connectorID)
}

// BankAccountsGet mocks base method.
func (m *MockStorage) BankAccountsGet(ctx context.Context, id uuid.UUID, expand bool) (*models.BankAccount, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BankAccountsGet", ctx, id, expand)
	ret0, _ := ret[0].(*models.BankAccount)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BankAccountsGet indicates an expected call of BankAccountsGet.
func (mr *MockStorageMockRecorder) BankAccountsGet(ctx, id, expand any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BankAccountsGet", reflect.TypeOf((*MockStorage)(nil).BankAccountsGet), ctx, id, expand)
}

// BankAccountsList mocks base method.
func (m *MockStorage) BankAccountsList(ctx context.Context, q ListBankAccountsQuery) (*bunpaginate.Cursor[models.BankAccount], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BankAccountsList", ctx, q)
	ret0, _ := ret[0].(*bunpaginate.Cursor[models.BankAccount])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BankAccountsList indicates an expected call of BankAccountsList.
func (mr *MockStorageMockRecorder) BankAccountsList(ctx, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BankAccountsList", reflect.TypeOf((*MockStorage)(nil).BankAccountsList), ctx, q)
}

// BankAccountsUpdateMetadata mocks base method.
func (m *MockStorage) BankAccountsUpdateMetadata(ctx context.Context, id uuid.UUID, metadata map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BankAccountsUpdateMetadata", ctx, id, metadata)
	ret0, _ := ret[0].(error)
	return ret0
}

// BankAccountsUpdateMetadata indicates an expected call of BankAccountsUpdateMetadata.
func (mr *MockStorageMockRecorder) BankAccountsUpdateMetadata(ctx, id, metadata any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BankAccountsUpdateMetadata", reflect.TypeOf((*MockStorage)(nil).BankAccountsUpdateMetadata), ctx, id, metadata)
}

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

// BankAccountsUpsert indicates an expected call of BankAccountsUpsert.
func (mr *MockStorageMockRecorder) BankAccountsUpsert(ctx, bankAccount any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BankAccountsUpsert", reflect.TypeOf((*MockStorage)(nil).BankAccountsUpsert), ctx, bankAccount)
}

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

// Close indicates an expected call of Close.
func (mr *MockStorageMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStorage)(nil).Close))
}

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

// ConnectorTasksTreeDeleteFromConnectorID indicates an expected call of ConnectorTasksTreeDeleteFromConnectorID.
func (mr *MockStorageMockRecorder) ConnectorTasksTreeDeleteFromConnectorID(ctx, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectorTasksTreeDeleteFromConnectorID", reflect.TypeOf((*MockStorage)(nil).ConnectorTasksTreeDeleteFromConnectorID), ctx, connectorID)
}

// ConnectorTasksTreeGet mocks base method.
func (m *MockStorage) ConnectorTasksTreeGet(ctx context.Context, connectorID models.ConnectorID) (*models.ConnectorTasksTree, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConnectorTasksTreeGet", ctx, connectorID)
	ret0, _ := ret[0].(*models.ConnectorTasksTree)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ConnectorTasksTreeGet indicates an expected call of ConnectorTasksTreeGet.
func (mr *MockStorageMockRecorder) ConnectorTasksTreeGet(ctx, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectorTasksTreeGet", reflect.TypeOf((*MockStorage)(nil).ConnectorTasksTreeGet), ctx, connectorID)
}

// ConnectorTasksTreeUpsert mocks base method.
func (m *MockStorage) ConnectorTasksTreeUpsert(ctx context.Context, connectorID models.ConnectorID, tasks models.ConnectorTasksTree) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConnectorTasksTreeUpsert", ctx, connectorID, tasks)
	ret0, _ := ret[0].(error)
	return ret0
}

// ConnectorTasksTreeUpsert indicates an expected call of ConnectorTasksTreeUpsert.
func (mr *MockStorageMockRecorder) ConnectorTasksTreeUpsert(ctx, connectorID, tasks any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectorTasksTreeUpsert", reflect.TypeOf((*MockStorage)(nil).ConnectorTasksTreeUpsert), ctx, connectorID, tasks)
}

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

// ConnectorsConfigUpdate indicates an expected call of ConnectorsConfigUpdate.
func (mr *MockStorageMockRecorder) ConnectorsConfigUpdate(ctx, c any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectorsConfigUpdate", reflect.TypeOf((*MockStorage)(nil).ConnectorsConfigUpdate), ctx, c)
}

// ConnectorsGet mocks base method.
func (m *MockStorage) ConnectorsGet(ctx context.Context, id models.ConnectorID) (*models.Connector, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConnectorsGet", ctx, id)
	ret0, _ := ret[0].(*models.Connector)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ConnectorsGet indicates an expected call of ConnectorsGet.
func (mr *MockStorageMockRecorder) ConnectorsGet(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectorsGet", reflect.TypeOf((*MockStorage)(nil).ConnectorsGet), ctx, id)
}

// ConnectorsInstall mocks base method.
func (m *MockStorage) ConnectorsInstall(ctx context.Context, c models.Connector, oldConnectorID *models.ConnectorID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConnectorsInstall", ctx, c, oldConnectorID)
	ret0, _ := ret[0].(error)
	return ret0
}

// ConnectorsInstall indicates an expected call of ConnectorsInstall.
func (mr *MockStorageMockRecorder) ConnectorsInstall(ctx, c, oldConnectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectorsInstall", reflect.TypeOf((*MockStorage)(nil).ConnectorsInstall), ctx, c, oldConnectorID)
}

// ConnectorsList mocks base method.
func (m *MockStorage) ConnectorsList(ctx context.Context, q ListConnectorsQuery) (*bunpaginate.Cursor[models.Connector], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConnectorsList", ctx, q)
	ret0, _ := ret[0].(*bunpaginate.Cursor[models.Connector])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ConnectorsList indicates an expected call of ConnectorsList.
func (mr *MockStorageMockRecorder) ConnectorsList(ctx, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectorsList", reflect.TypeOf((*MockStorage)(nil).ConnectorsList), ctx, q)
}

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

// ConnectorsScheduleForDeletion indicates an expected call of ConnectorsScheduleForDeletion.
func (mr *MockStorageMockRecorder) ConnectorsScheduleForDeletion(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectorsScheduleForDeletion", reflect.TypeOf((*MockStorage)(nil).ConnectorsScheduleForDeletion), ctx, id)
}

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

// ConnectorsUninstall indicates an expected call of ConnectorsUninstall.
func (mr *MockStorageMockRecorder) ConnectorsUninstall(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectorsUninstall", reflect.TypeOf((*MockStorage)(nil).ConnectorsUninstall), ctx, id)
}

// DecryptRaw mocks base method.
func (m *MockStorage) DecryptRaw(ctx context.Context, message json.RawMessage) (json.RawMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DecryptRaw", ctx, message)
	ret0, _ := ret[0].(json.RawMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DecryptRaw indicates an expected call of DecryptRaw.
func (mr *MockStorageMockRecorder) DecryptRaw(ctx, message any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecryptRaw", reflect.TypeOf((*MockStorage)(nil).DecryptRaw), ctx, message)
}

// EncryptRaw mocks base method.
func (m *MockStorage) EncryptRaw(ctx context.Context, message json.RawMessage) (json.RawMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EncryptRaw", ctx, message)
	ret0, _ := ret[0].(json.RawMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EncryptRaw indicates an expected call of EncryptRaw.
func (mr *MockStorageMockRecorder) EncryptRaw(ctx, message any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EncryptRaw", reflect.TypeOf((*MockStorage)(nil).EncryptRaw), ctx, message)
}

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

// EventsSentDeleteFromConnectorID indicates an expected call of EventsSentDeleteFromConnectorID.
func (mr *MockStorageMockRecorder) EventsSentDeleteFromConnectorID(ctx, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EventsSentDeleteFromConnectorID", reflect.TypeOf((*MockStorage)(nil).EventsSentDeleteFromConnectorID), ctx, connectorID)
}

// EventsSentDeleteFromConnectorIDBatch mocks base method.
func (m *MockStorage) EventsSentDeleteFromConnectorIDBatch(ctx context.Context, connectorID models.ConnectorID, batchSize int) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EventsSentDeleteFromConnectorIDBatch", ctx, connectorID, batchSize)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EventsSentDeleteFromConnectorIDBatch indicates an expected call of EventsSentDeleteFromConnectorIDBatch.
func (mr *MockStorageMockRecorder) EventsSentDeleteFromConnectorIDBatch(ctx, connectorID, batchSize any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EventsSentDeleteFromConnectorIDBatch", reflect.TypeOf((*MockStorage)(nil).EventsSentDeleteFromConnectorIDBatch), ctx, connectorID, batchSize)
}

// EventsSentExists mocks base method.
func (m *MockStorage) EventsSentExists(ctx context.Context, id models.EventID) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EventsSentExists", ctx, id)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EventsSentExists indicates an expected call of EventsSentExists.
func (mr *MockStorageMockRecorder) EventsSentExists(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EventsSentExists", reflect.TypeOf((*MockStorage)(nil).EventsSentExists), ctx, id)
}

// EventsSentGet mocks base method.
func (m *MockStorage) EventsSentGet(ctx context.Context, id models.EventID) (*models.EventSent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EventsSentGet", ctx, id)
	ret0, _ := ret[0].(*models.EventSent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EventsSentGet indicates an expected call of EventsSentGet.
func (mr *MockStorageMockRecorder) EventsSentGet(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EventsSentGet", reflect.TypeOf((*MockStorage)(nil).EventsSentGet), ctx, id)
}

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

// EventsSentUpsert indicates an expected call of EventsSentUpsert.
func (mr *MockStorageMockRecorder) EventsSentUpsert(ctx, event any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EventsSentUpsert", reflect.TypeOf((*MockStorage)(nil).EventsSentUpsert), ctx, event)
}

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

// InstancesDeleteFromConnectorID indicates an expected call of InstancesDeleteFromConnectorID.
func (mr *MockStorageMockRecorder) InstancesDeleteFromConnectorID(ctx, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstancesDeleteFromConnectorID", reflect.TypeOf((*MockStorage)(nil).InstancesDeleteFromConnectorID), ctx, connectorID)
}

// InstancesDeleteFromConnectorIDBatch mocks base method.
func (m *MockStorage) InstancesDeleteFromConnectorIDBatch(ctx context.Context, connectorID models.ConnectorID, batchSize int) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstancesDeleteFromConnectorIDBatch", ctx, connectorID, batchSize)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InstancesDeleteFromConnectorIDBatch indicates an expected call of InstancesDeleteFromConnectorIDBatch.
func (mr *MockStorageMockRecorder) InstancesDeleteFromConnectorIDBatch(ctx, connectorID, batchSize any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstancesDeleteFromConnectorIDBatch", reflect.TypeOf((*MockStorage)(nil).InstancesDeleteFromConnectorIDBatch), ctx, connectorID, batchSize)
}

// InstancesGet mocks base method.
func (m *MockStorage) InstancesGet(ctx context.Context, id, scheduleID string, connectorID models.ConnectorID) (*models.Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstancesGet", ctx, id, scheduleID, connectorID)
	ret0, _ := ret[0].(*models.Instance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InstancesGet indicates an expected call of InstancesGet.
func (mr *MockStorageMockRecorder) InstancesGet(ctx, id, scheduleID, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstancesGet", reflect.TypeOf((*MockStorage)(nil).InstancesGet), ctx, id, scheduleID, connectorID)
}

// InstancesList mocks base method.
func (m *MockStorage) InstancesList(ctx context.Context, q ListInstancesQuery) (*bunpaginate.Cursor[models.Instance], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstancesList", ctx, q)
	ret0, _ := ret[0].(*bunpaginate.Cursor[models.Instance])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InstancesList indicates an expected call of InstancesList.
func (mr *MockStorageMockRecorder) InstancesList(ctx, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstancesList", reflect.TypeOf((*MockStorage)(nil).InstancesList), ctx, q)
}

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

// InstancesUpdate indicates an expected call of InstancesUpdate.
func (mr *MockStorageMockRecorder) InstancesUpdate(ctx, instance any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstancesUpdate", reflect.TypeOf((*MockStorage)(nil).InstancesUpdate), ctx, instance)
}

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

// InstancesUpsert indicates an expected call of InstancesUpsert.
func (mr *MockStorageMockRecorder) InstancesUpsert(ctx, instance any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstancesUpsert", reflect.TypeOf((*MockStorage)(nil).InstancesUpsert), ctx, instance)
}

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

// ListenConnectorsChanges indicates an expected call of ListenConnectorsChanges.
func (mr *MockStorageMockRecorder) ListenConnectorsChanges(ctx, handler any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListenConnectorsChanges", reflect.TypeOf((*MockStorage)(nil).ListenConnectorsChanges), ctx, handler)
}

// OpenBankingConnectionAttemptsGet mocks base method.
func (m *MockStorage) OpenBankingConnectionAttemptsGet(ctx context.Context, id uuid.UUID) (*models.OpenBankingConnectionAttempt, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenBankingConnectionAttemptsGet", ctx, id)
	ret0, _ := ret[0].(*models.OpenBankingConnectionAttempt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OpenBankingConnectionAttemptsGet indicates an expected call of OpenBankingConnectionAttemptsGet.
func (mr *MockStorageMockRecorder) OpenBankingConnectionAttemptsGet(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenBankingConnectionAttemptsGet", reflect.TypeOf((*MockStorage)(nil).OpenBankingConnectionAttemptsGet), ctx, id)
}

// OpenBankingConnectionAttemptsList mocks base method.
func (m *MockStorage) OpenBankingConnectionAttemptsList(ctx context.Context, psuID uuid.UUID, connectorID models.ConnectorID, query ListOpenBankingConnectionAttemptsQuery) (*bunpaginate.Cursor[models.OpenBankingConnectionAttempt], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenBankingConnectionAttemptsList", ctx, psuID, connectorID, query)
	ret0, _ := ret[0].(*bunpaginate.Cursor[models.OpenBankingConnectionAttempt])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OpenBankingConnectionAttemptsList indicates an expected call of OpenBankingConnectionAttemptsList.
func (mr *MockStorageMockRecorder) OpenBankingConnectionAttemptsList(ctx, psuID, connectorID, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenBankingConnectionAttemptsList", reflect.TypeOf((*MockStorage)(nil).OpenBankingConnectionAttemptsList), ctx, psuID, connectorID, query)
}

// OpenBankingConnectionAttemptsUpdateStatus mocks base method.
func (m *MockStorage) OpenBankingConnectionAttemptsUpdateStatus(ctx context.Context, id uuid.UUID, status models.OpenBankingConnectionAttemptStatus, errMsg *string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenBankingConnectionAttemptsUpdateStatus", ctx, id, status, errMsg)
	ret0, _ := ret[0].(error)
	return ret0
}

// OpenBankingConnectionAttemptsUpdateStatus indicates an expected call of OpenBankingConnectionAttemptsUpdateStatus.
func (mr *MockStorageMockRecorder) OpenBankingConnectionAttemptsUpdateStatus(ctx, id, status, errMsg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenBankingConnectionAttemptsUpdateStatus", reflect.TypeOf((*MockStorage)(nil).OpenBankingConnectionAttemptsUpdateStatus), ctx, id, status, errMsg)
}

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

// OpenBankingConnectionAttemptsUpsert indicates an expected call of OpenBankingConnectionAttemptsUpsert.
func (mr *MockStorageMockRecorder) OpenBankingConnectionAttemptsUpsert(ctx, from any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenBankingConnectionAttemptsUpsert", reflect.TypeOf((*MockStorage)(nil).OpenBankingConnectionAttemptsUpsert), ctx, from)
}

// OpenBankingConnectionsDelete mocks base method.
func (m *MockStorage) OpenBankingConnectionsDelete(ctx context.Context, psuID uuid.UUID, connectorID models.ConnectorID, connectionID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenBankingConnectionsDelete", ctx, psuID, connectorID, connectionID)
	ret0, _ := ret[0].(error)
	return ret0
}

// OpenBankingConnectionsDelete indicates an expected call of OpenBankingConnectionsDelete.
func (mr *MockStorageMockRecorder) OpenBankingConnectionsDelete(ctx, psuID, connectorID, connectionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenBankingConnectionsDelete", reflect.TypeOf((*MockStorage)(nil).OpenBankingConnectionsDelete), ctx, psuID, connectorID, connectionID)
}

// OpenBankingConnectionsGet mocks base method.
func (m *MockStorage) OpenBankingConnectionsGet(ctx context.Context, psuID uuid.UUID, connectorID models.ConnectorID, connectionID string) (*models.OpenBankingConnection, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenBankingConnectionsGet", ctx, psuID, connectorID, connectionID)
	ret0, _ := ret[0].(*models.OpenBankingConnection)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OpenBankingConnectionsGet indicates an expected call of OpenBankingConnectionsGet.
func (mr *MockStorageMockRecorder) OpenBankingConnectionsGet(ctx, psuID, connectorID, connectionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenBankingConnectionsGet", reflect.TypeOf((*MockStorage)(nil).OpenBankingConnectionsGet), ctx, psuID, connectorID, connectionID)
}

// OpenBankingConnectionsGetFromConnectionID mocks base method.
func (m *MockStorage) OpenBankingConnectionsGetFromConnectionID(ctx context.Context, connectorID models.ConnectorID, connectionID string) (*models.OpenBankingConnection, uuid.UUID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenBankingConnectionsGetFromConnectionID", ctx, connectorID, connectionID)
	ret0, _ := ret[0].(*models.OpenBankingConnection)
	ret1, _ := ret[1].(uuid.UUID)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// OpenBankingConnectionsGetFromConnectionID indicates an expected call of OpenBankingConnectionsGetFromConnectionID.
func (mr *MockStorageMockRecorder) OpenBankingConnectionsGetFromConnectionID(ctx, connectorID, connectionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenBankingConnectionsGetFromConnectionID", reflect.TypeOf((*MockStorage)(nil).OpenBankingConnectionsGetFromConnectionID), ctx, connectorID, connectionID)
}

// OpenBankingConnectionsList mocks base method.
func (m *MockStorage) OpenBankingConnectionsList(ctx context.Context, psuID uuid.UUID, connectorID *models.ConnectorID, query ListOpenBankingConnectionsQuery) (*bunpaginate.Cursor[models.OpenBankingConnection], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenBankingConnectionsList", ctx, psuID, connectorID, query)
	ret0, _ := ret[0].(*bunpaginate.Cursor[models.OpenBankingConnection])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OpenBankingConnectionsList indicates an expected call of OpenBankingConnectionsList.
func (mr *MockStorageMockRecorder) OpenBankingConnectionsList(ctx, psuID, connectorID, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenBankingConnectionsList", reflect.TypeOf((*MockStorage)(nil).OpenBankingConnectionsList), ctx, psuID, connectorID, query)
}

// OpenBankingConnectionsUpdateLastDataUpdate mocks base method.
func (m *MockStorage) OpenBankingConnectionsUpdateLastDataUpdate(ctx context.Context, psuID uuid.UUID, connectorID models.ConnectorID, connectionID string, updatedAt time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenBankingConnectionsUpdateLastDataUpdate", ctx, psuID, connectorID, connectionID, updatedAt)
	ret0, _ := ret[0].(error)
	return ret0
}

// OpenBankingConnectionsUpdateLastDataUpdate indicates an expected call of OpenBankingConnectionsUpdateLastDataUpdate.
func (mr *MockStorageMockRecorder) OpenBankingConnectionsUpdateLastDataUpdate(ctx, psuID, connectorID, connectionID, updatedAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenBankingConnectionsUpdateLastDataUpdate", reflect.TypeOf((*MockStorage)(nil).OpenBankingConnectionsUpdateLastDataUpdate), ctx, psuID, connectorID, connectionID, updatedAt)
}

// OpenBankingConnectionsUpsert mocks base method.
func (m *MockStorage) OpenBankingConnectionsUpsert(ctx context.Context, psuID uuid.UUID, from models.OpenBankingConnection) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenBankingConnectionsUpsert", ctx, psuID, from)
	ret0, _ := ret[0].(error)
	return ret0
}

// OpenBankingConnectionsUpsert indicates an expected call of OpenBankingConnectionsUpsert.
func (mr *MockStorageMockRecorder) OpenBankingConnectionsUpsert(ctx, psuID, from any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenBankingConnectionsUpsert", reflect.TypeOf((*MockStorage)(nil).OpenBankingConnectionsUpsert), ctx, psuID, from)
}

// OpenBankingForwardedUserDelete mocks base method.
func (m *MockStorage) OpenBankingForwardedUserDelete(ctx context.Context, psuID uuid.UUID, connectorID models.ConnectorID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenBankingForwardedUserDelete", ctx, psuID, connectorID)
	ret0, _ := ret[0].(error)
	return ret0
}

// OpenBankingForwardedUserDelete indicates an expected call of OpenBankingForwardedUserDelete.
func (mr *MockStorageMockRecorder) OpenBankingForwardedUserDelete(ctx, psuID, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenBankingForwardedUserDelete", reflect.TypeOf((*MockStorage)(nil).OpenBankingForwardedUserDelete), ctx, psuID, connectorID)
}

// OpenBankingForwardedUserGet mocks base method.
func (m *MockStorage) OpenBankingForwardedUserGet(ctx context.Context, psuID uuid.UUID, connectorID models.ConnectorID) (*models.OpenBankingForwardedUser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenBankingForwardedUserGet", ctx, psuID, connectorID)
	ret0, _ := ret[0].(*models.OpenBankingForwardedUser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OpenBankingForwardedUserGet indicates an expected call of OpenBankingForwardedUserGet.
func (mr *MockStorageMockRecorder) OpenBankingForwardedUserGet(ctx, psuID, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenBankingForwardedUserGet", reflect.TypeOf((*MockStorage)(nil).OpenBankingForwardedUserGet), ctx, psuID, connectorID)
}

// OpenBankingForwardedUserGetByPSPUserID mocks base method.
func (m *MockStorage) OpenBankingForwardedUserGetByPSPUserID(ctx context.Context, pspUserID string, connectorID models.ConnectorID) (*models.OpenBankingForwardedUser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenBankingForwardedUserGetByPSPUserID", ctx, pspUserID, connectorID)
	ret0, _ := ret[0].(*models.OpenBankingForwardedUser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OpenBankingForwardedUserGetByPSPUserID indicates an expected call of OpenBankingForwardedUserGetByPSPUserID.
func (mr *MockStorageMockRecorder) OpenBankingForwardedUserGetByPSPUserID(ctx, pspUserID, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenBankingForwardedUserGetByPSPUserID", reflect.TypeOf((*MockStorage)(nil).OpenBankingForwardedUserGetByPSPUserID), ctx, pspUserID, connectorID)
}

// OpenBankingForwardedUserList mocks base method.
func (m *MockStorage) OpenBankingForwardedUserList(ctx context.Context, query ListOpenBankingForwardedUserQuery) (*bunpaginate.Cursor[models.OpenBankingForwardedUser], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenBankingForwardedUserList", ctx, query)
	ret0, _ := ret[0].(*bunpaginate.Cursor[models.OpenBankingForwardedUser])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OpenBankingForwardedUserList indicates an expected call of OpenBankingForwardedUserList.
func (mr *MockStorageMockRecorder) OpenBankingForwardedUserList(ctx, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenBankingForwardedUserList", reflect.TypeOf((*MockStorage)(nil).OpenBankingForwardedUserList), ctx, query)
}

// OpenBankingForwardedUserUpsert mocks base method.
func (m *MockStorage) OpenBankingForwardedUserUpsert(ctx context.Context, psuID uuid.UUID, from models.OpenBankingForwardedUser) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenBankingForwardedUserUpsert", ctx, psuID, from)
	ret0, _ := ret[0].(error)
	return ret0
}

// OpenBankingForwardedUserUpsert indicates an expected call of OpenBankingForwardedUserUpsert.
func (mr *MockStorageMockRecorder) OpenBankingForwardedUserUpsert(ctx, psuID, from any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenBankingForwardedUserUpsert", reflect.TypeOf((*MockStorage)(nil).OpenBankingForwardedUserUpsert), ctx, psuID, from)
}

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

// OutboxEventsDeleteOldProcessed indicates an expected call of OutboxEventsDeleteOldProcessed.
func (mr *MockStorageMockRecorder) OutboxEventsDeleteOldProcessed(ctx, olderThan any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OutboxEventsDeleteOldProcessed", reflect.TypeOf((*MockStorage)(nil).OutboxEventsDeleteOldProcessed), ctx, olderThan)
}

// OutboxEventsInsert mocks base method.
func (m *MockStorage) OutboxEventsInsert(ctx context.Context, tx bun.Tx, events []models.OutboxEvent) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OutboxEventsInsert", ctx, tx, events)
	ret0, _ := ret[0].(error)
	return ret0
}

// OutboxEventsInsert indicates an expected call of OutboxEventsInsert.
func (mr *MockStorageMockRecorder) OutboxEventsInsert(ctx, tx, events any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OutboxEventsInsert", reflect.TypeOf((*MockStorage)(nil).OutboxEventsInsert), ctx, tx, events)
}

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

// OutboxEventsInsertWithTx indicates an expected call of OutboxEventsInsertWithTx.
func (mr *MockStorageMockRecorder) OutboxEventsInsertWithTx(ctx, events any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OutboxEventsInsertWithTx", reflect.TypeOf((*MockStorage)(nil).OutboxEventsInsertWithTx), ctx, events)
}

// OutboxEventsMarkFailed mocks base method.
func (m *MockStorage) OutboxEventsMarkFailed(ctx context.Context, eventID models.EventID, retryCount int, err error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OutboxEventsMarkFailed", ctx, eventID, retryCount, err)
	ret0, _ := ret[0].(error)
	return ret0
}

// OutboxEventsMarkFailed indicates an expected call of OutboxEventsMarkFailed.
func (mr *MockStorageMockRecorder) OutboxEventsMarkFailed(ctx, eventID, retryCount, err any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OutboxEventsMarkFailed", reflect.TypeOf((*MockStorage)(nil).OutboxEventsMarkFailed), ctx, eventID, retryCount, err)
}

// OutboxEventsMarkProcessedAndRecordSent mocks base method.
func (m *MockStorage) OutboxEventsMarkProcessedAndRecordSent(ctx context.Context, eventIDs []models.EventID, eventsSent []models.EventSent) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OutboxEventsMarkProcessedAndRecordSent", ctx, eventIDs, eventsSent)
	ret0, _ := ret[0].(error)
	return ret0
}

// OutboxEventsMarkProcessedAndRecordSent indicates an expected call of OutboxEventsMarkProcessedAndRecordSent.
func (mr *MockStorageMockRecorder) OutboxEventsMarkProcessedAndRecordSent(ctx, eventIDs, eventsSent any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OutboxEventsMarkProcessedAndRecordSent", reflect.TypeOf((*MockStorage)(nil).OutboxEventsMarkProcessedAndRecordSent), ctx, eventIDs, eventsSent)
}

// OutboxEventsPollPending mocks base method.
func (m *MockStorage) OutboxEventsPollPending(ctx context.Context, limit int) ([]models.OutboxEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OutboxEventsPollPending", ctx, limit)
	ret0, _ := ret[0].([]models.OutboxEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OutboxEventsPollPending indicates an expected call of OutboxEventsPollPending.
func (mr *MockStorageMockRecorder) OutboxEventsPollPending(ctx, limit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OutboxEventsPollPending", reflect.TypeOf((*MockStorage)(nil).OutboxEventsPollPending), ctx, limit)
}

// PaymentInitiationAdjustmentsGet mocks base method.
func (m *MockStorage) PaymentInitiationAdjustmentsGet(ctx context.Context, id models.PaymentInitiationAdjustmentID) (*models.PaymentInitiationAdjustment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentInitiationAdjustmentsGet", ctx, id)
	ret0, _ := ret[0].(*models.PaymentInitiationAdjustment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PaymentInitiationAdjustmentsGet indicates an expected call of PaymentInitiationAdjustmentsGet.
func (mr *MockStorageMockRecorder) PaymentInitiationAdjustmentsGet(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentInitiationAdjustmentsGet", reflect.TypeOf((*MockStorage)(nil).PaymentInitiationAdjustmentsGet), ctx, id)
}

// PaymentInitiationAdjustmentsList mocks base method.
func (m *MockStorage) PaymentInitiationAdjustmentsList(ctx context.Context, piID models.PaymentInitiationID, q ListPaymentInitiationAdjustmentsQuery) (*bunpaginate.Cursor[models.PaymentInitiationAdjustment], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentInitiationAdjustmentsList", ctx, piID, q)
	ret0, _ := ret[0].(*bunpaginate.Cursor[models.PaymentInitiationAdjustment])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PaymentInitiationAdjustmentsList indicates an expected call of PaymentInitiationAdjustmentsList.
func (mr *MockStorageMockRecorder) PaymentInitiationAdjustmentsList(ctx, piID, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentInitiationAdjustmentsList", reflect.TypeOf((*MockStorage)(nil).PaymentInitiationAdjustmentsList), ctx, piID, q)
}

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

// PaymentInitiationAdjustmentsUpsert indicates an expected call of PaymentInitiationAdjustmentsUpsert.
func (mr *MockStorageMockRecorder) PaymentInitiationAdjustmentsUpsert(ctx, adj any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentInitiationAdjustmentsUpsert", reflect.TypeOf((*MockStorage)(nil).PaymentInitiationAdjustmentsUpsert), ctx, adj)
}

// PaymentInitiationAdjustmentsUpsertIfPredicate mocks base method.
func (m *MockStorage) PaymentInitiationAdjustmentsUpsertIfPredicate(ctx context.Context, adj models.PaymentInitiationAdjustment, predicate func(models.PaymentInitiationAdjustment) bool) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentInitiationAdjustmentsUpsertIfPredicate", ctx, adj, predicate)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PaymentInitiationAdjustmentsUpsertIfPredicate indicates an expected call of PaymentInitiationAdjustmentsUpsertIfPredicate.
func (mr *MockStorageMockRecorder) PaymentInitiationAdjustmentsUpsertIfPredicate(ctx, adj, predicate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentInitiationAdjustmentsUpsertIfPredicate", reflect.TypeOf((*MockStorage)(nil).PaymentInitiationAdjustmentsUpsertIfPredicate), ctx, adj, predicate)
}

// PaymentInitiationIDsListFromPaymentID mocks base method.
func (m *MockStorage) PaymentInitiationIDsListFromPaymentID(ctx context.Context, id models.PaymentID) ([]models.PaymentInitiationID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentInitiationIDsListFromPaymentID", ctx, id)
	ret0, _ := ret[0].([]models.PaymentInitiationID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PaymentInitiationIDsListFromPaymentID indicates an expected call of PaymentInitiationIDsListFromPaymentID.
func (mr *MockStorageMockRecorder) PaymentInitiationIDsListFromPaymentID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentInitiationIDsListFromPaymentID", reflect.TypeOf((*MockStorage)(nil).PaymentInitiationIDsListFromPaymentID), ctx, id)
}

// PaymentInitiationRelatedPaymentsList mocks base method.
func (m *MockStorage) PaymentInitiationRelatedPaymentsList(ctx context.Context, piID models.PaymentInitiationID, q ListPaymentInitiationRelatedPaymentsQuery) (*bunpaginate.Cursor[models.Payment], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentInitiationRelatedPaymentsList", ctx, piID, q)
	ret0, _ := ret[0].(*bunpaginate.Cursor[models.Payment])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PaymentInitiationRelatedPaymentsList indicates an expected call of PaymentInitiationRelatedPaymentsList.
func (mr *MockStorageMockRecorder) PaymentInitiationRelatedPaymentsList(ctx, piID, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentInitiationRelatedPaymentsList", reflect.TypeOf((*MockStorage)(nil).PaymentInitiationRelatedPaymentsList), ctx, piID, q)
}

// PaymentInitiationRelatedPaymentsUpsert mocks base method.
func (m *MockStorage) PaymentInitiationRelatedPaymentsUpsert(ctx context.Context, piID models.PaymentInitiationID, pID models.PaymentID, createdAt time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentInitiationRelatedPaymentsUpsert", ctx, piID, pID, createdAt)
	ret0, _ := ret[0].(error)
	return ret0
}

// PaymentInitiationRelatedPaymentsUpsert indicates an expected call of PaymentInitiationRelatedPaymentsUpsert.
func (mr *MockStorageMockRecorder) PaymentInitiationRelatedPaymentsUpsert(ctx, piID, pID, createdAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentInitiationRelatedPaymentsUpsert", reflect.TypeOf((*MockStorage)(nil).PaymentInitiationRelatedPaymentsUpsert), ctx, piID, pID, createdAt)
}

// PaymentInitiationReversalAdjustmentsGet mocks base method.
func (m *MockStorage) PaymentInitiationReversalAdjustmentsGet(ctx context.Context, id models.PaymentInitiationReversalAdjustmentID) (*models.PaymentInitiationReversalAdjustment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentInitiationReversalAdjustmentsGet", ctx, id)
	ret0, _ := ret[0].(*models.PaymentInitiationReversalAdjustment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PaymentInitiationReversalAdjustmentsGet indicates an expected call of PaymentInitiationReversalAdjustmentsGet.
func (mr *MockStorageMockRecorder) PaymentInitiationReversalAdjustmentsGet(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentInitiationReversalAdjustmentsGet", reflect.TypeOf((*MockStorage)(nil).PaymentInitiationReversalAdjustmentsGet), ctx, id)
}

// PaymentInitiationReversalAdjustmentsList mocks base method.
func (m *MockStorage) PaymentInitiationReversalAdjustmentsList(ctx context.Context, piID models.PaymentInitiationReversalID, q ListPaymentInitiationReversalAdjustmentsQuery) (*bunpaginate.Cursor[models.PaymentInitiationReversalAdjustment], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentInitiationReversalAdjustmentsList", ctx, piID, q)
	ret0, _ := ret[0].(*bunpaginate.Cursor[models.PaymentInitiationReversalAdjustment])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PaymentInitiationReversalAdjustmentsList indicates an expected call of PaymentInitiationReversalAdjustmentsList.
func (mr *MockStorageMockRecorder) PaymentInitiationReversalAdjustmentsList(ctx, piID, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentInitiationReversalAdjustmentsList", reflect.TypeOf((*MockStorage)(nil).PaymentInitiationReversalAdjustmentsList), ctx, piID, q)
}

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

// PaymentInitiationReversalAdjustmentsUpsert indicates an expected call of PaymentInitiationReversalAdjustmentsUpsert.
func (mr *MockStorageMockRecorder) PaymentInitiationReversalAdjustmentsUpsert(ctx, adj any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentInitiationReversalAdjustmentsUpsert", reflect.TypeOf((*MockStorage)(nil).PaymentInitiationReversalAdjustmentsUpsert), ctx, adj)
}

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

// PaymentInitiationReversalsDeleteFromConnectorID indicates an expected call of PaymentInitiationReversalsDeleteFromConnectorID.
func (mr *MockStorageMockRecorder) PaymentInitiationReversalsDeleteFromConnectorID(ctx, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentInitiationReversalsDeleteFromConnectorID", reflect.TypeOf((*MockStorage)(nil).PaymentInitiationReversalsDeleteFromConnectorID), ctx, connectorID)
}

// PaymentInitiationReversalsGet mocks base method.
func (m *MockStorage) PaymentInitiationReversalsGet(ctx context.Context, id models.PaymentInitiationReversalID) (*models.PaymentInitiationReversal, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentInitiationReversalsGet", ctx, id)
	ret0, _ := ret[0].(*models.PaymentInitiationReversal)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PaymentInitiationReversalsGet indicates an expected call of PaymentInitiationReversalsGet.
func (mr *MockStorageMockRecorder) PaymentInitiationReversalsGet(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentInitiationReversalsGet", reflect.TypeOf((*MockStorage)(nil).PaymentInitiationReversalsGet), ctx, id)
}

// PaymentInitiationReversalsList mocks base method.
func (m *MockStorage) PaymentInitiationReversalsList(ctx context.Context, q ListPaymentInitiationReversalsQuery) (*bunpaginate.Cursor[models.PaymentInitiationReversal], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentInitiationReversalsList", ctx, q)
	ret0, _ := ret[0].(*bunpaginate.Cursor[models.PaymentInitiationReversal])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PaymentInitiationReversalsList indicates an expected call of PaymentInitiationReversalsList.
func (mr *MockStorageMockRecorder) PaymentInitiationReversalsList(ctx, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentInitiationReversalsList", reflect.TypeOf((*MockStorage)(nil).PaymentInitiationReversalsList), ctx, q)
}

// PaymentInitiationReversalsUpsert mocks base method.
func (m *MockStorage) PaymentInitiationReversalsUpsert(ctx context.Context, pir models.PaymentInitiationReversal, reversalAdjustments []models.PaymentInitiationReversalAdjustment) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentInitiationReversalsUpsert", ctx, pir, reversalAdjustments)
	ret0, _ := ret[0].(error)
	return ret0
}

// PaymentInitiationReversalsUpsert indicates an expected call of PaymentInitiationReversalsUpsert.
func (mr *MockStorageMockRecorder) PaymentInitiationReversalsUpsert(ctx, pir, reversalAdjustments any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentInitiationReversalsUpsert", reflect.TypeOf((*MockStorage)(nil).PaymentInitiationReversalsUpsert), ctx, pir, reversalAdjustments)
}

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

// PaymentInitiationsDelete indicates an expected call of PaymentInitiationsDelete.
func (mr *MockStorageMockRecorder) PaymentInitiationsDelete(ctx, piID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentInitiationsDelete", reflect.TypeOf((*MockStorage)(nil).PaymentInitiationsDelete), ctx, piID)
}

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

// PaymentInitiationsDeleteFromConnectorID indicates an expected call of PaymentInitiationsDeleteFromConnectorID.
func (mr *MockStorageMockRecorder) PaymentInitiationsDeleteFromConnectorID(ctx, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentInitiationsDeleteFromConnectorID", reflect.TypeOf((*MockStorage)(nil).PaymentInitiationsDeleteFromConnectorID), ctx, connectorID)
}

// PaymentInitiationsGet mocks base method.
func (m *MockStorage) PaymentInitiationsGet(ctx context.Context, piID models.PaymentInitiationID) (*models.PaymentInitiation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentInitiationsGet", ctx, piID)
	ret0, _ := ret[0].(*models.PaymentInitiation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PaymentInitiationsGet indicates an expected call of PaymentInitiationsGet.
func (mr *MockStorageMockRecorder) PaymentInitiationsGet(ctx, piID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentInitiationsGet", reflect.TypeOf((*MockStorage)(nil).PaymentInitiationsGet), ctx, piID)
}

// PaymentInitiationsInsert mocks base method.
func (m *MockStorage) PaymentInitiationsInsert(ctx context.Context, pi models.PaymentInitiation, adjustments ...models.PaymentInitiationAdjustment) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, pi}
	for _, a := range adjustments {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PaymentInitiationsInsert", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// PaymentInitiationsInsert indicates an expected call of PaymentInitiationsInsert.
func (mr *MockStorageMockRecorder) PaymentInitiationsInsert(ctx, pi any, adjustments ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, pi}, adjustments...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentInitiationsInsert", reflect.TypeOf((*MockStorage)(nil).PaymentInitiationsInsert), varargs...)
}

// PaymentInitiationsList mocks base method.
func (m *MockStorage) PaymentInitiationsList(ctx context.Context, q ListPaymentInitiationsQuery) (*bunpaginate.Cursor[models.PaymentInitiation], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentInitiationsList", ctx, q)
	ret0, _ := ret[0].(*bunpaginate.Cursor[models.PaymentInitiation])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PaymentInitiationsList indicates an expected call of PaymentInitiationsList.
func (mr *MockStorageMockRecorder) PaymentInitiationsList(ctx, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentInitiationsList", reflect.TypeOf((*MockStorage)(nil).PaymentInitiationsList), ctx, q)
}

// PaymentInitiationsUpdateMetadata mocks base method.
func (m *MockStorage) PaymentInitiationsUpdateMetadata(ctx context.Context, piID models.PaymentInitiationID, metadata map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentInitiationsUpdateMetadata", ctx, piID, metadata)
	ret0, _ := ret[0].(error)
	return ret0
}

// PaymentInitiationsUpdateMetadata indicates an expected call of PaymentInitiationsUpdateMetadata.
func (mr *MockStorageMockRecorder) PaymentInitiationsUpdateMetadata(ctx, piID, metadata any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentInitiationsUpdateMetadata", reflect.TypeOf((*MockStorage)(nil).PaymentInitiationsUpdateMetadata), ctx, piID, metadata)
}

// PaymentServiceUsersAddBankAccount mocks base method.
func (m *MockStorage) PaymentServiceUsersAddBankAccount(ctx context.Context, psuID, bankAccountID uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentServiceUsersAddBankAccount", ctx, psuID, bankAccountID)
	ret0, _ := ret[0].(error)
	return ret0
}

// PaymentServiceUsersAddBankAccount indicates an expected call of PaymentServiceUsersAddBankAccount.
func (mr *MockStorageMockRecorder) PaymentServiceUsersAddBankAccount(ctx, psuID, bankAccountID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentServiceUsersAddBankAccount", reflect.TypeOf((*MockStorage)(nil).PaymentServiceUsersAddBankAccount), ctx, psuID, bankAccountID)
}

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

// PaymentServiceUsersCreate indicates an expected call of PaymentServiceUsersCreate.
func (mr *MockStorageMockRecorder) PaymentServiceUsersCreate(ctx, psu any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentServiceUsersCreate", reflect.TypeOf((*MockStorage)(nil).PaymentServiceUsersCreate), ctx, psu)
}

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

// PaymentServiceUsersDelete indicates an expected call of PaymentServiceUsersDelete.
func (mr *MockStorageMockRecorder) PaymentServiceUsersDelete(ctx, paymentServiceUserID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentServiceUsersDelete", reflect.TypeOf((*MockStorage)(nil).PaymentServiceUsersDelete), ctx, paymentServiceUserID)
}

// PaymentServiceUsersGet mocks base method.
func (m *MockStorage) PaymentServiceUsersGet(ctx context.Context, id uuid.UUID) (*models.PaymentServiceUser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentServiceUsersGet", ctx, id)
	ret0, _ := ret[0].(*models.PaymentServiceUser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PaymentServiceUsersGet indicates an expected call of PaymentServiceUsersGet.
func (mr *MockStorageMockRecorder) PaymentServiceUsersGet(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentServiceUsersGet", reflect.TypeOf((*MockStorage)(nil).PaymentServiceUsersGet), ctx, id)
}

// PaymentServiceUsersList mocks base method.
func (m *MockStorage) PaymentServiceUsersList(ctx context.Context, query ListPSUsQuery) (*bunpaginate.Cursor[models.PaymentServiceUser], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentServiceUsersList", ctx, query)
	ret0, _ := ret[0].(*bunpaginate.Cursor[models.PaymentServiceUser])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PaymentServiceUsersList indicates an expected call of PaymentServiceUsersList.
func (mr *MockStorageMockRecorder) PaymentServiceUsersList(ctx, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentServiceUsersList", reflect.TypeOf((*MockStorage)(nil).PaymentServiceUsersList), ctx, query)
}

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

// PaymentsDelete indicates an expected call of PaymentsDelete.
func (mr *MockStorageMockRecorder) PaymentsDelete(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentsDelete", reflect.TypeOf((*MockStorage)(nil).PaymentsDelete), ctx, id)
}

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

// PaymentsDeleteFromAccountID indicates an expected call of PaymentsDeleteFromAccountID.
func (mr *MockStorageMockRecorder) PaymentsDeleteFromAccountID(ctx, accountID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentsDeleteFromAccountID", reflect.TypeOf((*MockStorage)(nil).PaymentsDeleteFromAccountID), ctx, accountID)
}

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

// PaymentsDeleteFromConnectorID indicates an expected call of PaymentsDeleteFromConnectorID.
func (mr *MockStorageMockRecorder) PaymentsDeleteFromConnectorID(ctx, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentsDeleteFromConnectorID", reflect.TypeOf((*MockStorage)(nil).PaymentsDeleteFromConnectorID), ctx, connectorID)
}

// PaymentsDeleteFromConnectorIDAndPSUID mocks base method.
func (m *MockStorage) PaymentsDeleteFromConnectorIDAndPSUID(ctx context.Context, connectorID models.ConnectorID, psuID uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentsDeleteFromConnectorIDAndPSUID", ctx, connectorID, psuID)
	ret0, _ := ret[0].(error)
	return ret0
}

// PaymentsDeleteFromConnectorIDAndPSUID indicates an expected call of PaymentsDeleteFromConnectorIDAndPSUID.
func (mr *MockStorageMockRecorder) PaymentsDeleteFromConnectorIDAndPSUID(ctx, connectorID, psuID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentsDeleteFromConnectorIDAndPSUID", reflect.TypeOf((*MockStorage)(nil).PaymentsDeleteFromConnectorIDAndPSUID), ctx, connectorID, psuID)
}

// PaymentsDeleteFromConnectorIDBatch mocks base method.
func (m *MockStorage) PaymentsDeleteFromConnectorIDBatch(ctx context.Context, connectorID models.ConnectorID, batchSize int) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentsDeleteFromConnectorIDBatch", ctx, connectorID, batchSize)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PaymentsDeleteFromConnectorIDBatch indicates an expected call of PaymentsDeleteFromConnectorIDBatch.
func (mr *MockStorageMockRecorder) PaymentsDeleteFromConnectorIDBatch(ctx, connectorID, batchSize any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentsDeleteFromConnectorIDBatch", reflect.TypeOf((*MockStorage)(nil).PaymentsDeleteFromConnectorIDBatch), ctx, connectorID, batchSize)
}

// PaymentsDeleteFromOpenBankingConnectionID mocks base method.
func (m *MockStorage) PaymentsDeleteFromOpenBankingConnectionID(ctx context.Context, psuID uuid.UUID, connectorID models.ConnectorID, openBankingConnectionID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentsDeleteFromOpenBankingConnectionID", ctx, psuID, connectorID, openBankingConnectionID)
	ret0, _ := ret[0].(error)
	return ret0
}

// PaymentsDeleteFromOpenBankingConnectionID indicates an expected call of PaymentsDeleteFromOpenBankingConnectionID.
func (mr *MockStorageMockRecorder) PaymentsDeleteFromOpenBankingConnectionID(ctx, psuID, connectorID, openBankingConnectionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentsDeleteFromOpenBankingConnectionID", reflect.TypeOf((*MockStorage)(nil).PaymentsDeleteFromOpenBankingConnectionID), ctx, psuID, connectorID, openBankingConnectionID)
}

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

// PaymentsDeleteFromPSUID indicates an expected call of PaymentsDeleteFromPSUID.
func (mr *MockStorageMockRecorder) PaymentsDeleteFromPSUID(ctx, psuID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentsDeleteFromPSUID", reflect.TypeOf((*MockStorage)(nil).PaymentsDeleteFromPSUID), ctx, psuID)
}

// PaymentsDeleteFromReference mocks base method.
func (m *MockStorage) PaymentsDeleteFromReference(ctx context.Context, reference string, connectorID models.ConnectorID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentsDeleteFromReference", ctx, reference, connectorID)
	ret0, _ := ret[0].(error)
	return ret0
}

// PaymentsDeleteFromReference indicates an expected call of PaymentsDeleteFromReference.
func (mr *MockStorageMockRecorder) PaymentsDeleteFromReference(ctx, reference, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentsDeleteFromReference", reflect.TypeOf((*MockStorage)(nil).PaymentsDeleteFromReference), ctx, reference, connectorID)
}

// PaymentsGet mocks base method.
func (m *MockStorage) PaymentsGet(ctx context.Context, id models.PaymentID) (*models.Payment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentsGet", ctx, id)
	ret0, _ := ret[0].(*models.Payment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PaymentsGet indicates an expected call of PaymentsGet.
func (mr *MockStorageMockRecorder) PaymentsGet(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentsGet", reflect.TypeOf((*MockStorage)(nil).PaymentsGet), ctx, id)
}

// PaymentsGetByReference mocks base method.
func (m *MockStorage) PaymentsGetByReference(ctx context.Context, reference string, connectorID models.ConnectorID) (*models.Payment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentsGetByReference", ctx, reference, connectorID)
	ret0, _ := ret[0].(*models.Payment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PaymentsGetByReference indicates an expected call of PaymentsGetByReference.
func (mr *MockStorageMockRecorder) PaymentsGetByReference(ctx, reference, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentsGetByReference", reflect.TypeOf((*MockStorage)(nil).PaymentsGetByReference), ctx, reference, connectorID)
}

// PaymentsList mocks base method.
func (m *MockStorage) PaymentsList(ctx context.Context, q ListPaymentsQuery) (*bunpaginate.Cursor[models.Payment], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentsList", ctx, q)
	ret0, _ := ret[0].(*bunpaginate.Cursor[models.Payment])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PaymentsList indicates an expected call of PaymentsList.
func (mr *MockStorageMockRecorder) PaymentsList(ctx, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentsList", reflect.TypeOf((*MockStorage)(nil).PaymentsList), ctx, q)
}

// PaymentsUpdateMetadata mocks base method.
func (m *MockStorage) PaymentsUpdateMetadata(ctx context.Context, id models.PaymentID, metadata map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaymentsUpdateMetadata", ctx, id, metadata)
	ret0, _ := ret[0].(error)
	return ret0
}

// PaymentsUpdateMetadata indicates an expected call of PaymentsUpdateMetadata.
func (mr *MockStorageMockRecorder) PaymentsUpdateMetadata(ctx, id, metadata any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentsUpdateMetadata", reflect.TypeOf((*MockStorage)(nil).PaymentsUpdateMetadata), ctx, id, metadata)
}

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

// PaymentsUpsert indicates an expected call of PaymentsUpsert.
func (mr *MockStorageMockRecorder) PaymentsUpsert(ctx, payments any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentsUpsert", reflect.TypeOf((*MockStorage)(nil).PaymentsUpsert), ctx, payments)
}

// PoolsAddAccount mocks base method.
func (m *MockStorage) PoolsAddAccount(ctx context.Context, id uuid.UUID, accountID models.AccountID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PoolsAddAccount", ctx, id, accountID)
	ret0, _ := ret[0].(error)
	return ret0
}

// PoolsAddAccount indicates an expected call of PoolsAddAccount.
func (mr *MockStorageMockRecorder) PoolsAddAccount(ctx, id, accountID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PoolsAddAccount", reflect.TypeOf((*MockStorage)(nil).PoolsAddAccount), ctx, id, accountID)
}

// PoolsDelete mocks base method.
func (m *MockStorage) PoolsDelete(ctx context.Context, id uuid.UUID) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PoolsDelete", ctx, id)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PoolsDelete indicates an expected call of PoolsDelete.
func (mr *MockStorageMockRecorder) PoolsDelete(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PoolsDelete", reflect.TypeOf((*MockStorage)(nil).PoolsDelete), ctx, id)
}

// PoolsGet mocks base method.
func (m *MockStorage) PoolsGet(ctx context.Context, id uuid.UUID) (*models.Pool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PoolsGet", ctx, id)
	ret0, _ := ret[0].(*models.Pool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PoolsGet indicates an expected call of PoolsGet.
func (mr *MockStorageMockRecorder) PoolsGet(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PoolsGet", reflect.TypeOf((*MockStorage)(nil).PoolsGet), ctx, id)
}

// PoolsList mocks base method.
func (m *MockStorage) PoolsList(ctx context.Context, q ListPoolsQuery) (*bunpaginate.Cursor[models.Pool], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PoolsList", ctx, q)
	ret0, _ := ret[0].(*bunpaginate.Cursor[models.Pool])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PoolsList indicates an expected call of PoolsList.
func (mr *MockStorageMockRecorder) PoolsList(ctx, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PoolsList", reflect.TypeOf((*MockStorage)(nil).PoolsList), ctx, q)
}

// PoolsRemoveAccount mocks base method.
func (m *MockStorage) PoolsRemoveAccount(ctx context.Context, id uuid.UUID, accountID models.AccountID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PoolsRemoveAccount", ctx, id, accountID)
	ret0, _ := ret[0].(error)
	return ret0
}

// PoolsRemoveAccount indicates an expected call of PoolsRemoveAccount.
func (mr *MockStorageMockRecorder) PoolsRemoveAccount(ctx, id, accountID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PoolsRemoveAccount", reflect.TypeOf((*MockStorage)(nil).PoolsRemoveAccount), ctx, id, accountID)
}

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

// PoolsRemoveAccountsFromConnectorID indicates an expected call of PoolsRemoveAccountsFromConnectorID.
func (mr *MockStorageMockRecorder) PoolsRemoveAccountsFromConnectorID(ctx, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PoolsRemoveAccountsFromConnectorID", reflect.TypeOf((*MockStorage)(nil).PoolsRemoveAccountsFromConnectorID), ctx, connectorID)
}

// PoolsUpdateQuery mocks base method.
func (m *MockStorage) PoolsUpdateQuery(ctx context.Context, p models.Pool, query map[string]any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PoolsUpdateQuery", ctx, p, query)
	ret0, _ := ret[0].(error)
	return ret0
}

// PoolsUpdateQuery indicates an expected call of PoolsUpdateQuery.
func (mr *MockStorageMockRecorder) PoolsUpdateQuery(ctx, p, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PoolsUpdateQuery", reflect.TypeOf((*MockStorage)(nil).PoolsUpdateQuery), ctx, p, query)
}

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

// PoolsUpsert indicates an expected call of PoolsUpsert.
func (mr *MockStorageMockRecorder) PoolsUpsert(ctx, pool any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PoolsUpsert", reflect.TypeOf((*MockStorage)(nil).PoolsUpsert), ctx, pool)
}

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

// SchedulesDelete indicates an expected call of SchedulesDelete.
func (mr *MockStorageMockRecorder) SchedulesDelete(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SchedulesDelete", reflect.TypeOf((*MockStorage)(nil).SchedulesDelete), ctx, id)
}

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

// SchedulesDeleteFromConnectorID indicates an expected call of SchedulesDeleteFromConnectorID.
func (mr *MockStorageMockRecorder) SchedulesDeleteFromConnectorID(ctx, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SchedulesDeleteFromConnectorID", reflect.TypeOf((*MockStorage)(nil).SchedulesDeleteFromConnectorID), ctx, connectorID)
}

// SchedulesDeleteFromConnectorIDBatch mocks base method.
func (m *MockStorage) SchedulesDeleteFromConnectorIDBatch(ctx context.Context, connectorID models.ConnectorID, batchSize int) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SchedulesDeleteFromConnectorIDBatch", ctx, connectorID, batchSize)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SchedulesDeleteFromConnectorIDBatch indicates an expected call of SchedulesDeleteFromConnectorIDBatch.
func (mr *MockStorageMockRecorder) SchedulesDeleteFromConnectorIDBatch(ctx, connectorID, batchSize any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SchedulesDeleteFromConnectorIDBatch", reflect.TypeOf((*MockStorage)(nil).SchedulesDeleteFromConnectorIDBatch), ctx, connectorID, batchSize)
}

// SchedulesGet mocks base method.
func (m *MockStorage) SchedulesGet(ctx context.Context, id string, connectorID models.ConnectorID) (*models.Schedule, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SchedulesGet", ctx, id, connectorID)
	ret0, _ := ret[0].(*models.Schedule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SchedulesGet indicates an expected call of SchedulesGet.
func (mr *MockStorageMockRecorder) SchedulesGet(ctx, id, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SchedulesGet", reflect.TypeOf((*MockStorage)(nil).SchedulesGet), ctx, id, connectorID)
}

// SchedulesList mocks base method.
func (m *MockStorage) SchedulesList(ctx context.Context, q ListSchedulesQuery) (*bunpaginate.Cursor[models.Schedule], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SchedulesList", ctx, q)
	ret0, _ := ret[0].(*bunpaginate.Cursor[models.Schedule])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SchedulesList indicates an expected call of SchedulesList.
func (mr *MockStorageMockRecorder) SchedulesList(ctx, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SchedulesList", reflect.TypeOf((*MockStorage)(nil).SchedulesList), ctx, q)
}

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

// SchedulesUpsert indicates an expected call of SchedulesUpsert.
func (mr *MockStorageMockRecorder) SchedulesUpsert(ctx, schedule any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SchedulesUpsert", reflect.TypeOf((*MockStorage)(nil).SchedulesUpsert), ctx, schedule)
}

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

// StatesDeleteFromConnectorID indicates an expected call of StatesDeleteFromConnectorID.
func (mr *MockStorageMockRecorder) StatesDeleteFromConnectorID(ctx, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatesDeleteFromConnectorID", reflect.TypeOf((*MockStorage)(nil).StatesDeleteFromConnectorID), ctx, connectorID)
}

// StatesGet mocks base method.
func (m *MockStorage) StatesGet(ctx context.Context, id models.StateID) (models.State, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StatesGet", ctx, id)
	ret0, _ := ret[0].(models.State)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StatesGet indicates an expected call of StatesGet.
func (mr *MockStorageMockRecorder) StatesGet(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatesGet", reflect.TypeOf((*MockStorage)(nil).StatesGet), ctx, id)
}

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

// StatesUpsert indicates an expected call of StatesUpsert.
func (mr *MockStorageMockRecorder) StatesUpsert(ctx, state any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatesUpsert", reflect.TypeOf((*MockStorage)(nil).StatesUpsert), ctx, state)
}

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

// TasksDeleteFromConnectorID indicates an expected call of TasksDeleteFromConnectorID.
func (mr *MockStorageMockRecorder) TasksDeleteFromConnectorID(ctx, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TasksDeleteFromConnectorID", reflect.TypeOf((*MockStorage)(nil).TasksDeleteFromConnectorID), ctx, connectorID)
}

// TasksGet mocks base method.
func (m *MockStorage) TasksGet(ctx context.Context, id models.TaskID) (*models.Task, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TasksGet", ctx, id)
	ret0, _ := ret[0].(*models.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TasksGet indicates an expected call of TasksGet.
func (mr *MockStorageMockRecorder) TasksGet(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TasksGet", reflect.TypeOf((*MockStorage)(nil).TasksGet), ctx, id)
}

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

// TasksUpsert indicates an expected call of TasksUpsert.
func (mr *MockStorageMockRecorder) TasksUpsert(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TasksUpsert", reflect.TypeOf((*MockStorage)(nil).TasksUpsert), ctx, task)
}

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

// WebhooksConfigsDeleteFromConnectorID indicates an expected call of WebhooksConfigsDeleteFromConnectorID.
func (mr *MockStorageMockRecorder) WebhooksConfigsDeleteFromConnectorID(ctx, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WebhooksConfigsDeleteFromConnectorID", reflect.TypeOf((*MockStorage)(nil).WebhooksConfigsDeleteFromConnectorID), ctx, connectorID)
}

// WebhooksConfigsGet mocks base method.
func (m *MockStorage) WebhooksConfigsGet(ctx context.Context, name string, connectorID models.ConnectorID) (*models.WebhookConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WebhooksConfigsGet", ctx, name, connectorID)
	ret0, _ := ret[0].(*models.WebhookConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WebhooksConfigsGet indicates an expected call of WebhooksConfigsGet.
func (mr *MockStorageMockRecorder) WebhooksConfigsGet(ctx, name, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WebhooksConfigsGet", reflect.TypeOf((*MockStorage)(nil).WebhooksConfigsGet), ctx, name, connectorID)
}

// WebhooksConfigsGetFromConnectorID mocks base method.
func (m *MockStorage) WebhooksConfigsGetFromConnectorID(ctx context.Context, connectorID models.ConnectorID) ([]models.WebhookConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WebhooksConfigsGetFromConnectorID", ctx, connectorID)
	ret0, _ := ret[0].([]models.WebhookConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WebhooksConfigsGetFromConnectorID indicates an expected call of WebhooksConfigsGetFromConnectorID.
func (mr *MockStorageMockRecorder) WebhooksConfigsGetFromConnectorID(ctx, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WebhooksConfigsGetFromConnectorID", reflect.TypeOf((*MockStorage)(nil).WebhooksConfigsGetFromConnectorID), ctx, connectorID)
}

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

// WebhooksConfigsUpsert indicates an expected call of WebhooksConfigsUpsert.
func (mr *MockStorageMockRecorder) WebhooksConfigsUpsert(ctx, webhooksConfigs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WebhooksConfigsUpsert", reflect.TypeOf((*MockStorage)(nil).WebhooksConfigsUpsert), ctx, webhooksConfigs)
}

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

// WebhooksDeleteFromConnectorID indicates an expected call of WebhooksDeleteFromConnectorID.
func (mr *MockStorageMockRecorder) WebhooksDeleteFromConnectorID(ctx, connectorID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WebhooksDeleteFromConnectorID", reflect.TypeOf((*MockStorage)(nil).WebhooksDeleteFromConnectorID), ctx, connectorID)
}

// WebhooksGet mocks base method.
func (m *MockStorage) WebhooksGet(ctx context.Context, id string) (models.Webhook, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WebhooksGet", ctx, id)
	ret0, _ := ret[0].(models.Webhook)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WebhooksGet indicates an expected call of WebhooksGet.
func (mr *MockStorageMockRecorder) WebhooksGet(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WebhooksGet", reflect.TypeOf((*MockStorage)(nil).WebhooksGet), ctx, id)
}

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

// WebhooksInsert indicates an expected call of WebhooksInsert.
func (mr *MockStorageMockRecorder) WebhooksInsert(ctx, webhook any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WebhooksInsert", reflect.TypeOf((*MockStorage)(nil).WebhooksInsert), ctx, webhook)
}