sqlsubscribers

type Account struct {
	// contains filtered or unexported fields
}

type AccountEvent interface {
	events.Event
	Account() vega.Account
}

type AccountService interface {
	Obtain(ctx context.Context, a *entities.Account) error
	AddAccountBalance(b entities.AccountBalance) error
	Flush(ctx context.Context) error
}

type AccountSource interface {
	Obtain(ctx context.Context, a *entities.Account) error
	GetByID(ctx context.Context, id entities.AccountID) (entities.Account, error)
}

type Asset struct {
	// contains filtered or unexported fields
}

type AssetEvent interface {
	events.Event
	Asset() vega.Asset
}

type AssetStore interface {
	Add(context.Context, entities.Asset) error
}

type Checkpoint struct {
	// contains filtered or unexported fields
}

type CheckpointEvent interface {
	events.Event
	Proto() eventspb.CheckpointEvent
}

type CheckpointStore interface {
	Add(context.Context, entities.Checkpoint) error
}

type CoreSnapshotEvent interface {
	events.Event
	SnapshotTakenEvent() eventspb.CoreSnapshotData
}

type Delegation struct {
	// contains filtered or unexported fields
}

type DelegationBalanceEvent interface {
	events.Event
	Proto() eventspb.DelegationBalanceEvent
}

type DelegationStore interface {
	Add(context.Context, entities.Delegation) error
}

type Deposit struct {
	// contains filtered or unexported fields
}

type DepositEvent interface {
	events.Event
	Deposit() vega.Deposit
}

type DepositStore interface {
	Upsert(context.Context, *entities.Deposit) error
}

type ERC20MultiSigSignerAddedEvent interface {
	events.Event
	Proto() eventspb.ERC20MultiSigSignerAdded
}

type ERC20MultiSigSignerEvent struct {
	// contains filtered or unexported fields
}

type ERC20MultiSigSignerEventStore interface {
	Add(ctx context.Context, e *entities.ERC20MultiSigSignerEvent) error
}

type ERC20MultiSigSignerRemovedEvent interface {
	events.Event
	Proto() eventspb.ERC20MultiSigSignerRemoved
}

type Epoch struct {
	// contains filtered or unexported fields
}

type EpochStore interface {
	Add(context.Context, entities.Epoch) error
}

type EpochUpdateEvent interface {
	events.Event
	Proto() eventspb.EpochEvent
}

type EthereumKeyRotation struct {
	// contains filtered or unexported fields
}

type EthereumKeyRotationEvent interface {
	events.Event
	EthereumKeyRotation() eventspb.EthereumKeyRotation
}

type EthereumKeyRotationService interface {
	Add(context.Context, entities.EthereumKeyRotation) error
}

type ExpiredOrdersEvent interface {
	events.Event
	MarketID() string
	OrderIDs() []string
}

type FeesStats struct {
	// contains filtered or unexported fields
}

type FeesStatsEvent interface {
	events.Event
	FeesStats() *eventspb.FeesStats
}

type FeesStatsStore interface {
	AddFeesStats(ctx context.Context, FeesStats *entities.FeesStats) error
}

type FundingPaymentSubscriber struct {
	// contains filtered or unexported fields
}

type FundingPaymentsEvent interface {
	events.Event
	FundingPayments() *eventspb.FundingPayments
}

type FundingPaymentsStore interface {
	Add(context.Context, []*entities.FundingPayment) error
}

type FundingPeriod struct {
	// contains filtered or unexported fields
}

type FundingPeriodDataPointEvent interface {
	events.Event
	FundingPeriodDataPoint() *eventspb.FundingPeriodDataPoint
}

type FundingPeriodEvent interface {
	events.Event
	FundingPeriod() *eventspb.FundingPeriod
}

type FundingPeriodStore interface {
	AddFundingPeriod(ctx context.Context, period *entities.FundingPeriod) error
	AddDataPoint(ctx context.Context, dataPoint *entities.FundingPeriodDataPoint) error
}

type GovernanceService interface {
	AddVote(context.Context, entities.Vote) error
}

type KeyRotation struct {
	// contains filtered or unexported fields
}

type KeyRotationEvent interface {
	events.Event
	KeyRotation() eventspb.KeyRotation
}

type KeyRotationStore interface {
	Upsert(context.Context, *entities.KeyRotation) error
}

type Ledger interface {
	AddLedgerEntry(entities.LedgerEntry) error
	AddTransferResponse(*vega.LedgerMovement)
	Flush(ctx context.Context) error
}

type LedgerMovementEvents interface {
	events.Event
	LedgerMovements() []*vega.LedgerMovement
}

type LiquidityProvision struct {
	// contains filtered or unexported fields
}

type LiquidityProvisionEvent interface {
	events.Event
	LiquidityProvision() *vega.LiquidityProvision
}

type LiquidityProvisionStore interface {
	Upsert(context.Context, entities.LiquidityProvision) error
	Flush(ctx context.Context) error
}

type LockedBalancesStore interface {
	Add(ctx context.Context, balance entities.PartyLockedBalance) error
	Prune(ctx context.Context, currentEpoch uint64) error
}

type MarginLevels struct {
	// contains filtered or unexported fields
}

type MarginLevelsEvent interface {
	events.Event
	MarginLevels() vega.MarginLevels
}

type MarginLevelsStore interface {
	Add(entities.MarginLevels) error
	Flush(context.Context) error
}

type MarginModeStore interface {
	UpdatePartyMarginMode(ctx context.Context, update entities.PartyMarginMode) error
}

type MarginModes struct {
	// contains filtered or unexported fields
}

type MarketCreated struct {
	// contains filtered or unexported fields
}

type MarketCreatedEvent interface {
	events.Event
	Market() vega.Market
}

type MarketData struct {
	// contains filtered or unexported fields
}

type MarketDataEvent interface {
	events.Event
	MarketData() types.MarketData
}

type MarketDataStore interface {
	Add(*entities.MarketData) error
	Flush(context.Context) error
}

type MarketDepthService interface {
	AddOrder(order *types.Order, vegaTime time.Time, sequenceNumber uint64)
	PublishAtEndOfBlock()
}

type MarketSvc interface {
	GetMarketScalingFactor(ctx context.Context, marketID string) (num.Decimal, bool)
}

type MarketUpdated struct {
	// contains filtered or unexported fields
}

type MarketUpdatedEvent interface {
	events.Event
	Market() vega.Market
}

type MarketsStore interface {
	Upsert(context.Context, *entities.Market) error
}

type NetworkLimitStore interface {
	Add(context.Context, entities.NetworkLimits) error
}

type NetworkLimits struct {
	// contains filtered or unexported fields
}

type NetworkLimitsEvent interface {
	events.Event
	NetworkLimits() *vega.NetworkLimits
}

type NetworkParameter struct {
	// contains filtered or unexported fields
}

type NetworkParameterEvent interface {
	events.Event
	NetworkParameter() vega.NetworkParameter
}

type NetworkParameterStore interface {
	Add(context.Context, entities.NetworkParameter) error
}

type Node struct {
	// contains filtered or unexported fields
}

type NodeSignatureEvent interface {
	events.Event
	NodeSignature() commandspb.NodeSignature
}

type NodeStore interface {
	UpsertNode(context.Context, *entities.Node) error
	UpsertRanking(context.Context, *entities.RankingScore, *entities.RankingScoreAux) error
	UpsertScore(context.Context, *entities.RewardScore, *entities.RewardScoreAux) error
	UpdatePublicKey(context.Context, *entities.KeyRotation) error
	AddNodeAnnouncedEvent(context.Context, string, time.Time, *entities.ValidatorUpdateAux) error
	UpdateEthereumAddress(ctx context.Context, kr entities.EthereumKeyRotation) error
}

type Notary struct {
	// contains filtered or unexported fields
}

type NotaryStore interface {
	Add(context.Context, *entities.NodeSignature) error
}

type OracleData struct {
	// contains filtered or unexported fields
}

type OracleDataEvent interface {
	events.Event
	OracleData() vegapb.OracleData
}

type OracleDataStore interface {
	Add(context.Context, *entities.OracleData) error
}

type OracleSpec struct {
	// contains filtered or unexported fields
}

type OracleSpecEvent interface {
	events.Event
	OracleSpec() *vegapb.OracleSpec
}

type OracleSpecStore interface {
	Upsert(context.Context, *entities.OracleSpec) error
}

type Order struct {
	// contains filtered or unexported fields
}

type OrderEvent interface {
	events.Event
	Order() *vega.Order
}

type OrderStore interface {
	Add(entities.Order) error
	Flush(ctx context.Context) error
	GetByMarketAndID(ctx context.Context, marketIDstr string, orderIDs []string) ([]entities.Order, error)
}

type PaidLiquidityFeesStats struct {
	// contains filtered or unexported fields
}

type PaidLiquidityFeesStatsEvent interface {
	events.Event
	PaidLiquidityFeesStats() *eventspb.PaidLiquidityFeesStats
}

type PaidLiquidityFeesStatsStore interface {
	Add(ctx context.Context, stats *entities.PaidLiquidityFeesStats) error
}

type Party struct {
	// contains filtered or unexported fields
}

type PartyActivityStreak struct {
	// contains filtered or unexported fields
}

type PartyActivityStreakEvent interface {
	events.Event
	PartyActivityStreak() *eventspb.PartyActivityStreak
}

type PartyActivityStreakStore interface {
	Add(context.Context, *entities.PartyActivityStreak) error
}

type PartyEvent interface {
	events.Event
	Party() types.Party
}

type PartyMarginModeUpdatedEvent interface {
	events.Event
	PartyMarginModeUpdated() *eventspb.PartyMarginModeUpdated
}

type PartyProfileUpdatedEvent interface {
	events.Event
	PartyProfileUpdated() *eventspb.PartyProfileUpdated
}

type PartyStore interface {
	Add(context.Context, entities.Party) error
	UpdateProfile(ctx context.Context, updated *entities.PartyProfile) error
}

type Position struct {
	// contains filtered or unexported fields
}

type PositionStore interface {
	Add(context.Context, entities.Position) error
	GetByMarket(ctx context.Context, marketID string) ([]entities.Position, error)
	GetByMarketAndParty(ctx context.Context, marketID string, partyID string) (entities.Position, error)
	GetByMarketAndParties(ctx context.Context, marketID string, parties []string) ([]entities.Position, error)
	Flush(ctx context.Context) error
}

type Proposal struct {
	// contains filtered or unexported fields
}

type ProposalEvent interface {
	events.Event
	ProposalID() string
	PartyID() string
	Proposal() vega.Proposal
}

type ProtocolUpgrade struct {
	// contains filtered or unexported fields
}

type ProtocolUpgradeProposalEvent interface {
	events.Event
	ProtocolUpgradeProposalEvent() eventspb.ProtocolUpgradeEvent
}

type RefereeJoinedReferralSetEvent interface {
	events.Event
	GetProtoEvent() *eventspb.RefereeJoinedReferralSet
}

type RefereeJoinedTeam interface {
	events.Event
	RefereeJoinedTeam() *eventspb.RefereeJoinedTeam
}

type RefereeSwitchedTeam interface {
	events.Event
	RefereeSwitchedTeam() *eventspb.RefereeSwitchedTeam
}

type ReferralProgram struct {
	// contains filtered or unexported fields
}

type ReferralProgramEndedEvent interface {
	events.Event
	GetReferralProgramEnded() *eventspb.ReferralProgramEnded
}

type ReferralProgramStartedEvent interface {
	events.Event
	GetReferralProgramStarted() *eventspb.ReferralProgramStarted
}

type ReferralProgramUpdatedEvent interface {
	events.Event
	GetReferralProgramUpdated() *eventspb.ReferralProgramUpdated
}

type ReferralSetCreatedEvent interface {
	events.Event
	GetProtoEvent() *eventspb.ReferralSetCreated
}

type ReferralSetStatsUpdatedEvent interface {
	events.Event
	GetProtoEvent() *eventspb.ReferralSetStatsUpdated
}

type ReferralSets struct {
	// contains filtered or unexported fields
}

type ReferralSetsStore interface {
	AddReferralSet(ctx context.Context, referralSet *entities.ReferralSet) error
	RefereeJoinedReferralSet(ctx context.Context, referee *entities.ReferralSetReferee) error
	AddReferralSetStats(ctx context.Context, stats *entities.ReferralSetStats) error
}

type ReferralStore interface {
	AddReferralProgram(ctx context.Context, referral *entities.ReferralProgram) error
	UpdateReferralProgram(ctx context.Context, referral *entities.ReferralProgram) error
	EndReferralProgram(ctx context.Context, version uint64, endedAt time.Time, vegaTime time.Time, seqNum uint64) error
}

type Reward struct {
	// contains filtered or unexported fields
}

type RewardPayoutEvent interface {
	events.Event
	RewardPayoutEvent() eventspb.RewardPayoutEvent
}

type RewardStore interface {
	Add(context.Context, entities.Reward) error
}

type RiskFactor struct {
	// contains filtered or unexported fields
}

type RiskFactorEvent interface {
	events.Event
	RiskFactor() vega.RiskFactor
}

type RiskFactorStore interface {
	Upsert(context.Context, *entities.RiskFactor) error
}

type SnapshotData struct {
	// contains filtered or unexported fields
}

type StakeLinking struct {
	// contains filtered or unexported fields
}

type StakeLinkingEvent interface {
	events.Event
	StakeLinking() eventspb.StakeLinking
}

type StakeLinkingStore interface {
	Upsert(ctx context.Context, linking *entities.StakeLinking) error
}

type StopOrder struct {
	// contains filtered or unexported fields
}

type StopOrderEvent interface {
	events.Event
	StopOrder() *pbevents.StopOrderEvent
}

type StopOrderStore interface {
	Add(entities.StopOrder) error
	Flush(ctx context.Context) error
}

type TeamCreatedEvent interface {
	events.Event
	TeamCreated() *eventspb.TeamCreated
}

type TeamStore interface {
	AddTeam(ctx context.Context, team *entities.Team) error
	UpdateTeam(ctx context.Context, team *entities.TeamUpdated) error
	RefereeJoinedTeam(ctx context.Context, referee *entities.TeamMember) error
	RefereeSwitchedTeam(ctx context.Context, referee *entities.RefereeTeamSwitch) error
	TeamsStatsUpdated(ctx context.Context, stats *eventspb.TeamsStatsUpdated) error
}

type TeamUpdateEvent interface {
	events.Event
	TeamUpdated() *eventspb.TeamUpdated
}

type Teams struct {
	// contains filtered or unexported fields
}

type TeamsStatsUpdated interface {
	events.Event
	TeamsStatsUpdated() *eventspb.TeamsStatsUpdated
}

type TimeWeightedNotionalPosition struct {
	// contains filtered or unexported fields
}

type TimeWeightedNotionalPositionStore interface {
	Upsert(ctx context.Context, twNotionalPos entities.TimeWeightedNotionalPosition) error
}

type TimeWeightedNotionalPositionUpdatedEvent interface {
	events.Event
	TimeWeightedNotionalPositionUpdated() *eventspb.TimeWeightedNotionalPositionUpdated
}

type TradeEvent interface {
	events.Event
	Trade() types.Trade
}

type TradeSubscriber struct {
	// contains filtered or unexported fields
}

type TradesStore interface {
	Add(*entities.Trade) error
	Flush(ctx context.Context) error
}

type TransactionResultEvent interface {
	events.Event
	TransactionResult() events.TransactionResult
}

type TransactionResults struct {
	// contains filtered or unexported fields
}

type Transfer struct {
	// contains filtered or unexported fields
}

type TransferEvent interface {
	events.Event
	TransferFunds() eventspb.Transfer
}

type TransferFeesDiscountUpdateEvent interface {
	events.Event
	TransferFeesDiscount() eventspb.TransferFeesDiscount
}

type TransferFeesEvent interface {
	events.Event
	TransferFees() eventspb.TransferFees
}

type TransferResponse struct {
	// contains filtered or unexported fields
}

type TransferStore interface {
	Upsert(ctx context.Context, transfer *entities.Transfer) error
	UpsertFees(ctx context.Context, tf *entities.TransferFees) error
	UpsertFeesDiscount(ctx context.Context, tfd *entities.TransferFeesDiscount) error
}

type ValidatorRankingScoreEvent interface {
	events.Event
	ValidatorRankingEvent() eventspb.ValidatorRankingEvent
}

type ValidatorRewardScoreEvent interface {
	events.Event
	ValidatorScoreEvent() eventspb.ValidatorScoreEvent
}

type ValidatorUpdateEvent interface {
	events.Event
	ValidatorUpdate() eventspb.ValidatorUpdate
}

type VestingBalancesStore interface {
	Add(ctx context.Context, balance entities.PartyVestingBalance) error
}

type VestingBalancesSummary struct {
	// contains filtered or unexported fields
}

type VestingBalancesSummaryEvent interface {
	events.Event
	VestingBalancesSummary() *eventspb.VestingBalancesSummary
}

type VestingStatsUpdated struct {
	// contains filtered or unexported fields
}

type VestingStatsUpdatedEvent interface {
	events.Event
	VestingStatsUpdated() *eventspb.VestingStatsUpdated
}

type VestingStatsUpdatedStore interface {
	Add(context.Context, *entities.VestingStatsUpdated) error
}

type VolumeDiscountProgram struct {
	// contains filtered or unexported fields
}

type VolumeDiscountProgramEndedEvent interface {
	events.Event
	GetVolumeDiscountProgramEnded() *eventspb.VolumeDiscountProgramEnded
}

type VolumeDiscountProgramStartedEvent interface {
	events.Event
	GetVolumeDiscountProgramStarted() *eventspb.VolumeDiscountProgramStarted
}

type VolumeDiscountProgramUpdatedEvent interface {
	events.Event
	GetVolumeDiscountProgramUpdated() *eventspb.VolumeDiscountProgramUpdated
}

type VolumeDiscountStatsUpdated struct {
	// contains filtered or unexported fields
}

type VolumeDiscountStatsUpdatedEvent interface {
	events.Event
	VolumeDiscountStatsUpdated() *eventspb.VolumeDiscountStatsUpdated
}

type VolumeDiscountStatsUpdatedStore interface {
	Add(context.Context, *entities.VolumeDiscountStats) error
}

type VolumeDiscountStore interface {
	AddVolumeDiscountProgram(ctx context.Context, referral *entities.VolumeDiscountProgram) error
	UpdateVolumeDiscountProgram(ctx context.Context, referral *entities.VolumeDiscountProgram) error
	EndVolumeDiscountProgram(ctx context.Context, version uint64, endedAt time.Time, vegaTime time.Time, seqNum uint64) error
}

type Vote struct {
	// contains filtered or unexported fields
}

type VoteEvent interface {
	events.Event
	ProposalID() string
	PartyID() string
	Vote() vega.Vote
	Value() vega.Vote_Value
}

type Withdrawal struct {
	// contains filtered or unexported fields
}

type WithdrawalEvent interface {
	events.Event
	Withdrawal() vega.Withdrawal
}

type WithdrawalStore interface {
	Upsert(context.Context, *entities.Withdrawal) error
}