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"
	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"
	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
}

// 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)
}

// 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)
}

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

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

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

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

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

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

// 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) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConnectorsInstall", ctx, c)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// 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)
}

// 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)
}

// 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)
}

// 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)
}

// 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)
}

// 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)
}

// 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)
}

// 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)
}

// 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)
}

// 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)
}

// 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)
}