aperturedb

type BaseDB struct {
	*sql.DB

	*sqlc.Queries
}

type BatchedL402TransactionsDB interface {
	L402TransactionsDB

	BatchedTx[L402TransactionsDB]
}

type BatchedLNCSessionsDB interface {
	LNCSessionsDB

	BatchedTx[LNCSessionsDB]
}

type BatchedMPPSessionsDB interface {
	MPPSessionsDB

	BatchedTx[MPPSessionsDB]
}

type BatchedOnionDB interface {
	OnionDB

	BatchedTx[OnionDB]
}

type BatchedQuerier interface {
	// Querier is the underlying query source, this is in place so we can
	// pass a BatchedQuerier implementation directly into objects that
	// create a batched version of the normal methods they need.
	sqlc.Querier

	// BeginTx creates a new database transaction given the set of
	// transaction options.
	BeginTx(ctx context.Context, options TxOptions) (*sql.Tx, error)
}

type BatchedSecretsDB interface {
	SecretsDB

	BatchedTx[SecretsDB]
}

type BatchedServicesDB interface {
	ServicesDB

	BatchedTx[ServicesDB]
}

type BatchedTx[Q any] interface {
	// ExecTx will execute the passed txBody, operating upon generic
	// parameter Q (usually a storage interface) in a single transaction.
	// The set of TxOptions are passed in in order to allow the caller to
	// specify if a transaction should be read-only and optionally what
	// type of concurrency control should be used.
	ExecTx(ctx context.Context, txOptions TxOptions,
		txBody func(Q) error) error
}

type CountByDateRangeParams = sqlc.CountL402TransactionsByDateRangeParams

type CountL402TxFilteredParams = sqlc.CountL402TransactionsFilteredParams

type ErrSQLUniqueConstraintViolation struct {
	DBError error
}

type ErrSerializationError struct {
	DBError error
}

type L402Transaction = sqlc.L402Transaction

type L402TransactionsDB interface {
	// InsertL402Transaction inserts a new L402 transaction into the
	// database.
	InsertL402Transaction(ctx context.Context,
		arg NewL402Transaction) (int32, error)

	// UpdateL402TransactionState updates the state and settled_at
	// timestamp of a transaction identified by its payment hash.
	// Returns the number of rows affected.
	UpdateL402TransactionState(ctx context.Context,
		arg UpdateL402TxState) (int64, error)

	// GetL402TransactionsByPaymentHash returns transactions matching the
	// given payment hash.
	GetL402TransactionsByPaymentHash(ctx context.Context,
		paymentHash []byte) ([]L402Transaction, error)

	// GetL402TransactionByIdentifierHash returns the transaction matching
	// the given identifier hash.
	GetL402TransactionByIdentifierHash(ctx context.Context,
		identifierHash []byte) (L402Transaction, error)

	// GetL402SettledTransactionByTokenID returns the settled transaction
	// matching the given token ID.
	GetL402SettledTransactionByTokenID(ctx context.Context,
		tokenID []byte) (L402Transaction, error)

	// ListL402Transactions returns a paginated list of all transactions,
	// ordered by created_at DESC.
	ListL402Transactions(ctx context.Context,
		arg ListL402TxParams) ([]L402Transaction, error)

	// ListL402TransactionsByService returns a paginated list of
	// transactions filtered by service name.
	ListL402TransactionsByService(ctx context.Context,
		arg ListL402TxByServiceParams) ([]L402Transaction, error)

	// ListL402TransactionsByState returns a paginated list of
	// transactions filtered by state.
	ListL402TransactionsByState(ctx context.Context,
		arg ListL402TxByStateParams) ([]L402Transaction, error)

	// ListL402TransactionsByDateRange returns a paginated list of
	// transactions within a date range.
	ListL402TransactionsByDateRange(ctx context.Context,
		arg ListL402TxByDateRangeParams) ([]L402Transaction, error)

	// CountL402Transactions returns the total number of settled
	// transactions.
	CountL402Transactions(ctx context.Context) (int64, error)

	// CountL402TransactionsByService returns the number of transactions
	// for a given service.
	CountL402TransactionsByService(ctx context.Context,
		serviceName string) (int64, error)

	// CountL402TransactionsByDateRange returns the total number of
	// settled transactions within a settlement-time date range.
	CountL402TransactionsByDateRange(ctx context.Context,
		arg CountByDateRangeParams) (int64, error)

	// GetL402RevenueByService returns the total settled revenue grouped
	// by service name.
	GetL402RevenueByService(ctx context.Context) (
		[]RevenueByServiceRow, error)

	// GetL402RevenueByServiceAndDateRange returns the total settled
	// revenue grouped by service name within a date range.
	GetL402RevenueByServiceAndDateRange(ctx context.Context,
		arg RevenueByServiceAndDateRangeParams) (
		[]RevenueByServiceAndDateRangeRow, error)

	// GetL402TotalRevenue returns the total settled revenue across all
	// services.
	GetL402TotalRevenue(ctx context.Context) (int64, error)

	// GetL402TotalRevenueByDateRange returns the total settled revenue
	// across all services within a date range.
	GetL402TotalRevenueByDateRange(ctx context.Context,
		arg TotalRevenueByDateRangeParams) (int64, error)

	// DeleteL402TransactionByTokenID deletes a transaction by its
	// token ID.
	DeleteL402TransactionByTokenID(ctx context.Context,
		tokenID []byte) (int64, error)

	// ListL402TransactionsFiltered returns a paginated list of
	// transactions with optional combined filters.
	ListL402TransactionsFiltered(ctx context.Context,
		arg ListL402TxFilteredParams) ([]L402Transaction, error)

	// CountL402TransactionsFiltered returns the count of transactions
	// matching the combined filters.
	CountL402TransactionsFiltered(ctx context.Context,
		arg CountL402TxFilteredParams) (int64, error)
}

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

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

type LNCSessionsDB interface {
	// InsertLNCSession inserts a new session into the database.
	InsertSession(ctx context.Context, arg NewLNCSession) error

	// GetLNCSession returns the session tagged with the given passphrase
	// entropy.
	GetSession(ctx context.Context,
		passphraseEntropy []byte) (sqlc.LncSession, error)

	// SetRemotePubKey sets the remote public key for the session.
	SetRemotePubKey(ctx context.Context,
		arg SetRemoteParams) error

	// SetExpiry sets the expiry for the session.
	SetExpiry(ctx context.Context, arg SetExpiryParams) error
}

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

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

type ListL402TxByDateRangeParams = sqlc.ListL402TransactionsByDateRangeParams

type ListL402TxByServiceParams = sqlc.ListL402TransactionsByServiceParams

type ListL402TxByStateParams = sqlc.ListL402TransactionsByStateParams

type ListL402TxFilteredParams = sqlc.ListL402TransactionsFilteredParams

type ListL402TxParams = sqlc.ListL402TransactionsParams

type MPPSessionsDB interface {
	// InsertMPPSession inserts a new MPP session into the database.
	InsertMPPSession(ctx context.Context,
		arg NewMPPSession) (int32, error)

	// GetMPPSessionByID returns the MPP session with the given session ID.
	GetMPPSessionByID(ctx context.Context,
		sessionID string) (sqlc.MppSession, error)

	// UpdateMPPSessionDeposit atomically adds to the deposit balance.
	UpdateMPPSessionDeposit(ctx context.Context,
		arg sqlc.UpdateMPPSessionDepositParams) (sql.Result, error)

	// UpdateMPPSessionSpent atomically adds to the spent counter.
	// The query includes a balance check: deposit_sats - spent_sats >= amount.
	UpdateMPPSessionSpent(ctx context.Context,
		arg sqlc.UpdateMPPSessionSpentParams) (sql.Result, error)

	// CloseMPPSession marks the session as closed.
	CloseMPPSession(ctx context.Context,
		arg sqlc.CloseMPPSessionParams) (sql.Result, error)

	// CloseMPPSessionReturningBalance atomically closes the session and
	// returns the remaining balance (deposit_sats - spent_sats).
	CloseMPPSessionReturningBalance(ctx context.Context,
		arg sqlc.CloseMPPSessionReturningBalanceParams) (int64, error)
}

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

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

type NewL402Transaction = sqlc.InsertL402TransactionParams

type NewLNCSession = sqlc.InsertSessionParams

type NewMPPSession = sqlc.InsertMPPSessionParams

type NewOnionPrivateKey = sqlc.UpsertOnionParams

type NewSecret = sqlc.InsertSecretParams

type OnionDB interface {
	// UpsertOnion inserts a new onion private key into the database. If
	// the onion private key already exists in the db this is a NOOP
	// operation.
	UpsertOnion(ctx context.Context, arg NewOnionPrivateKey) error

	// SelectOnionPrivateKey selects the onion private key from the
	// database.
	SelectOnionPrivateKey(ctx context.Context) ([]byte, error)

	// DeleteOnionPrivateKey deletes the onion private key from the
	// database.
	DeleteOnionPrivateKey(ctx context.Context) error
}

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

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

type PostgresConfig struct {
	SkipMigrations     bool   `long:"skipmigrations" description:"Skip applying migrations on startup."`
	Host               string `long:"host" description:"Database server hostname."`
	Port               int    `long:"port" description:"Database server port."`
	User               string `long:"user" description:"Database user."`
	Password           string `long:"password" description:"Database user's password."`
	DBName             string `long:"dbname" description:"Database name to use."`
	MaxOpenConnections int32  `long:"maxconnections" description:"Max open connections to keep alive to the database server."`
	RequireSSL         bool   `long:"requiressl" description:"Whether to require using SSL (mode: require) when connecting to the server."`
}

type PostgresStore struct {
	*BaseDB
	// contains filtered or unexported fields
}

type QueryCreator[Q any] func(*sql.Tx) Q

type RevenueByServiceAndDateRangeParams = sqlc.GetL402RevenueByServiceAndDateRangeParams

type RevenueByServiceAndDateRangeRow = sqlc.GetL402RevenueByServiceAndDateRangeRow

type RevenueByServiceRow = sqlc.GetL402RevenueByServiceRow

type SecretsDB interface {
	// InsertSecret inserts a new secret into the database.
	InsertSecret(ctx context.Context, arg NewSecret) (int32, error)

	// GetSecretByHash returns the secret that corresponds to the given
	// hash.
	GetSecretByHash(ctx context.Context, hash []byte) ([]byte, error)

	// DeleteSecretByHash removes the secret that corresponds to the given
	// hash.
	DeleteSecretByHash(ctx context.Context, hash []byte) (int64, error)
}

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

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

type ServiceParams struct {
	Name       string
	Address    string
	Protocol   string
	HostRegexp string
	PathRegexp string
	Auth       string
	AuthScheme string
	Price      int64
}

type ServiceRow = sqlc.Service

type ServicesDB interface {
	// UpsertService inserts or updates a service by name.
	UpsertService(ctx context.Context, arg UpsertServiceParams) error

	// DeleteService deletes a service by name.
	DeleteService(ctx context.Context, name string) (int64, error)

	// ListServices returns all services ordered by name.
	ListServices(ctx context.Context) ([]ServiceRow, error)
}

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

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

type SetExpiryParams = sqlc.SetExpiryParams

type SetRemoteParams = sqlc.SetRemotePubKeyParams

type SqliteConfig struct {
	// SkipMigrations if true, then all the tables will be created on start
	// up if they don't already exist.
	SkipMigrations bool `long:"skipmigrations" description:"Skip applying migrations on startup."`

	// DatabaseFileName is the full file path where the database file can be
	// found.
	DatabaseFileName string `long:"dbfile" description:"The full path to the database."`
}

type SqliteStore struct {
	*BaseDB
	// contains filtered or unexported fields
}

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

type TotalRevenueByDateRangeParams = sqlc.GetL402TotalRevenueByDateRangeParams

type TransactionExecutor[Query any] struct {
	BatchedQuerier
	// contains filtered or unexported fields
}

type TransactionFilter struct {
	Service      string
	State        string
	AuthType     string
	HasDateRange bool
	From         time.Time
	To           time.Time
	Limit        int32
	Offset       int32
}

type Tx interface {
	// Commit commits the database transaction, an error should be returned
	// if the commit isn't possible.
	Commit() error

	// Rollback rolls back an incomplete database transaction.
	// Transactions that were able to be committed can still call this as a
	// noop.
	Rollback() error
}

type TxExecutorOption func(*txExecutorOptions)

type TxOptions interface {
	// ReadOnly returns true if the transaction should be read only.
	ReadOnly() bool
}

type UpdateL402TxState = sqlc.UpdateL402TransactionStateParams

type UpsertServiceParams = sqlc.UpsertServiceParams