beacon-server/db/sqlc/mock/querier.go

// Code generated by MockGen. DO NOT EDIT.
// Source: db/sqlc/querier.go
//
// Generated by this command:
//
//	mockgen -source db/sqlc/querier.go -destination db/sqlc/mock/querier.go -package mockdb
//

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

import (
	context "context"
	reflect "reflect"

	db "github.com/MeshCore-Beacon/beacon-server/db/sqlc"
	uuid "github.com/google/uuid"
	pgtype "github.com/jackc/pgx/v5/pgtype"
	gomock "go.uber.org/mock/gomock"
)

// MockQuerier is a mock of Querier interface.
type MockQuerier struct {
	ctrl     *gomock.Controller
	recorder *MockQuerierMockRecorder
	isgomock struct{}
}

// MockQuerierMockRecorder is the mock recorder for MockQuerier.
type MockQuerierMockRecorder struct {
	mock *MockQuerier
}

// NewMockQuerier creates a new mock instance.
func NewMockQuerier(ctrl *gomock.Controller) *MockQuerier {
	mock := &MockQuerier{ctrl: ctrl}
	mock.recorder = &MockQuerierMockRecorder{mock}
	return mock
}

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

// AmbiguousPrefixes mocks base method.
func (m *MockQuerier) AmbiguousPrefixes(ctx context.Context) ([]db.AmbiguousPrefixesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AmbiguousPrefixes", ctx)
	ret0, _ := ret[0].([]db.AmbiguousPrefixesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAccount mocks base method.
func (m *MockQuerier) CreateAccount(ctx context.Context, name string) (db.Account, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAccount", ctx, name)
	ret0, _ := ret[0].(db.Account)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

// DeleteOldChannelIATAs indicates an expected call of DeleteOldChannelIATAs.
func (mr *MockQuerierMockRecorder) DeleteOldChannelIATAs(ctx, lastHeard any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldChannelIATAs", reflect.TypeOf((*MockQuerier)(nil).DeleteOldChannelIATAs), ctx, lastHeard)
}

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

// DeleteOldNodes indicates an expected call of DeleteOldNodes.
func (mr *MockQuerierMockRecorder) DeleteOldNodes(ctx, lastSeen any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldNodes", reflect.TypeOf((*MockQuerier)(nil).DeleteOldNodes), ctx, lastSeen)
}

// DeleteOldObservers mocks base method.
func (m *MockQuerier) DeleteOldObservers(ctx context.Context, lastSeen pgtype.Timestamptz) ([]uuid.UUID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOldObservers", ctx, lastSeen)
	ret0, _ := ret[0].([]uuid.UUID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteOldObservers indicates an expected call of DeleteOldObservers.
func (mr *MockQuerierMockRecorder) DeleteOldObservers(ctx, lastSeen any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldObservers", reflect.TypeOf((*MockQuerier)(nil).DeleteOldObservers), ctx, lastSeen)
}

// DeleteOldPackets mocks base method.
func (m *MockQuerier) DeleteOldPackets(ctx context.Context, arg db.DeleteOldPacketsParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOldPackets", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteOldPackets indicates an expected call of DeleteOldPackets.
func (mr *MockQuerierMockRecorder) DeleteOldPackets(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldPackets", reflect.TypeOf((*MockQuerier)(nil).DeleteOldPackets), ctx, arg)
}

// DeleteOldRoutes mocks base method.
func (m *MockQuerier) DeleteOldRoutes(ctx context.Context, arg db.DeleteOldRoutesParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOldRoutes", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteOldRoutes indicates an expected call of DeleteOldRoutes.
func (mr *MockQuerierMockRecorder) DeleteOldRoutes(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldRoutes", reflect.TypeOf((*MockQuerier)(nil).DeleteOldRoutes), ctx, arg)
}

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

// DeleteOldTelemetry indicates an expected call of DeleteOldTelemetry.
func (mr *MockQuerierMockRecorder) DeleteOldTelemetry(ctx, reportedAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldTelemetry", reflect.TypeOf((*MockQuerier)(nil).DeleteOldTelemetry), ctx, reportedAt)
}

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

// DeleteOldTraceIATAs indicates an expected call of DeleteOldTraceIATAs.
func (mr *MockQuerierMockRecorder) DeleteOldTraceIATAs(ctx, lastHeard any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldTraceIATAs", reflect.TypeOf((*MockQuerier)(nil).DeleteOldTraceIATAs), ctx, lastHeard)
}

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

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

// GetChannelByID mocks base method.
func (m *MockQuerier) GetChannelByID(ctx context.Context, id int32) (db.Channel, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChannelByID", ctx, id)
	ret0, _ := ret[0].(db.Channel)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCrossIATANeighbors mocks base method.
func (m *MockQuerier) GetCrossIATANeighbors(ctx context.Context, arg db.GetCrossIATANeighborsParams) ([]db.GetCrossIATANeighborsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCrossIATANeighbors", ctx, arg)
	ret0, _ := ret[0].([]db.GetCrossIATANeighborsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCrossIATANeighbors indicates an expected call of GetCrossIATANeighbors.
func (mr *MockQuerierMockRecorder) GetCrossIATANeighbors(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCrossIATANeighbors", reflect.TypeOf((*MockQuerier)(nil).GetCrossIATANeighbors), ctx, arg)
}

// GetHourlyStats mocks base method.
func (m *MockQuerier) GetHourlyStats(ctx context.Context, arg db.GetHourlyStatsParams) ([]db.MvHourlyIataStat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHourlyStats", ctx, arg)
	ret0, _ := ret[0].([]db.MvHourlyIataStat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHourlyStats indicates an expected call of GetHourlyStats.
func (mr *MockQuerierMockRecorder) GetHourlyStats(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHourlyStats", reflect.TypeOf((*MockQuerier)(nil).GetHourlyStats), ctx, arg)
}

// GetIATA mocks base method.
func (m *MockQuerier) GetIATA(ctx context.Context, iata string) (db.IataCode, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIATA", ctx, iata)
	ret0, _ := ret[0].(db.IataCode)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIATA indicates an expected call of GetIATA.
func (mr *MockQuerierMockRecorder) GetIATA(ctx, iata any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIATA", reflect.TypeOf((*MockQuerier)(nil).GetIATA), ctx, iata)
}

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

// GetIATABorder indicates an expected call of GetIATABorder.
func (mr *MockQuerierMockRecorder) GetIATABorder(ctx, iata any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIATABorder", reflect.TypeOf((*MockQuerier)(nil).GetIATABorder), ctx, iata)
}

// GetKnownRoutesByNode mocks base method.
func (m *MockQuerier) GetKnownRoutesByNode(ctx context.Context, arg db.GetKnownRoutesByNodeParams) ([]db.GetKnownRoutesByNodeRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetKnownRoutesByNode", ctx, arg)
	ret0, _ := ret[0].([]db.GetKnownRoutesByNodeRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetKnownRoutesByNode indicates an expected call of GetKnownRoutesByNode.
func (mr *MockQuerierMockRecorder) GetKnownRoutesByNode(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKnownRoutesByNode", reflect.TypeOf((*MockQuerier)(nil).GetKnownRoutesByNode), ctx, arg)
}

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

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

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

// GetNodeByPubkey indicates an expected call of GetNodeByPubkey.
func (mr *MockQuerierMockRecorder) GetNodeByPubkey(ctx, publicKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeByPubkey", reflect.TypeOf((*MockQuerier)(nil).GetNodeByPubkey), ctx, publicKey)
}

// GetNodeNeighbors mocks base method.
func (m *MockQuerier) GetNodeNeighbors(ctx context.Context, nodeID uuid.UUID) ([]db.GetNodeNeighborsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNodeNeighbors", ctx, nodeID)
	ret0, _ := ret[0].([]db.GetNodeNeighborsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodeNeighbors indicates an expected call of GetNodeNeighbors.
func (mr *MockQuerierMockRecorder) GetNodeNeighbors(ctx, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeNeighbors", reflect.TypeOf((*MockQuerier)(nil).GetNodeNeighbors), ctx, nodeID)
}

// GetNodesByIDs mocks base method.
func (m *MockQuerier) GetNodesByIDs(ctx context.Context, dollar_1 []uuid.UUID) ([]db.GetNodesByIDsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNodesByIDs", ctx, dollar_1)
	ret0, _ := ret[0].([]db.GetNodesByIDsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodesByIDs indicates an expected call of GetNodesByIDs.
func (mr *MockQuerierMockRecorder) GetNodesByIDs(ctx, dollar_1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodesByIDs", reflect.TypeOf((*MockQuerier)(nil).GetNodesByIDs), ctx, dollar_1)
}

// GetNodesByPubkeys mocks base method.
func (m *MockQuerier) GetNodesByPubkeys(ctx context.Context, pubkeys [][]byte) ([]db.GetNodesByPubkeysRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNodesByPubkeys", ctx, pubkeys)
	ret0, _ := ret[0].([]db.GetNodesByPubkeysRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodesByPubkeys indicates an expected call of GetNodesByPubkeys.
func (mr *MockQuerierMockRecorder) GetNodesByPubkeys(ctx, pubkeys any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodesByPubkeys", reflect.TypeOf((*MockQuerier)(nil).GetNodesByPubkeys), ctx, pubkeys)
}

// GetObserverActivityHourly mocks base method.
func (m *MockQuerier) GetObserverActivityHourly(ctx context.Context, arg db.GetObserverActivityHourlyParams) ([]db.GetObserverActivityHourlyRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObserverActivityHourly", ctx, arg)
	ret0, _ := ret[0].([]db.GetObserverActivityHourlyRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObserverActivityHourly indicates an expected call of GetObserverActivityHourly.
func (mr *MockQuerierMockRecorder) GetObserverActivityHourly(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObserverActivityHourly", reflect.TypeOf((*MockQuerier)(nil).GetObserverActivityHourly), ctx, arg)
}

// GetObserverActivityHourlyPayloadTypes mocks base method.
func (m *MockQuerier) GetObserverActivityHourlyPayloadTypes(ctx context.Context, arg db.GetObserverActivityHourlyPayloadTypesParams) ([]db.GetObserverActivityHourlyPayloadTypesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObserverActivityHourlyPayloadTypes", ctx, arg)
	ret0, _ := ret[0].([]db.GetObserverActivityHourlyPayloadTypesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObserverActivityHourlyPayloadTypes indicates an expected call of GetObserverActivityHourlyPayloadTypes.
func (mr *MockQuerierMockRecorder) GetObserverActivityHourlyPayloadTypes(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObserverActivityHourlyPayloadTypes", reflect.TypeOf((*MockQuerier)(nil).GetObserverActivityHourlyPayloadTypes), ctx, arg)
}

// GetObserverActivityLiveSummary mocks base method.
func (m *MockQuerier) GetObserverActivityLiveSummary(ctx context.Context, arg db.GetObserverActivityLiveSummaryParams) (db.GetObserverActivityLiveSummaryRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObserverActivityLiveSummary", ctx, arg)
	ret0, _ := ret[0].(db.GetObserverActivityLiveSummaryRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObserverActivityLiveSummary indicates an expected call of GetObserverActivityLiveSummary.
func (mr *MockQuerierMockRecorder) GetObserverActivityLiveSummary(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObserverActivityLiveSummary", reflect.TypeOf((*MockQuerier)(nil).GetObserverActivityLiveSummary), ctx, arg)
}

// GetObserverActivityRaw mocks base method.
func (m *MockQuerier) GetObserverActivityRaw(ctx context.Context, arg db.GetObserverActivityRawParams) ([]db.GetObserverActivityRawRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObserverActivityRaw", ctx, arg)
	ret0, _ := ret[0].([]db.GetObserverActivityRawRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObserverActivityRaw indicates an expected call of GetObserverActivityRaw.
func (mr *MockQuerierMockRecorder) GetObserverActivityRaw(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObserverActivityRaw", reflect.TypeOf((*MockQuerier)(nil).GetObserverActivityRaw), ctx, arg)
}

// GetObserverActivityRawPayloadTypes mocks base method.
func (m *MockQuerier) GetObserverActivityRawPayloadTypes(ctx context.Context, arg db.GetObserverActivityRawPayloadTypesParams) ([]db.GetObserverActivityRawPayloadTypesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObserverActivityRawPayloadTypes", ctx, arg)
	ret0, _ := ret[0].([]db.GetObserverActivityRawPayloadTypesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObserverActivityRawPayloadTypes indicates an expected call of GetObserverActivityRawPayloadTypes.
func (mr *MockQuerierMockRecorder) GetObserverActivityRawPayloadTypes(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObserverActivityRawPayloadTypes", reflect.TypeOf((*MockQuerier)(nil).GetObserverActivityRawPayloadTypes), ctx, arg)
}

// GetObserverBrokers mocks base method.
func (m *MockQuerier) GetObserverBrokers(ctx context.Context, observerID uuid.UUID) ([]db.GetObserverBrokersRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObserverBrokers", ctx, observerID)
	ret0, _ := ret[0].([]db.GetObserverBrokersRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObserverBrokers indicates an expected call of GetObserverBrokers.
func (mr *MockQuerierMockRecorder) GetObserverBrokers(ctx, observerID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObserverBrokers", reflect.TypeOf((*MockQuerier)(nil).GetObserverBrokers), ctx, observerID)
}

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

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

// GetObserverByPubkey mocks base method.
func (m *MockQuerier) GetObserverByPubkey(ctx context.Context, publicKey []byte) (db.Observer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObserverByPubkey", ctx, publicKey)
	ret0, _ := ret[0].(db.Observer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObserverByPubkey indicates an expected call of GetObserverByPubkey.
func (mr *MockQuerierMockRecorder) GetObserverByPubkey(ctx, publicKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObserverByPubkey", reflect.TypeOf((*MockQuerier)(nil).GetObserverByPubkey), ctx, publicKey)
}

// GetObserverComparison mocks base method.
func (m *MockQuerier) GetObserverComparison(ctx context.Context, arg db.GetObserverComparisonParams) (db.GetObserverComparisonRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObserverComparison", ctx, arg)
	ret0, _ := ret[0].(db.GetObserverComparisonRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObserverComparison indicates an expected call of GetObserverComparison.
func (mr *MockQuerierMockRecorder) GetObserverComparison(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObserverComparison", reflect.TypeOf((*MockQuerier)(nil).GetObserverComparison), ctx, arg)
}

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

// GetObserverLastIATA indicates an expected call of GetObserverLastIATA.
func (mr *MockQuerierMockRecorder) GetObserverLastIATA(ctx, observerID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObserverLastIATA", reflect.TypeOf((*MockQuerier)(nil).GetObserverLastIATA), ctx, observerID)
}

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

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

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

// GetObserverScopes indicates an expected call of GetObserverScopes.
func (mr *MockQuerierMockRecorder) GetObserverScopes(ctx, observerID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObserverScopes", reflect.TypeOf((*MockQuerier)(nil).GetObserverScopes), ctx, observerID)
}

// GetObserverTelemetry mocks base method.
func (m *MockQuerier) GetObserverTelemetry(ctx context.Context, arg db.GetObserverTelemetryParams) ([]db.GetObserverTelemetryRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObserverTelemetry", ctx, arg)
	ret0, _ := ret[0].([]db.GetObserverTelemetryRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObserverTelemetry indicates an expected call of GetObserverTelemetry.
func (mr *MockQuerierMockRecorder) GetObserverTelemetry(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObserverTelemetry", reflect.TypeOf((*MockQuerier)(nil).GetObserverTelemetry), ctx, arg)
}

// GetObserverTelemetryBucketed mocks base method.
func (m *MockQuerier) GetObserverTelemetryBucketed(ctx context.Context, arg db.GetObserverTelemetryBucketedParams) ([]db.GetObserverTelemetryBucketedRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObserverTelemetryBucketed", ctx, arg)
	ret0, _ := ret[0].([]db.GetObserverTelemetryBucketedRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObserverTelemetryBucketed indicates an expected call of GetObserverTelemetryBucketed.
func (mr *MockQuerierMockRecorder) GetObserverTelemetryBucketed(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObserverTelemetryBucketed", reflect.TypeOf((*MockQuerier)(nil).GetObserverTelemetryBucketed), ctx, arg)
}

// GetPacketByHash mocks base method.
func (m *MockQuerier) GetPacketByHash(ctx context.Context, packetHash []byte) (db.GetPacketByHashRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPacketByHash", ctx, packetHash)
	ret0, _ := ret[0].(db.GetPacketByHashRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPacketByHash indicates an expected call of GetPacketByHash.
func (mr *MockQuerierMockRecorder) GetPacketByHash(ctx, packetHash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPacketByHash", reflect.TypeOf((*MockQuerier)(nil).GetPacketByHash), ctx, packetHash)
}

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

// GetPacketObservationCount indicates an expected call of GetPacketObservationCount.
func (mr *MockQuerierMockRecorder) GetPacketObservationCount(ctx, packetHash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPacketObservationCount", reflect.TypeOf((*MockQuerier)(nil).GetPacketObservationCount), ctx, packetHash)
}

// GetPacketsByTraceTag mocks base method.
func (m *MockQuerier) GetPacketsByTraceTag(ctx context.Context, decode string) ([]db.GetPacketsByTraceTagRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPacketsByTraceTag", ctx, decode)
	ret0, _ := ret[0].([]db.GetPacketsByTraceTagRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPacketsByTraceTag indicates an expected call of GetPacketsByTraceTag.
func (mr *MockQuerierMockRecorder) GetPacketsByTraceTag(ctx, decode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPacketsByTraceTag", reflect.TypeOf((*MockQuerier)(nil).GetPacketsByTraceTag), ctx, decode)
}

// GetPathStats mocks base method.
func (m *MockQuerier) GetPathStats(ctx context.Context, arg db.GetPathStatsParams) ([]db.GetPathStatsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPathStats", ctx, arg)
	ret0, _ := ret[0].([]db.GetPathStatsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPathStats indicates an expected call of GetPathStats.
func (mr *MockQuerierMockRecorder) GetPathStats(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPathStats", reflect.TypeOf((*MockQuerier)(nil).GetPathStats), ctx, arg)
}

// GetRadioPresets mocks base method.
func (m *MockQuerier) GetRadioPresets(ctx context.Context, arg db.GetRadioPresetsParams) ([]db.MvRadioPreset, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRadioPresets", ctx, arg)
	ret0, _ := ret[0].([]db.MvRadioPreset)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRadioPresets indicates an expected call of GetRadioPresets.
func (mr *MockQuerierMockRecorder) GetRadioPresets(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRadioPresets", reflect.TypeOf((*MockQuerier)(nil).GetRadioPresets), ctx, arg)
}

// GetRegion mocks base method.
func (m *MockQuerier) GetRegion(ctx context.Context, id int32) (db.GetRegionRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRegion", ctx, id)
	ret0, _ := ret[0].(db.GetRegionRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetRegionBySlug mocks base method.
func (m *MockQuerier) GetRegionBySlug(ctx context.Context, slug string) (db.GetRegionBySlugRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRegionBySlug", ctx, slug)
	ret0, _ := ret[0].(db.GetRegionBySlugRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRegionBySlug indicates an expected call of GetRegionBySlug.
func (mr *MockQuerierMockRecorder) GetRegionBySlug(ctx, slug any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRegionBySlug", reflect.TypeOf((*MockQuerier)(nil).GetRegionBySlug), ctx, slug)
}

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

// GetRegionIATAs indicates an expected call of GetRegionIATAs.
func (mr *MockQuerierMockRecorder) GetRegionIATAs(ctx, regionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRegionIATAs", reflect.TypeOf((*MockQuerier)(nil).GetRegionIATAs), ctx, regionID)
}

// GetRouteEvidenceRoute mocks base method.
func (m *MockQuerier) GetRouteEvidenceRoute(ctx context.Context, arg db.GetRouteEvidenceRouteParams) (db.KnownRoute, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRouteEvidenceRoute", ctx, arg)
	ret0, _ := ret[0].(db.KnownRoute)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRouteEvidenceRoute indicates an expected call of GetRouteEvidenceRoute.
func (mr *MockQuerierMockRecorder) GetRouteEvidenceRoute(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRouteEvidenceRoute", reflect.TypeOf((*MockQuerier)(nil).GetRouteEvidenceRoute), ctx, arg)
}

// GetScopeByName mocks base method.
func (m *MockQuerier) GetScopeByName(ctx context.Context, name string) (db.GetScopeByNameRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetScopeByName", ctx, name)
	ret0, _ := ret[0].(db.GetScopeByNameRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetScopeCatalogue mocks base method.
func (m *MockQuerier) GetScopeCatalogue(ctx context.Context, arg db.GetScopeCatalogueParams) (db.MeshmapperScopeCatalogue, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetScopeCatalogue", ctx, arg)
	ret0, _ := ret[0].(db.MeshmapperScopeCatalogue)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetScopeCatalogue indicates an expected call of GetScopeCatalogue.
func (mr *MockQuerierMockRecorder) GetScopeCatalogue(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetScopeCatalogue", reflect.TypeOf((*MockQuerier)(nil).GetScopeCatalogue), ctx, arg)
}

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

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

// GetScopeStats mocks base method.
func (m *MockQuerier) GetScopeStats(ctx context.Context, iatas []string) ([]db.GetScopeStatsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetScopeStats", ctx, iatas)
	ret0, _ := ret[0].([]db.GetScopeStatsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetScopeStats indicates an expected call of GetScopeStats.
func (mr *MockQuerierMockRecorder) GetScopeStats(ctx, iatas any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetScopeStats", reflect.TypeOf((*MockQuerier)(nil).GetScopeStats), ctx, iatas)
}

// GetScopesByIATAs mocks base method.
func (m *MockQuerier) GetScopesByIATAs(ctx context.Context, dollar_1 []string) ([]db.GetScopesByIATAsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetScopesByIATAs", ctx, dollar_1)
	ret0, _ := ret[0].([]db.GetScopesByIATAsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetScopesByIATAs indicates an expected call of GetScopesByIATAs.
func (mr *MockQuerierMockRecorder) GetScopesByIATAs(ctx, dollar_1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetScopesByIATAs", reflect.TypeOf((*MockQuerier)(nil).GetScopesByIATAs), ctx, dollar_1)
}

// GetSignalStats mocks base method.
func (m *MockQuerier) GetSignalStats(ctx context.Context, arg db.GetSignalStatsParams) ([]db.GetSignalStatsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSignalStats", ctx, arg)
	ret0, _ := ret[0].([]db.GetSignalStatsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSignalStats indicates an expected call of GetSignalStats.
func (mr *MockQuerierMockRecorder) GetSignalStats(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSignalStats", reflect.TypeOf((*MockQuerier)(nil).GetSignalStats), ctx, arg)
}

// GetStatsClockDrift mocks base method.
func (m *MockQuerier) GetStatsClockDrift(ctx context.Context, arg db.GetStatsClockDriftParams) ([]db.GetStatsClockDriftRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStatsClockDrift", ctx, arg)
	ret0, _ := ret[0].([]db.GetStatsClockDriftRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStatsClockDrift indicates an expected call of GetStatsClockDrift.
func (mr *MockQuerierMockRecorder) GetStatsClockDrift(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatsClockDrift", reflect.TypeOf((*MockQuerier)(nil).GetStatsClockDrift), ctx, arg)
}

// GetStatsNodeTypes mocks base method.
func (m *MockQuerier) GetStatsNodeTypes(ctx context.Context, dollar_1 []string) ([]db.GetStatsNodeTypesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStatsNodeTypes", ctx, dollar_1)
	ret0, _ := ret[0].([]db.GetStatsNodeTypesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStatsNodeTypes indicates an expected call of GetStatsNodeTypes.
func (mr *MockQuerierMockRecorder) GetStatsNodeTypes(ctx, dollar_1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatsNodeTypes", reflect.TypeOf((*MockQuerier)(nil).GetStatsNodeTypes), ctx, dollar_1)
}

// GetStatsOverview mocks base method.
func (m *MockQuerier) GetStatsOverview(ctx context.Context, dollar_1 []string) (db.GetStatsOverviewRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStatsOverview", ctx, dollar_1)
	ret0, _ := ret[0].(db.GetStatsOverviewRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStatsOverview indicates an expected call of GetStatsOverview.
func (mr *MockQuerierMockRecorder) GetStatsOverview(ctx, dollar_1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatsOverview", reflect.TypeOf((*MockQuerier)(nil).GetStatsOverview), ctx, dollar_1)
}

// GetStatsPayloadBreakdown mocks base method.
func (m *MockQuerier) GetStatsPayloadBreakdown(ctx context.Context, arg db.GetStatsPayloadBreakdownParams) ([]db.GetStatsPayloadBreakdownRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStatsPayloadBreakdown", ctx, arg)
	ret0, _ := ret[0].([]db.GetStatsPayloadBreakdownRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStatsPayloadBreakdown indicates an expected call of GetStatsPayloadBreakdown.
func (mr *MockQuerierMockRecorder) GetStatsPayloadBreakdown(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatsPayloadBreakdown", reflect.TypeOf((*MockQuerier)(nil).GetStatsPayloadBreakdown), ctx, arg)
}

// GetStatsTopAdvertisers mocks base method.
func (m *MockQuerier) GetStatsTopAdvertisers(ctx context.Context, arg db.GetStatsTopAdvertisersParams) ([]db.GetStatsTopAdvertisersRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStatsTopAdvertisers", ctx, arg)
	ret0, _ := ret[0].([]db.GetStatsTopAdvertisersRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStatsTopAdvertisers indicates an expected call of GetStatsTopAdvertisers.
func (mr *MockQuerierMockRecorder) GetStatsTopAdvertisers(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatsTopAdvertisers", reflect.TypeOf((*MockQuerier)(nil).GetStatsTopAdvertisers), ctx, arg)
}

// GetStatsTopObservers mocks base method.
func (m *MockQuerier) GetStatsTopObservers(ctx context.Context, arg db.GetStatsTopObserversParams) ([]db.GetStatsTopObserversRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStatsTopObservers", ctx, arg)
	ret0, _ := ret[0].([]db.GetStatsTopObserversRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStatsTopObservers indicates an expected call of GetStatsTopObservers.
func (mr *MockQuerierMockRecorder) GetStatsTopObservers(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatsTopObservers", reflect.TypeOf((*MockQuerier)(nil).GetStatsTopObservers), ctx, arg)
}

// GetStatsTopTalkers mocks base method.
func (m *MockQuerier) GetStatsTopTalkers(ctx context.Context, arg db.GetStatsTopTalkersParams) ([]db.GetStatsTopTalkersRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStatsTopTalkers", ctx, arg)
	ret0, _ := ret[0].([]db.GetStatsTopTalkersRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStatsTopTalkers indicates an expected call of GetStatsTopTalkers.
func (mr *MockQuerierMockRecorder) GetStatsTopTalkers(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatsTopTalkers", reflect.TypeOf((*MockQuerier)(nil).GetStatsTopTalkers), ctx, arg)
}

// GetTopNodes mocks base method.
func (m *MockQuerier) GetTopNodes(ctx context.Context, arg db.GetTopNodesParams) ([]db.MvTopNodesByIatum, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTopNodes", ctx, arg)
	ret0, _ := ret[0].([]db.MvTopNodesByIatum)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTopNodes indicates an expected call of GetTopNodes.
func (mr *MockQuerierMockRecorder) GetTopNodes(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTopNodes", reflect.TypeOf((*MockQuerier)(nil).GetTopNodes), ctx, arg)
}

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

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

// GetTransportScopes mocks base method.
func (m *MockQuerier) GetTransportScopes(ctx context.Context) ([]db.GetTransportScopesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransportScopes", ctx)
	ret0, _ := ret[0].([]db.GetTransportScopesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InsertChannelMessage mocks base method.
func (m *MockQuerier) InsertChannelMessage(ctx context.Context, arg db.InsertChannelMessageParams) (db.InsertChannelMessageRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertChannelMessage", ctx, arg)
	ret0, _ := ret[0].(db.InsertChannelMessageRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertChannelMessage indicates an expected call of InsertChannelMessage.
func (mr *MockQuerierMockRecorder) InsertChannelMessage(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertChannelMessage", reflect.TypeOf((*MockQuerier)(nil).InsertChannelMessage), ctx, arg)
}

// InsertObservation mocks base method.
func (m *MockQuerier) InsertObservation(ctx context.Context, arg db.InsertObservationParams) (db.PacketObservation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertObservation", ctx, arg)
	ret0, _ := ret[0].(db.PacketObservation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertObservation indicates an expected call of InsertObservation.
func (mr *MockQuerierMockRecorder) InsertObservation(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertObservation", reflect.TypeOf((*MockQuerier)(nil).InsertObservation), ctx, arg)
}

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

// InsertObserverTelemetry indicates an expected call of InsertObserverTelemetry.
func (mr *MockQuerierMockRecorder) InsertObserverTelemetry(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertObserverTelemetry", reflect.TypeOf((*MockQuerier)(nil).InsertObserverTelemetry), ctx, arg)
}

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

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

// ListAllChannelMessages mocks base method.
func (m *MockQuerier) ListAllChannelMessages(ctx context.Context, arg db.ListAllChannelMessagesParams) ([]db.ListAllChannelMessagesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAllChannelMessages", ctx, arg)
	ret0, _ := ret[0].([]db.ListAllChannelMessagesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAllChannelMessages indicates an expected call of ListAllChannelMessages.
func (mr *MockQuerierMockRecorder) ListAllChannelMessages(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllChannelMessages", reflect.TypeOf((*MockQuerier)(nil).ListAllChannelMessages), ctx, arg)
}

// ListChannelMessages mocks base method.
func (m *MockQuerier) ListChannelMessages(ctx context.Context, arg db.ListChannelMessagesParams) ([]db.ListChannelMessagesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListChannelMessages", ctx, arg)
	ret0, _ := ret[0].([]db.ListChannelMessagesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListChannelMessages indicates an expected call of ListChannelMessages.
func (mr *MockQuerierMockRecorder) ListChannelMessages(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChannelMessages", reflect.TypeOf((*MockQuerier)(nil).ListChannelMessages), ctx, arg)
}

// ListChannelMessagesByHash mocks base method.
func (m *MockQuerier) ListChannelMessagesByHash(ctx context.Context, arg db.ListChannelMessagesByHashParams) ([]db.ListChannelMessagesByHashRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListChannelMessagesByHash", ctx, arg)
	ret0, _ := ret[0].([]db.ListChannelMessagesByHashRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListChannelMessagesByHash indicates an expected call of ListChannelMessagesByHash.
func (mr *MockQuerierMockRecorder) ListChannelMessagesByHash(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChannelMessagesByHash", reflect.TypeOf((*MockQuerier)(nil).ListChannelMessagesByHash), ctx, arg)
}

// ListChannels mocks base method.
func (m *MockQuerier) ListChannels(ctx context.Context, arg db.ListChannelsParams) ([]db.Channel, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListChannels", ctx, arg)
	ret0, _ := ret[0].([]db.Channel)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListChannels indicates an expected call of ListChannels.
func (mr *MockQuerierMockRecorder) ListChannels(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChannels", reflect.TypeOf((*MockQuerier)(nil).ListChannels), ctx, arg)
}

// ListChannelsAfter mocks base method.
func (m *MockQuerier) ListChannelsAfter(ctx context.Context, arg db.ListChannelsAfterParams) ([]db.Channel, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListChannelsAfter", ctx, arg)
	ret0, _ := ret[0].([]db.Channel)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListChannelsAfter indicates an expected call of ListChannelsAfter.
func (mr *MockQuerierMockRecorder) ListChannelsAfter(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChannelsAfter", reflect.TypeOf((*MockQuerier)(nil).ListChannelsAfter), ctx, arg)
}

// ListIATAs mocks base method.
func (m *MockQuerier) ListIATAs(ctx context.Context) ([]db.IataCode, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIATAs", ctx)
	ret0, _ := ret[0].([]db.IataCode)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListKnownRoutes mocks base method.
func (m *MockQuerier) ListKnownRoutes(ctx context.Context, arg db.ListKnownRoutesParams) ([]db.ListKnownRoutesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListKnownRoutes", ctx, arg)
	ret0, _ := ret[0].([]db.ListKnownRoutesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListKnownRoutes indicates an expected call of ListKnownRoutes.
func (mr *MockQuerierMockRecorder) ListKnownRoutes(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKnownRoutes", reflect.TypeOf((*MockQuerier)(nil).ListKnownRoutes), ctx, arg)
}

// ListMessagesAfterID mocks base method.
func (m *MockQuerier) ListMessagesAfterID(ctx context.Context, arg db.ListMessagesAfterIDParams) ([]db.ListMessagesAfterIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMessagesAfterID", ctx, arg)
	ret0, _ := ret[0].([]db.ListMessagesAfterIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMessagesAfterID indicates an expected call of ListMessagesAfterID.
func (mr *MockQuerierMockRecorder) ListMessagesAfterID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMessagesAfterID", reflect.TypeOf((*MockQuerier)(nil).ListMessagesAfterID), ctx, arg)
}

// ListNodeObservations mocks base method.
func (m *MockQuerier) ListNodeObservations(ctx context.Context, arg db.ListNodeObservationsParams) ([]db.ListNodeObservationsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNodeObservations", ctx, arg)
	ret0, _ := ret[0].([]db.ListNodeObservationsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNodeObservations indicates an expected call of ListNodeObservations.
func (mr *MockQuerierMockRecorder) ListNodeObservations(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNodeObservations", reflect.TypeOf((*MockQuerier)(nil).ListNodeObservations), ctx, arg)
}

// ListNodes mocks base method.
func (m *MockQuerier) ListNodes(ctx context.Context, arg db.ListNodesParams) ([]db.ListNodesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNodes", ctx, arg)
	ret0, _ := ret[0].([]db.ListNodesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNodes indicates an expected call of ListNodes.
func (mr *MockQuerierMockRecorder) ListNodes(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNodes", reflect.TypeOf((*MockQuerier)(nil).ListNodes), ctx, arg)
}

// ListObservationsForPacket mocks base method.
func (m *MockQuerier) ListObservationsForPacket(ctx context.Context, packetHash []byte) ([]db.ListObservationsForPacketRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListObservationsForPacket", ctx, packetHash)
	ret0, _ := ret[0].([]db.ListObservationsForPacketRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObservationsForPacket indicates an expected call of ListObservationsForPacket.
func (mr *MockQuerierMockRecorder) ListObservationsForPacket(ctx, packetHash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObservationsForPacket", reflect.TypeOf((*MockQuerier)(nil).ListObservationsForPacket), ctx, packetHash)
}

// ListObserverAdverts mocks base method.
func (m *MockQuerier) ListObserverAdverts(ctx context.Context, arg db.ListObserverAdvertsParams) ([]db.ListObserverAdvertsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListObserverAdverts", ctx, arg)
	ret0, _ := ret[0].([]db.ListObserverAdvertsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObserverAdverts indicates an expected call of ListObserverAdverts.
func (mr *MockQuerierMockRecorder) ListObserverAdverts(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObserverAdverts", reflect.TypeOf((*MockQuerier)(nil).ListObserverAdverts), ctx, arg)
}

// ListObservers mocks base method.
func (m *MockQuerier) ListObservers(ctx context.Context, arg db.ListObserversParams) ([]db.ListObserversRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListObservers", ctx, arg)
	ret0, _ := ret[0].([]db.ListObserversRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObservers indicates an expected call of ListObservers.
func (mr *MockQuerierMockRecorder) ListObservers(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObservers", reflect.TypeOf((*MockQuerier)(nil).ListObservers), ctx, arg)
}

// ListPackets mocks base method.
func (m *MockQuerier) ListPackets(ctx context.Context, arg db.ListPacketsParams) ([]db.ListPacketsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPackets", ctx, arg)
	ret0, _ := ret[0].([]db.ListPacketsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPackets indicates an expected call of ListPackets.
func (mr *MockQuerierMockRecorder) ListPackets(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPackets", reflect.TypeOf((*MockQuerier)(nil).ListPackets), ctx, arg)
}

// ListPacketsAfterID mocks base method.
func (m *MockQuerier) ListPacketsAfterID(ctx context.Context, arg db.ListPacketsAfterIDParams) ([]db.ListPacketsAfterIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPacketsAfterID", ctx, arg)
	ret0, _ := ret[0].([]db.ListPacketsAfterIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPacketsAfterID indicates an expected call of ListPacketsAfterID.
func (mr *MockQuerierMockRecorder) ListPacketsAfterID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPacketsAfterID", reflect.TypeOf((*MockQuerier)(nil).ListPacketsAfterID), ctx, arg)
}

// ListPacketsByIATAs mocks base method.
func (m *MockQuerier) ListPacketsByIATAs(ctx context.Context, arg db.ListPacketsByIATAsParams) ([]db.ListPacketsByIATAsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPacketsByIATAs", ctx, arg)
	ret0, _ := ret[0].([]db.ListPacketsByIATAsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPacketsByIATAs indicates an expected call of ListPacketsByIATAs.
func (mr *MockQuerierMockRecorder) ListPacketsByIATAs(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPacketsByIATAs", reflect.TypeOf((*MockQuerier)(nil).ListPacketsByIATAs), ctx, arg)
}

// ListRegions mocks base method.
func (m *MockQuerier) ListRegions(ctx context.Context) ([]db.ListRegionsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRegions", ctx)
	ret0, _ := ret[0].([]db.ListRegionsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListRouteEvidence mocks base method.
func (m *MockQuerier) ListRouteEvidence(ctx context.Context, arg db.ListRouteEvidenceParams) ([]db.ListRouteEvidenceRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRouteEvidence", ctx, arg)
	ret0, _ := ret[0].([]db.ListRouteEvidenceRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRouteEvidence indicates an expected call of ListRouteEvidence.
func (mr *MockQuerierMockRecorder) ListRouteEvidence(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRouteEvidence", reflect.TypeOf((*MockQuerier)(nil).ListRouteEvidence), ctx, arg)
}

// ListTraceTags mocks base method.
func (m *MockQuerier) ListTraceTags(ctx context.Context, arg db.ListTraceTagsParams) ([]db.ListTraceTagsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTraceTags", ctx, arg)
	ret0, _ := ret[0].([]db.ListTraceTagsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTraceTags indicates an expected call of ListTraceTags.
func (mr *MockQuerierMockRecorder) ListTraceTags(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTraceTags", reflect.TypeOf((*MockQuerier)(nil).ListTraceTags), ctx, arg)
}

// ListUndecryptedGroupTextPackets mocks base method.
func (m *MockQuerier) ListUndecryptedGroupTextPackets(ctx context.Context) ([]db.ListUndecryptedGroupTextPacketsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUndecryptedGroupTextPackets", ctx)
	ret0, _ := ret[0].([]db.ListUndecryptedGroupTextPacketsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// ReconfirmRoutes mocks base method.
func (m *MockQuerier) ReconfirmRoutes(ctx context.Context, arg db.ReconfirmRoutesParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconfirmRoutes", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReconfirmRoutes indicates an expected call of ReconfirmRoutes.
func (mr *MockQuerierMockRecorder) ReconfirmRoutes(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconfirmRoutes", reflect.TypeOf((*MockQuerier)(nil).ReconfirmRoutes), ctx, arg)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ResolveEndpointHashPairs mocks base method.
func (m *MockQuerier) ResolveEndpointHashPairs(ctx context.Context, arg db.ResolveEndpointHashPairsParams) ([]db.ResolveEndpointHashPairsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResolveEndpointHashPairs", ctx, arg)
	ret0, _ := ret[0].([]db.ResolveEndpointHashPairsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResolveEndpointHashPairs indicates an expected call of ResolveEndpointHashPairs.
func (mr *MockQuerierMockRecorder) ResolveEndpointHashPairs(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveEndpointHashPairs", reflect.TypeOf((*MockQuerier)(nil).ResolveEndpointHashPairs), ctx, arg)
}

// ResolveEndpointHashes mocks base method.
func (m *MockQuerier) ResolveEndpointHashes(ctx context.Context, arg db.ResolveEndpointHashesParams) ([]db.ResolveEndpointHashesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResolveEndpointHashes", ctx, arg)
	ret0, _ := ret[0].([]db.ResolveEndpointHashesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResolveEndpointHashes indicates an expected call of ResolveEndpointHashes.
func (mr *MockQuerierMockRecorder) ResolveEndpointHashes(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveEndpointHashes", reflect.TypeOf((*MockQuerier)(nil).ResolveEndpointHashes), ctx, arg)
}

// ResolvePathHashesP1 mocks base method.
func (m *MockQuerier) ResolvePathHashesP1(ctx context.Context, arg db.ResolvePathHashesP1Params) ([]db.ResolvePathHashesP1Row, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResolvePathHashesP1", ctx, arg)
	ret0, _ := ret[0].([]db.ResolvePathHashesP1Row)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResolvePathHashesP1 indicates an expected call of ResolvePathHashesP1.
func (mr *MockQuerierMockRecorder) ResolvePathHashesP1(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolvePathHashesP1", reflect.TypeOf((*MockQuerier)(nil).ResolvePathHashesP1), ctx, arg)
}

// ResolvePathHashesP2 mocks base method.
func (m *MockQuerier) ResolvePathHashesP2(ctx context.Context, arg db.ResolvePathHashesP2Params) ([]db.ResolvePathHashesP2Row, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResolvePathHashesP2", ctx, arg)
	ret0, _ := ret[0].([]db.ResolvePathHashesP2Row)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResolvePathHashesP2 indicates an expected call of ResolvePathHashesP2.
func (mr *MockQuerierMockRecorder) ResolvePathHashesP2(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolvePathHashesP2", reflect.TypeOf((*MockQuerier)(nil).ResolvePathHashesP2), ctx, arg)
}

// ResolvePathHashesP3 mocks base method.
func (m *MockQuerier) ResolvePathHashesP3(ctx context.Context, arg db.ResolvePathHashesP3Params) ([]db.ResolvePathHashesP3Row, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResolvePathHashesP3", ctx, arg)
	ret0, _ := ret[0].([]db.ResolvePathHashesP3Row)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResolvePathHashesP3 indicates an expected call of ResolvePathHashesP3.
func (mr *MockQuerierMockRecorder) ResolvePathHashesP3(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolvePathHashesP3", reflect.TypeOf((*MockQuerier)(nil).ResolvePathHashesP3), ctx, arg)
}

// ResolvePathHashesP4 mocks base method.
func (m *MockQuerier) ResolvePathHashesP4(ctx context.Context, arg db.ResolvePathHashesP4Params) ([]db.ResolvePathHashesP4Row, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResolvePathHashesP4", ctx, arg)
	ret0, _ := ret[0].([]db.ResolvePathHashesP4Row)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResolvePathHashesP4 indicates an expected call of ResolvePathHashesP4.
func (mr *MockQuerierMockRecorder) ResolvePathHashesP4(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolvePathHashesP4", reflect.TypeOf((*MockQuerier)(nil).ResolvePathHashesP4), ctx, arg)
}

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

// SaveScopeCatalogue indicates an expected call of SaveScopeCatalogue.
func (mr *MockQuerierMockRecorder) SaveScopeCatalogue(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveScopeCatalogue", reflect.TypeOf((*MockQuerier)(nil).SaveScopeCatalogue), ctx, arg)
}

// SearchKnownRoutes mocks base method.
func (m *MockQuerier) SearchKnownRoutes(ctx context.Context, arg db.SearchKnownRoutesParams) ([]db.SearchKnownRoutesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchKnownRoutes", ctx, arg)
	ret0, _ := ret[0].([]db.SearchKnownRoutesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchKnownRoutes indicates an expected call of SearchKnownRoutes.
func (mr *MockQuerierMockRecorder) SearchKnownRoutes(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchKnownRoutes", reflect.TypeOf((*MockQuerier)(nil).SearchKnownRoutes), ctx, arg)
}

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

// SetNodeDefaultScope indicates an expected call of SetNodeDefaultScope.
func (mr *MockQuerierMockRecorder) SetNodeDefaultScope(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNodeDefaultScope", reflect.TypeOf((*MockQuerier)(nil).SetNodeDefaultScope), ctx, arg)
}

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

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

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

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

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

// SetPacketDecrypted indicates an expected call of SetPacketDecrypted.
func (mr *MockQuerierMockRecorder) SetPacketDecrypted(ctx, packetHash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPacketDecrypted", reflect.TypeOf((*MockQuerier)(nil).SetPacketDecrypted), ctx, packetHash)
}

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

// TouchObserverBrokers indicates an expected call of TouchObserverBrokers.
func (mr *MockQuerierMockRecorder) TouchObserverBrokers(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TouchObserverBrokers", reflect.TypeOf((*MockQuerier)(nil).TouchObserverBrokers), ctx, arg)
}

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

// TouchObservers indicates an expected call of TouchObservers.
func (mr *MockQuerierMockRecorder) TouchObservers(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TouchObservers", reflect.TypeOf((*MockQuerier)(nil).TouchObservers), ctx, arg)
}

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

// TouchPackets indicates an expected call of TouchPackets.
func (mr *MockQuerierMockRecorder) TouchPackets(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TouchPackets", reflect.TypeOf((*MockQuerier)(nil).TouchPackets), ctx, arg)
}

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

// UpdateObserverRegionScope indicates an expected call of UpdateObserverRegionScope.
func (mr *MockQuerierMockRecorder) UpdateObserverRegionScope(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateObserverRegionScope", reflect.TypeOf((*MockQuerier)(nil).UpdateObserverRegionScope), ctx, arg)
}

// UpdateObserverStatus mocks base method.
func (m *MockQuerier) UpdateObserverStatus(ctx context.Context, arg db.UpdateObserverStatusParams) (uuid.UUID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateObserverStatus", ctx, arg)
	ret0, _ := ret[0].(uuid.UUID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateObserverStatus indicates an expected call of UpdateObserverStatus.
func (mr *MockQuerierMockRecorder) UpdateObserverStatus(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateObserverStatus", reflect.TypeOf((*MockQuerier)(nil).UpdateObserverStatus), ctx, arg)
}

// UpsertChannel mocks base method.
func (m *MockQuerier) UpsertChannel(ctx context.Context, arg db.UpsertChannelParams) (db.Channel, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChannel", ctx, arg)
	ret0, _ := ret[0].(db.Channel)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertChannel indicates an expected call of UpsertChannel.
func (mr *MockQuerierMockRecorder) UpsertChannel(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChannel", reflect.TypeOf((*MockQuerier)(nil).UpsertChannel), ctx, arg)
}

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

// UpsertChannelHashOnly indicates an expected call of UpsertChannelHashOnly.
func (mr *MockQuerierMockRecorder) UpsertChannelHashOnly(ctx, channelHash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChannelHashOnly", reflect.TypeOf((*MockQuerier)(nil).UpsertChannelHashOnly), ctx, channelHash)
}

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

// UpsertChannelIATA indicates an expected call of UpsertChannelIATA.
func (mr *MockQuerierMockRecorder) UpsertChannelIATA(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChannelIATA", reflect.TypeOf((*MockQuerier)(nil).UpsertChannelIATA), ctx, arg)
}

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

// UpsertIATA indicates an expected call of UpsertIATA.
func (mr *MockQuerierMockRecorder) UpsertIATA(ctx, iata any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertIATA", reflect.TypeOf((*MockQuerier)(nil).UpsertIATA), ctx, iata)
}

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

// UpsertIATABorder indicates an expected call of UpsertIATABorder.
func (mr *MockQuerierMockRecorder) UpsertIATABorder(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertIATABorder", reflect.TypeOf((*MockQuerier)(nil).UpsertIATABorder), ctx, arg)
}

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

// UpsertIATADetails indicates an expected call of UpsertIATADetails.
func (mr *MockQuerierMockRecorder) UpsertIATADetails(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertIATADetails", reflect.TypeOf((*MockQuerier)(nil).UpsertIATADetails), ctx, arg)
}

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

// UpsertKnownRoute indicates an expected call of UpsertKnownRoute.
func (mr *MockQuerierMockRecorder) UpsertKnownRoute(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertKnownRoute", reflect.TypeOf((*MockQuerier)(nil).UpsertKnownRoute), ctx, arg)
}

// UpsertNode mocks base method.
func (m *MockQuerier) UpsertNode(ctx context.Context, arg db.UpsertNodeParams) (db.Node, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertNode", ctx, arg)
	ret0, _ := ret[0].(db.Node)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertNode indicates an expected call of UpsertNode.
func (mr *MockQuerierMockRecorder) UpsertNode(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertNode", reflect.TypeOf((*MockQuerier)(nil).UpsertNode), ctx, arg)
}

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

// UpsertNodeIATA indicates an expected call of UpsertNodeIATA.
func (mr *MockQuerierMockRecorder) UpsertNodeIATA(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertNodeIATA", reflect.TypeOf((*MockQuerier)(nil).UpsertNodeIATA), ctx, arg)
}

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

// UpsertNodeNeighbor indicates an expected call of UpsertNodeNeighbor.
func (mr *MockQuerierMockRecorder) UpsertNodeNeighbor(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertNodeNeighbor", reflect.TypeOf((*MockQuerier)(nil).UpsertNodeNeighbor), ctx, arg)
}

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

// UpsertNodeShortID indicates an expected call of UpsertNodeShortID.
func (mr *MockQuerierMockRecorder) UpsertNodeShortID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertNodeShortID", reflect.TypeOf((*MockQuerier)(nil).UpsertNodeShortID), ctx, arg)
}

// UpsertObserver mocks base method.
func (m *MockQuerier) UpsertObserver(ctx context.Context, publicKey []byte) (db.Observer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertObserver", ctx, publicKey)
	ret0, _ := ret[0].(db.Observer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertObserver indicates an expected call of UpsertObserver.
func (mr *MockQuerierMockRecorder) UpsertObserver(ctx, publicKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertObserver", reflect.TypeOf((*MockQuerier)(nil).UpsertObserver), ctx, publicKey)
}

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

// UpsertObserverBroker indicates an expected call of UpsertObserverBroker.
func (mr *MockQuerierMockRecorder) UpsertObserverBroker(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertObserverBroker", reflect.TypeOf((*MockQuerier)(nil).UpsertObserverBroker), ctx, arg)
}

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

// UpsertObserverScope indicates an expected call of UpsertObserverScope.
func (mr *MockQuerierMockRecorder) UpsertObserverScope(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertObserverScope", reflect.TypeOf((*MockQuerier)(nil).UpsertObserverScope), ctx, arg)
}

// UpsertPacket mocks base method.
func (m *MockQuerier) UpsertPacket(ctx context.Context, arg db.UpsertPacketParams) (db.UpsertPacketRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertPacket", ctx, arg)
	ret0, _ := ret[0].(db.UpsertPacketRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertPacket indicates an expected call of UpsertPacket.
func (mr *MockQuerierMockRecorder) UpsertPacket(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertPacket", reflect.TypeOf((*MockQuerier)(nil).UpsertPacket), ctx, arg)
}

// UpsertRegion mocks base method.
func (m *MockQuerier) UpsertRegion(ctx context.Context, arg db.UpsertRegionParams) (int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertRegion", ctx, arg)
	ret0, _ := ret[0].(int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertRegion indicates an expected call of UpsertRegion.
func (mr *MockQuerierMockRecorder) UpsertRegion(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertRegion", reflect.TypeOf((*MockQuerier)(nil).UpsertRegion), ctx, arg)
}

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

// UpsertRegionIATA indicates an expected call of UpsertRegionIATA.
func (mr *MockQuerierMockRecorder) UpsertRegionIATA(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertRegionIATA", reflect.TypeOf((*MockQuerier)(nil).UpsertRegionIATA), ctx, arg)
}

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

// UpsertTraceIATA indicates an expected call of UpsertTraceIATA.
func (mr *MockQuerierMockRecorder) UpsertTraceIATA(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertTraceIATA", reflect.TypeOf((*MockQuerier)(nil).UpsertTraceIATA), ctx, arg)
}

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

// UpsertTransportScope indicates an expected call of UpsertTransportScope.
func (mr *MockQuerierMockRecorder) UpsertTransportScope(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertTransportScope", reflect.TypeOf((*MockQuerier)(nil).UpsertTransportScope), ctx, arg)
}