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

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

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

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

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

// GetChannelByID mocks base method.
func (m *MockQuerier) GetChannelByID(ctx context.Context, id int32) (sqlc.Channel, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChannelByID", ctx, id)
	ret0, _ := ret[0].(sqlc.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 sqlc.GetCrossIATANeighborsParams) ([]sqlc.GetCrossIATANeighborsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCrossIATANeighbors", ctx, arg)
	ret0, _ := ret[0].([]sqlc.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 sqlc.GetHourlyStatsParams) ([]sqlc.MvHourlyIataStat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHourlyStats", ctx, arg)
	ret0, _ := ret[0].([]sqlc.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) (sqlc.IataCode, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIATA", ctx, iata)
	ret0, _ := ret[0].(sqlc.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)
}

// GetKnownRoutesByNode mocks base method.
func (m *MockQuerier) GetKnownRoutesByNode(ctx context.Context, arg sqlc.GetKnownRoutesByNodeParams) ([]sqlc.KnownRoute, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetKnownRoutesByNode", ctx, arg)
	ret0, _ := ret[0].([]sqlc.KnownRoute)
	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) (sqlc.GetNodeByIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNodeByID", ctx, id)
	ret0, _ := ret[0].(sqlc.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)
}

// GetNodeNeighbors mocks base method.
func (m *MockQuerier) GetNodeNeighbors(ctx context.Context, nodeID uuid.UUID) ([]sqlc.GetNodeNeighborsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNodeNeighbors", ctx, nodeID)
	ret0, _ := ret[0].([]sqlc.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) ([]sqlc.GetNodesByIDsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNodesByIDs", ctx, dollar_1)
	ret0, _ := ret[0].([]sqlc.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)
}

// GetObserverBrokers mocks base method.
func (m *MockQuerier) GetObserverBrokers(ctx context.Context, observerID uuid.UUID) ([]sqlc.GetObserverBrokersRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObserverBrokers", ctx, observerID)
	ret0, _ := ret[0].([]sqlc.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) (sqlc.Observer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObserverByID", ctx, id)
	ret0, _ := ret[0].(sqlc.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) (sqlc.Observer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObserverByPubkey", ctx, publicKey)
	ret0, _ := ret[0].(sqlc.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)
}

// 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) (sqlc.GetObserverRadioRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObserverRadio", ctx, id)
	ret0, _ := ret[0].(sqlc.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 sqlc.GetObserverTelemetryParams) ([]sqlc.GetObserverTelemetryRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObserverTelemetry", ctx, arg)
	ret0, _ := ret[0].([]sqlc.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 sqlc.GetObserverTelemetryBucketedParams) ([]sqlc.GetObserverTelemetryBucketedRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObserverTelemetryBucketed", ctx, arg)
	ret0, _ := ret[0].([]sqlc.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) (sqlc.GetPacketByHashRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPacketByHash", ctx, packetHash)
	ret0, _ := ret[0].(sqlc.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) ([]sqlc.GetPacketsByTraceTagRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPacketsByTraceTag", ctx, decode)
	ret0, _ := ret[0].([]sqlc.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)
}

// GetRadioPresets mocks base method.
func (m *MockQuerier) GetRadioPresets(ctx context.Context, arg sqlc.GetRadioPresetsParams) ([]sqlc.MvRadioPreset, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRadioPresets", ctx, arg)
	ret0, _ := ret[0].([]sqlc.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) (sqlc.GetRegionRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRegion", ctx, id)
	ret0, _ := ret[0].(sqlc.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) (sqlc.GetRegionBySlugRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRegionBySlug", ctx, slug)
	ret0, _ := ret[0].(sqlc.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)
}

// GetScopeByName mocks base method.
func (m *MockQuerier) GetScopeByName(ctx context.Context, name string) (sqlc.GetScopeByNameRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetScopeByName", ctx, name)
	ret0, _ := ret[0].(sqlc.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)
}

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

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

// GetScopesByIATAs mocks base method.
func (m *MockQuerier) GetScopesByIATAs(ctx context.Context, dollar_1 string) ([]sqlc.GetScopesByIATAsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetScopesByIATAs", ctx, dollar_1)
	ret0, _ := ret[0].([]sqlc.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)
}

// GetStatsNodeTypes mocks base method.
func (m *MockQuerier) GetStatsNodeTypes(ctx context.Context, dollar_1 string) ([]sqlc.GetStatsNodeTypesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStatsNodeTypes", ctx, dollar_1)
	ret0, _ := ret[0].([]sqlc.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) (sqlc.GetStatsOverviewRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStatsOverview", ctx, dollar_1)
	ret0, _ := ret[0].(sqlc.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 sqlc.GetStatsPayloadBreakdownParams) ([]sqlc.GetStatsPayloadBreakdownRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStatsPayloadBreakdown", ctx, arg)
	ret0, _ := ret[0].([]sqlc.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)
}

// GetStatsTopObservers mocks base method.
func (m *MockQuerier) GetStatsTopObservers(ctx context.Context, arg sqlc.GetStatsTopObserversParams) ([]sqlc.GetStatsTopObserversRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStatsTopObservers", ctx, arg)
	ret0, _ := ret[0].([]sqlc.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)
}

// GetTopNodes mocks base method.
func (m *MockQuerier) GetTopNodes(ctx context.Context, arg sqlc.GetTopNodesParams) ([]sqlc.MvTopNodesByIatum, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTopNodes", ctx, arg)
	ret0, _ := ret[0].([]sqlc.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) ([]sqlc.GetTransportScopesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransportScopes", ctx)
	ret0, _ := ret[0].([]sqlc.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 sqlc.InsertChannelMessageParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertChannelMessage", ctx, arg)
	ret0, _ := ret[0].(int64)
	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 sqlc.InsertObservationParams) (sqlc.PacketObservation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertObservation", ctx, arg)
	ret0, _ := ret[0].(sqlc.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 sqlc.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)
}

// ListAllChannelMessages mocks base method.
func (m *MockQuerier) ListAllChannelMessages(ctx context.Context, arg sqlc.ListAllChannelMessagesParams) ([]sqlc.ListAllChannelMessagesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAllChannelMessages", ctx, arg)
	ret0, _ := ret[0].([]sqlc.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 sqlc.ListChannelMessagesParams) ([]sqlc.ListChannelMessagesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListChannelMessages", ctx, arg)
	ret0, _ := ret[0].([]sqlc.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 sqlc.ListChannelMessagesByHashParams) ([]sqlc.ListChannelMessagesByHashRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListChannelMessagesByHash", ctx, arg)
	ret0, _ := ret[0].([]sqlc.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 sqlc.ListChannelsParams) ([]sqlc.Channel, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListChannels", ctx, arg)
	ret0, _ := ret[0].([]sqlc.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)
}

// ListIATAs mocks base method.
func (m *MockQuerier) ListIATAs(ctx context.Context) ([]sqlc.IataCode, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIATAs", ctx)
	ret0, _ := ret[0].([]sqlc.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 sqlc.ListKnownRoutesParams) ([]sqlc.KnownRoute, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListKnownRoutes", ctx, arg)
	ret0, _ := ret[0].([]sqlc.KnownRoute)
	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 sqlc.ListMessagesAfterIDParams) ([]sqlc.ListMessagesAfterIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMessagesAfterID", ctx, arg)
	ret0, _ := ret[0].([]sqlc.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 sqlc.ListNodeObservationsParams) ([]sqlc.ListNodeObservationsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNodeObservations", ctx, arg)
	ret0, _ := ret[0].([]sqlc.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 sqlc.ListNodesParams) ([]sqlc.ListNodesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNodes", ctx, arg)
	ret0, _ := ret[0].([]sqlc.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) ([]sqlc.ListObservationsForPacketRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListObservationsForPacket", ctx, packetHash)
	ret0, _ := ret[0].([]sqlc.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 sqlc.ListObserverAdvertsParams) ([]sqlc.ListObserverAdvertsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListObserverAdverts", ctx, arg)
	ret0, _ := ret[0].([]sqlc.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 sqlc.ListObserversParams) ([]sqlc.ListObserversRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListObservers", ctx, arg)
	ret0, _ := ret[0].([]sqlc.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 sqlc.ListPacketsParams) ([]sqlc.ListPacketsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPackets", ctx, arg)
	ret0, _ := ret[0].([]sqlc.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 sqlc.ListPacketsAfterIDParams) ([]sqlc.ListPacketsAfterIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPacketsAfterID", ctx, arg)
	ret0, _ := ret[0].([]sqlc.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)
}

// ListRegions mocks base method.
func (m *MockQuerier) ListRegions(ctx context.Context) ([]sqlc.ListRegionsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRegions", ctx)
	ret0, _ := ret[0].([]sqlc.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)
}

// ListTraceTags mocks base method.
func (m *MockQuerier) ListTraceTags(ctx context.Context, arg sqlc.ListTraceTagsParams) ([]sqlc.ListTraceTagsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTraceTags", ctx, arg)
	ret0, _ := ret[0].([]sqlc.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)
}

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

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

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

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

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

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

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

// SearchKnownRoutes mocks base method.
func (m *MockQuerier) SearchKnownRoutes(ctx context.Context, arg sqlc.SearchKnownRoutesParams) ([]sqlc.KnownRoute, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchKnownRoutes", ctx, arg)
	ret0, _ := ret[0].([]sqlc.KnownRoute)
	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 sqlc.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)
}

// UpdateObserverStatus mocks base method.
func (m *MockQuerier) UpdateObserverStatus(ctx context.Context, arg sqlc.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 sqlc.UpsertChannelParams) (sqlc.Channel, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChannel", ctx, arg)
	ret0, _ := ret[0].(sqlc.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)
}

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

// UpsertIATADetails mocks base method.
func (m *MockQuerier) UpsertIATADetails(ctx context.Context, arg sqlc.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 sqlc.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 sqlc.UpsertNodeParams) (sqlc.Node, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertNode", ctx, arg)
	ret0, _ := ret[0].(sqlc.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 sqlc.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 sqlc.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 sqlc.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) (sqlc.Observer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertObserver", ctx, publicKey)
	ret0, _ := ret[0].(sqlc.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 sqlc.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 sqlc.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 sqlc.UpsertPacketParams) (sqlc.UpsertPacketRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertPacket", ctx, arg)
	ret0, _ := ret[0].(sqlc.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 sqlc.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 sqlc.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)
}

// UpsertTransportScope mocks base method.
func (m *MockQuerier) UpsertTransportScope(ctx context.Context, arg sqlc.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)
}