rockyardkv

type AssociativeMergeOperator interface {
	// Name returns a unique identifier for this merge operator.
	Name() string

	// Merge merges a new value with an existing value.
	// If existingValue is nil, treat it as the identity element for the operation.
	Merge(key []byte, existingValue, value []byte) ([]byte, bool)
}

type BackgroundErrorInfo struct {
	// Reason is the reason for the error.
	Reason BackgroundErrorReason
	// Status is the error that occurred.
	Status error
}

type BackgroundErrorReason int

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

type BackupInfo struct {
	ID        uint32    `json:"id"`
	Timestamp time.Time `json:"timestamp"`
	Size      int64     `json:"size"`
	NumFiles  int       `json:"num_files"`
}

type BaseCompactionFilter struct{}

type BatchResult struct {
	// Sequence is the sequence number of the first operation in the batch.
	Sequence uint64

	// WriteBatch is the batch of operations.
	WriteBatch *WriteBatch
}

type BlobDBOptions struct {
	// Enable enables storing large values in blob files
	Enable bool

	// MinBlobSize is the minimum value size to store in a blob file (bytes)
	MinBlobSize int

	// BlobFileSize is the target size for blob files (bytes)
	BlobFileSize int64

	// BlobCompressionType is the compression algorithm for blob files
	BlobCompressionType CompressionType

	// EnableBlobGC enables garbage collection of unreferenced blobs
	EnableBlobGC bool

	// BlobGCAgeCutoff is the age fraction of files to consider for GC (0.0 to 1.0)
	BlobGCAgeCutoff float64
}

type BytewiseComparator struct{}

type BytewiseComparatorWithU64Ts struct{}

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

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

type ChecksumType = checksum.Type

type ColumnFamilyHandle interface {
	// ID returns the column family ID.
	ID() uint32

	// Name returns the column family name.
	Name() string

	// IsValid returns true if the handle is still valid (not dropped).
	IsValid() bool
}

type ColumnFamilyOptions struct {
	// Comparator for ordering keys within the column family.
	// If nil, uses the database's default comparator.
	Comparator Comparator

	// WriteBufferSize is the amount of data to build up in memory
	// before converting to a sorted on-disk file.
	WriteBufferSize int
}

type CompactRangeOptions struct {
	// ChangeLevel when true, will move compacted files to the minimum level
	// capable of holding the data.
	ChangeLevel bool
	// TargetLevel specifies the target level for the compacted files.
	TargetLevel int
	// ExclusiveManualCompaction when true, only one manual compaction runs at a time.
	ExclusiveManualCompaction bool
}

type CompactionFilter interface {
	// Name returns the name of the compaction filter.
	// This is used for logging and identification.
	Name() string

	// Filter is called for each key-value pair during compaction.
	// Returns the decision (Keep, Remove, or Change) and optionally a new value.
	//
	// Parameters:
	//   - level: The compaction output level
	//   - key: The user key (not internal key)
	//   - oldValue: The current value
	//
	// Returns:
	//   - decision: Whether to keep, remove, or change the entry
	//   - newValue: If decision is FilterChange, this is the new value
	Filter(level int, key, oldValue []byte) (decision CompactionFilterDecision, newValue []byte)

	// FilterMergeOperand is called for merge operands.
	// This allows filtering of individual merge operands.
	// Default implementation returns FilterKeep.
	FilterMergeOperand(level int, key, operand []byte) CompactionFilterDecision
}

type CompactionFilterContext struct {
	// IsFull is true if this is a full compaction (all levels).
	IsFull bool

	// IsManual is true if this is a manually triggered compaction.
	IsManual bool

	// ColumnFamilyID is the ID of the column family being compacted.
	ColumnFamilyID uint32
}

type CompactionFilterDecision int

type CompactionFilterFactory interface {
	// Name returns the name of the factory.
	Name() string

	// CreateCompactionFilter creates a new compaction filter for a compaction.
	// The context provides information about the current compaction.
	CreateCompactionFilter(context CompactionFilterContext) CompactionFilter
}

type CompactionJobInfo struct {
	// CFName is the column family name.
	CFName string
	// Status is the status of the compaction (nil for success).
	Status error
	// ThreadID is the ID of the thread that performed the compaction.
	ThreadID uint64
	// JobID is the unique identifier for this compaction job.
	JobID int
	// BaseInputLevel is the lowest input level.
	BaseInputLevel int
	// OutputLevel is the output level.
	OutputLevel int
	// InputFiles is the list of input file paths.
	InputFiles []string
	// OutputFiles is the list of output file paths.
	OutputFiles []string
	// NumInputRecords is the number of records in input files.
	NumInputRecords uint64
	// NumOutputRecords is the number of records in output files.
	NumOutputRecords uint64
	// NumCorruptKeys is the number of corrupt keys encountered.
	NumCorruptKeys uint64
	// TotalInputBytes is the total bytes read.
	TotalInputBytes uint64
	// TotalOutputBytes is the total bytes written.
	TotalOutputBytes uint64
	// NumInputFiles is the number of input files.
	NumInputFiles int
	// NumOutputFiles is the number of output files.
	NumOutputFiles int
	// IsManualCompaction indicates if this was a manual compaction.
	IsManualCompaction bool
	// CompactionReason is the reason for the compaction.
	CompactionReason CompactionReason
}

type CompactionOptions struct {
	OutputLevel           int
	TargetLevel           int
	MaxSubcompactions     uint32
	OutputFilePathID      uint32
	CompressionType       CompressionType
	OutputFileSizeLimit   uint64
	MaxCompactionBytes    uint64
	PenultimateOutputPath bool
}

type CompactionReason int

type CompactionStyle int

type Comparator interface {
	// Compare returns a value < 0 if a < b, 0 if a == b, > 0 if a > b.
	Compare(a, b []byte) int

	// Name returns the name of the comparator.
	Name() string

	// FindShortestSeparator finds a key k such that a <= k < b.
	// This is used to shorten keys in index blocks.
	// If no such key exists, a should be returned unchanged.
	FindShortestSeparator(a, b []byte) []byte

	// FindShortSuccessor finds a short key that is >= a.
	// This is used to shorten keys at the end of an index block.
	FindShortSuccessor(a []byte) []byte
}

type CompressionType = compression.Type

type CountingEventListener struct {
	NoOpEventListener
	FlushCount      int
	CompactionCount int
	FileCreateCount int
	FileDeleteCount int
	ErrorCount      int
	StallCount      int
	// contains filtered or unexported fields
}

type DB interface {
	// Put sets the value for the given key in the default column family.
	Put(opts *WriteOptions, key, value []byte) error

	// PutCF sets the value for the given key in the specified column family.
	PutCF(opts *WriteOptions, cf ColumnFamilyHandle, key, value []byte) error

	// Get retrieves the value for the given key from the default column family.
	// Returns ErrNotFound if the key does not exist.
	Get(opts *ReadOptions, key []byte) ([]byte, error)

	// GetCF retrieves the value for the given key from the specified column family.
	GetCF(opts *ReadOptions, cf ColumnFamilyHandle, key []byte) ([]byte, error)

	// MultiGet retrieves multiple values for the given keys.
	// Returns a slice of values in the same order as keys.
	// If a key doesn't exist, the corresponding value is nil and error is ErrNotFound.
	MultiGet(opts *ReadOptions, keys [][]byte) ([][]byte, []error)

	// Delete removes the given key from the default column family.
	Delete(opts *WriteOptions, key []byte) error

	// SingleDelete removes the given key from the default column family.
	// Unlike Delete, SingleDelete is only valid for keys that have been Put exactly once
	// without any Merge operations. If there are multiple Put operations for a key,
	// SingleDelete may not work correctly.
	SingleDelete(opts *WriteOptions, key []byte) error

	// DeleteCF removes the given key from the specified column family.
	DeleteCF(opts *WriteOptions, cf ColumnFamilyHandle, key []byte) error

	// DeleteRange removes all keys in the range [startKey, endKey) from the default column family.
	DeleteRange(opts *WriteOptions, startKey, endKey []byte) error

	// DeleteRangeCF removes all keys in the range [startKey, endKey) from the specified column family.
	DeleteRangeCF(opts *WriteOptions, cf ColumnFamilyHandle, startKey, endKey []byte) error

	// Merge applies a merge operation for the given key in the default column family.
	// The merge operator specified in Options will be used to combine the operand
	// with any existing value during reads and compaction.
	Merge(opts *WriteOptions, key, value []byte) error

	// MergeCF applies a merge operation for the given key in the specified column family.
	MergeCF(opts *WriteOptions, cf ColumnFamilyHandle, key, value []byte) error

	// Write applies a batch of operations atomically.
	Write(opts *WriteOptions, batch *WriteBatch) error

	// NewIterator creates an iterator over the default column family.
	NewIterator(opts *ReadOptions) Iterator

	// NewIteratorCF creates an iterator over the specified column family.
	NewIteratorCF(opts *ReadOptions, cf ColumnFamilyHandle) Iterator

	// GetSnapshot creates a new snapshot of the database.
	GetSnapshot() *Snapshot

	// ReleaseSnapshot releases a previously acquired snapshot.
	ReleaseSnapshot(s *Snapshot)

	// Flush flushes the memtable to disk.
	Flush(opts *FlushOptions) error

	// Close closes the database, releasing all resources.
	Close() error

	// GetProperty returns the value of a database property.
	GetProperty(name string) (string, bool)

	// CreateColumnFamily creates a new column family.
	CreateColumnFamily(opts ColumnFamilyOptions, name string) (ColumnFamilyHandle, error)

	// DropColumnFamily drops the specified column family.
	DropColumnFamily(cf ColumnFamilyHandle) error

	// ListColumnFamilies returns the names of all column families.
	ListColumnFamilies() []string

	// DefaultColumnFamily returns a handle to the default column family.
	DefaultColumnFamily() ColumnFamilyHandle

	// GetColumnFamily returns a handle to the named column family, or nil if not found.
	GetColumnFamily(name string) ColumnFamilyHandle

	// CompactRange manually triggers compaction for the specified key range.
	// If start and end are nil, the entire database is compacted.
	CompactRange(opts *CompactRangeOptions, start, end []byte) error

	// BeginTransaction begins a new optimistic transaction.
	BeginTransaction(opts TransactionOptions, writeOpts *WriteOptions) Transaction

	// IngestExternalFile loads external SST files into the database.
	IngestExternalFile(paths []string, opts IngestExternalFileOptions) error

	// SyncWAL syncs the current WAL to disk, ensuring all data is durable.
	// This is more expensive than FlushWAL(false) but provides stronger durability.
	// Reference: RocksDB v10.7.5 include/rocksdb/db.h lines 1782-1789
	SyncWAL() error

	// FlushWAL flushes the WAL buffer to the file system.
	// If sync is true, it also syncs the WAL to disk (equivalent to SyncWAL).
	// Reference: RocksDB v10.7.5 include/rocksdb/db.h lines 1775-1780
	FlushWAL(sync bool) error

	// GetLatestSequenceNumber returns the sequence number of the most recent transaction.
	// This is useful for tracking database state and replication.
	GetLatestSequenceNumber() uint64

	// GetLiveFiles returns a list of all files in the database except WAL files.
	// The files are relative to the dbname. The manifest file size is returned.
	// If flushMemtable is true, the memtable is flushed before getting files.
	// Reference: RocksDB v10.7.5 include/rocksdb/db.h lines 1929-1947
	GetLiveFiles(flushMemtable bool) (files []string, manifestFileSize uint64, err error)

	// GetLiveFilesMetaData returns metadata about all live SST files in the database.
	// Reference: RocksDB v10.7.5 include/rocksdb/db.h lines 1892-1897
	GetLiveFilesMetaData() []LiveFileMetaData

	// DisableFileDeletions prevents file deletions. Call EnableFileDeletions when done.
	// This is useful for making consistent backups.
	// Reference: RocksDB v10.7.5 include/rocksdb/db.h
	DisableFileDeletions() error

	// EnableFileDeletions re-enables file deletions after DisableFileDeletions.
	// Reference: RocksDB v10.7.5 include/rocksdb/db.h
	EnableFileDeletions() error

	// PauseBackgroundWork pauses all background work (compaction, flush).
	// Reference: RocksDB v10.7.5 include/rocksdb/db.h
	PauseBackgroundWork() error

	// ContinueBackgroundWork resumes background work after PauseBackgroundWork.
	// Reference: RocksDB v10.7.5 include/rocksdb/db.h
	ContinueBackgroundWork() error

	// KeyMayExist checks if a key may exist using bloom filters.
	// Returns true if the key may exist, false if it definitely doesn't exist.
	// If value pointer is not nil, the value may be set if found in cache.
	// Reference: RocksDB v10.7.5 include/rocksdb/db.h lines 1022-1050
	KeyMayExist(opts *ReadOptions, key []byte, value *[]byte) (mayExist bool, valueFound bool)

	// NewIterators creates iterators for multiple column families.
	// Reference: RocksDB v10.7.5 include/rocksdb/db.h lines 1066-1069
	NewIterators(opts *ReadOptions, cfs []ColumnFamilyHandle) ([]Iterator, error)

	// GetApproximateSizes returns the approximate sizes of key ranges.
	// Reference: RocksDB v10.7.5 include/rocksdb/db.h lines 1533-1565
	GetApproximateSizes(ranges []Range, flags SizeApproximationFlags) ([]uint64, error)

	// GetOptions returns a copy of the current database options.
	// Reference: RocksDB v10.7.5 include/rocksdb/db.h lines 1741-1748
	GetOptions() Options

	// GetDBOptions returns a copy of the current database-wide options.
	// Reference: RocksDB v10.7.5 include/rocksdb/db.h line 1750
	GetDBOptions() Options

	// SetOptions dynamically changes database options.
	// Reference: RocksDB v10.7.5 include/rocksdb/db.h lines 1807-1809
	SetOptions(newOptions map[string]string) error

	// SetDBOptions dynamically changes database-wide options.
	// Reference: RocksDB v10.7.5 include/rocksdb/db.h lines 1810-1812
	SetDBOptions(newOptions map[string]string) error

	// GetIntProperty returns an integer property value.
	// Reference: RocksDB v10.7.5 include/rocksdb/db.h lines 1366-1368
	GetIntProperty(name string) (uint64, bool)

	// GetMapProperty returns a map property value.
	// Reference: RocksDB v10.7.5 include/rocksdb/db.h lines 1370-1372
	GetMapProperty(name string) (map[string]string, bool)

	// WaitForCompact waits for all compactions to complete.
	// Reference: RocksDB v10.7.5 include/rocksdb/db.h lines 1705-1708
	WaitForCompact(opts *WaitForCompactOptions) error

	// LockWAL locks the WAL, preventing new writes.
	// Reference: RocksDB v10.7.5 include/rocksdb/db.h lines 1791-1800
	LockWAL() error

	// UnlockWAL unlocks the WAL.
	// Reference: RocksDB v10.7.5 include/rocksdb/db.h lines 1801-1806
	UnlockWAL() error
}

type EventListener interface {
	// OnFlushCompleted is called when a flush job completes.
	OnFlushCompleted(info *FlushJobInfo)

	// OnFlushBegin is called when a flush job begins.
	OnFlushBegin(info *FlushJobInfo)

	// OnCompactionCompleted is called when a compaction job completes.
	OnCompactionCompleted(info *CompactionJobInfo)

	// OnCompactionBegin is called when a compaction job begins.
	OnCompactionBegin(info *CompactionJobInfo)

	// OnTableFileCreated is called when a table file is created.
	OnTableFileCreated(info *TableFileCreationInfo)

	// OnTableFileDeleted is called when a table file is deleted.
	OnTableFileDeleted(info *TableFileDeletionInfo)

	// OnBackgroundError is called when a background error occurs.
	OnBackgroundError(info *BackgroundErrorInfo)

	// OnStallConditionsChanged is called when stall conditions change.
	OnStallConditionsChanged(info *WriteStallInfo)
}

type ExternalSstFileInfo struct {
	// FilePath is the path to the SST file.
	FilePath string

	// SmallestKey is the smallest user key in the file.
	SmallestKey []byte

	// LargestKey is the largest user key in the file.
	LargestKey []byte

	// SmallestRangeDelKey is the smallest range deletion user key (if any).
	SmallestRangeDelKey []byte

	// LargestRangeDelKey is the largest range deletion user key (if any).
	LargestRangeDelKey []byte

	// SequenceNumber is the sequence number assigned to all keys in the file.
	// For externally created files, this is typically 0.
	SequenceNumber uint64

	// FileSize is the size of the file in bytes.
	FileSize uint64

	// NumEntries is the number of point entries (Put/Delete) in the file.
	NumEntries uint64

	// NumRangeDelEntries is the number of range deletion entries in the file.
	NumRangeDelEntries uint64

	// FileChecksum is the checksum of the file (if computed).
	FileChecksum string

	// Version is the SST file format version.
	Version int32
}

type FIFOCompactionOptions struct {
	// MaxTableFilesSize is the maximum total size before deletion.
	// Default: 1GB
	MaxTableFilesSize uint64

	// TTL is the time-to-live for files before deletion.
	// Default: 0 (disabled)
	TTL time.Duration

	// AllowCompaction allows intra-L0 compaction.
	// Default: false
	AllowCompaction bool
}

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

type FlushJobInfo struct {
	// CFName is the column family name.
	CFName string
	// FilePath is the path to the output SST file.
	FilePath string
	// ThreadID is the ID of the thread that performed the flush.
	ThreadID uint64
	// JobID is the unique identifier for this flush job.
	JobID int
	// TriggeredWritesSlowdown indicates if flush was triggered by write slowdown.
	TriggeredWritesSlowdown bool
	// TriggeredWritesStop indicates if flush was triggered by write stop.
	TriggeredWritesStop bool
	// SmallestSeqno is the smallest sequence number in the flushed file.
	SmallestSeqno uint64
	// LargestSeqno is the largest sequence number in the flushed file.
	LargestSeqno uint64
	// TableProperties contains properties of the flushed SST file.
	TableProperties map[string]string
	// FlushReason is the reason why the flush was triggered.
	FlushReason FlushReason
}

type FlushOptions struct {
	// Wait indicates whether to wait for the flush to complete.
	Wait bool

	// AllowWriteStall indicates whether to allow write stalls.
	AllowWriteStall bool
}

type FlushReason int

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

type HistogramData struct {
	Median  float64
	P95     float64
	P99     float64
	Average float64
	StdDev  float64
	Max     float64
	Min     float64
	Count   uint64
	Sum     uint64
}

type HistogramType int

type IOPriority int

type IngestExternalFileOptions struct {
	// MoveFiles: if true, move the files instead of copying them.
	// The input files will be unlinked after successful ingestion.
	MoveFiles bool

	// SnapshotConsistency: if false, ingested file keys could appear in
	// existing snapshots that were created before the file was ingested.
	SnapshotConsistency bool

	// AllowGlobalSeqNo: enables assigning a global sequence number to each
	// ingested file. If false, we will use the sequence numbers in the
	// ingested file as is.
	AllowGlobalSeqNo bool

	// AllowBlockingFlush: if true, IngestExternalFile() will trigger and
	// block for flushing memtable(s) if there is overlap between ingested
	// files and memtable(s). If false, ingestion will fail if overlap exists.
	AllowBlockingFlush bool

	// IngestBehind: if true, duplicate keys in the file being ingested will
	// be skipped rather than overwriting existing data. All files will be
	// ingested at the bottommost level with seqno=0.
	IngestBehind bool

	// FailIfNotBottommostLevel: if true, ingestion will fail if files cannot
	// be placed in the bottommost level.
	FailIfNotBottommostLevel bool

	// VerifyChecksumsBeforeIngest: if true, verify the checksums of each
	// block of the external SST file before ingestion.
	VerifyChecksumsBeforeIngest bool
}

type Iterator interface {
	// Valid returns true if the iterator is positioned at a valid entry.
	Valid() bool

	// SeekToFirst positions the iterator at the first key.
	SeekToFirst()

	// SeekToLast positions the iterator at the last key.
	SeekToLast()

	// Seek positions the iterator at the first key >= target.
	Seek(target []byte)

	// SeekForPrev positions the iterator at the last key <= target.
	SeekForPrev(target []byte)

	// Next moves the iterator to the next key.
	Next()

	// Prev moves the iterator to the previous key.
	Prev()

	// Key returns the key at the current position.
	// REQUIRES: Valid()
	Key() []byte

	// Value returns the value at the current position.
	// REQUIRES: Valid()
	Value() []byte

	// Error returns any error that has occurred.
	Error() error

	// Close releases resources associated with the iterator.
	Close() error
}

type LiveFileMetaData struct {
	// Name is the file name (without the directory path).
	Name string

	// Directory is the directory containing the file.
	Directory string

	// FileNumber is the file number.
	FileNumber uint64

	// Size is the file size in bytes.
	Size uint64

	// ColumnFamilyName is the name of the column family this file belongs to.
	ColumnFamilyName string

	// Level is the level at which this file resides.
	Level int

	// SmallestKey is the smallest user key in the file.
	SmallestKey []byte

	// LargestKey is the largest user key in the file.
	LargestKey []byte

	// SmallestSeqno is the smallest sequence number in the file.
	SmallestSeqno uint64

	// LargestSeqno is the largest sequence number in the file.
	LargestSeqno uint64

	// NumEntries is the number of entries in the file.
	NumEntries uint64

	// NumDeletions is the number of deletion entries in the file.
	NumDeletions uint64

	// BeingCompacted is true if the file is currently being compacted.
	BeingCompacted bool
}

type LockManagerOptions = txn.LockManagerOptions

type LockType = txn.LockType

type Logger = logging.Logger

type MaxOperator struct{}

type MergeOperator interface {
	// Name returns a unique identifier for this merge operator.
	// Used to check compatibility when opening an existing database.
	Name() string

	// FullMerge performs a merge operation.
	//
	// Parameters:
	// - key: The key associated with this merge operation
	// - existingValue: The existing value (nil if key doesn't exist)
	// - operands: List of merge operands to apply, oldest first
	//
	// Returns:
	// - newValue: The result of the merge
	// - ok: Whether the merge succeeded
	//
	// If ok is false, the merge is considered failed and treated as an error.
	FullMerge(key []byte, existingValue []byte, operands [][]byte) (newValue []byte, ok bool)

	// PartialMerge merges two operands into a single operand.
	// This is an optimization that allows combining operands before FullMerge.
	//
	// Parameters:
	// - key: The key associated with this merge operation
	// - leftOperand: The first operand
	// - rightOperand: The second operand
	//
	// Returns:
	// - newOperand: The combined operand
	// - ok: Whether the partial merge succeeded
	//
	// If ok is false, the operands cannot be combined and both must be kept.
	// PartialMerge is optional - returning (nil, false) is always valid.
	PartialMerge(key []byte, leftOperand, rightOperand []byte) (newOperand []byte, ok bool)
}

type NoOpEventListener struct{}

type NoopPrefixExtractor struct{}

type Options struct {
	// CreateIfMissing causes Open to create the database if it does not exist.
	CreateIfMissing bool

	// ErrorIfExists causes Open to return an error if the database already exists.
	ErrorIfExists bool

	// ParanoidChecks enables additional checks for data integrity.
	ParanoidChecks bool

	// FS is the filesystem implementation to use.
	// If nil, the OS filesystem is used.
	FS vfs.FS

	// Comparator defines the order of keys in the database.
	// If nil, a default bytewise comparator is used.
	Comparator Comparator

	// WriteBufferSize is the size of a single memtable.
	// Default: 64MB
	WriteBufferSize int

	// MaxWriteBufferNumber is the maximum number of memtables to keep in memory.
	// Default: 2
	MaxWriteBufferNumber int

	// MaxOpenFiles is the maximum number of SST files to keep open.
	// Default: 1000
	MaxOpenFiles int

	// BlockSize is the approximate size of data blocks within SST files.
	// Default: 4KB
	BlockSize int

	// BlockRestartInterval is how often to create restart points in blocks.
	// Default: 16
	BlockRestartInterval int

	// ChecksumType specifies the checksum algorithm for SST files.
	// Default: CRC32C
	ChecksumType ChecksumType

	// FormatVersion is the SST file format version.
	// Default: 3
	FormatVersion uint32

	// MergeOperator specifies the merge operator for merge operations.
	// If nil, Merge operations will return an error.
	MergeOperator MergeOperator

	// PrefixExtractor extracts prefixes from keys for prefix-based operations.
	// When set, bloom filters are built for prefixes instead of whole keys,
	// and prefix seek can be used for efficient iteration within a prefix.
	// If nil, no prefix optimization is used.
	PrefixExtractor PrefixExtractor

	// Level0FileNumCompactionTrigger is the number of files in level-0 that
	// triggers compaction to level-1.
	// Default: 4
	Level0FileNumCompactionTrigger int

	// MaxBytesForLevelBase is the maximum total data size for level-1.
	// Default: 256MB
	MaxBytesForLevelBase int64

	// BloomFilterBitsPerKey is the number of bits per key for bloom filters.
	// 0 disables bloom filters. Default: 10
	BloomFilterBitsPerKey int

	// Level0SlowdownWritesTrigger is the number of L0 files that triggers
	// write slowdown. When L0 file count exceeds this, writes are delayed.
	// Default: 20
	Level0SlowdownWritesTrigger int

	// Level0StopWritesTrigger is the number of L0 files that stops writes.
	// When L0 file count exceeds this, all writes are blocked until
	// compaction reduces the count.
	// Default: 36
	Level0StopWritesTrigger int

	// DisableAutoCompactions disables background compaction.
	// When true, no write stalling occurs based on L0 file count.
	// Default: false
	DisableAutoCompactions bool

	// CompactionFilter is called for each key-value pair during compaction.
	// It can filter out or modify entries during compaction.
	// If nil, no filtering is applied.
	CompactionFilter CompactionFilter

	// CompactionFilterFactory creates a new CompactionFilter for each compaction.
	// This takes precedence over CompactionFilter if both are set.
	// If nil, CompactionFilter is used directly.
	CompactionFilterFactory CompactionFilterFactory

	// CompactionStyle specifies the compaction strategy.
	// Default: CompactionStyleLevel
	CompactionStyle CompactionStyle

	// UniversalCompactionOptions contains options for universal compaction.
	// Only used when CompactionStyle is CompactionStyleUniversal.
	UniversalCompactionOptions *UniversalCompactionOptions

	// FIFOCompactionOptions contains options for FIFO compaction.
	// Only used when CompactionStyle is CompactionStyleFIFO.
	FIFOCompactionOptions *FIFOCompactionOptions

	// RateLimiter controls the rate of I/O operations.
	// If nil, no rate limiting is applied.
	RateLimiter RateLimiter

	// Compression specifies the compression algorithm for SST blocks.
	// Default: NoCompression
	Compression CompressionType

	// MaxSubcompactions is the maximum number of subcompactions per compaction job.
	// Subcompactions allow parallel compaction within a single job by dividing
	// the key range. Higher values can improve compaction throughput on multi-core
	// systems but increase memory usage.
	// Default: 1 (no parallel subcompaction)
	MaxSubcompactions int

	// UseDirectReads enables O_DIRECT for reading data.
	// This bypasses the OS page cache and reads directly from disk.
	// Beneficial for reducing memory pressure and cache pollution.
	// Requires aligned buffers and may not be supported on all platforms.
	// Reference: RocksDB v10.7.5 include/rocksdb/options.h line 1022-1024
	// Default: false
	UseDirectReads bool

	// UseDirectIOForFlushAndCompaction enables O_DIRECT for background
	// flush and compaction writes. This bypasses the OS page cache.
	// Reference: RocksDB v10.7.5 include/rocksdb/options.h line 1026-1028
	// Default: false
	UseDirectIOForFlushAndCompaction bool

	// Logger is the logger for database operations.
	// If nil, a default logger writing to stderr is used.
	Logger Logger
}

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

type PessimisticTransactionOptions struct {
	// SetSnapshot determines if the transaction should set a snapshot at creation.
	SetSnapshot bool

	// LockTimeout is the timeout for acquiring locks.
	LockTimeout time.Duration

	// DeadlockDetect enables deadlock detection.
	DeadlockDetect bool

	// Expiration is the transaction expiration time (0 = no expiration).
	Expiration time.Duration

	// ReadOnly makes the transaction read-only (no writes allowed).
	ReadOnly bool
}

type PinnableWideColumns struct {
	Columns WideColumns
	// contains filtered or unexported fields
}

type PrefixExtractor interface {
	// Name returns a unique identifier for this prefix extractor.
	// The name is stored in SST files and used for compatibility checks.
	Name() string

	// Transform extracts the prefix from the given key.
	// The returned slice may reference the input key's memory.
	// REQUIRES: InDomain(key) == true
	Transform(key []byte) []byte

	// InDomain returns true if the key has a valid prefix.
	// If false, the key is considered "out of domain" and prefix bloom
	// filters will not be used for it.
	InDomain(key []byte) bool
}

type Range struct {
	Start []byte
	Limit []byte
}

type RateLimiter interface {
	// Request requests bytes to be written/read.
	// It blocks until enough quota is available.
	Request(bytes int64, priority IOPriority)

	// SetBytesPerSecond dynamically sets the rate limit.
	SetBytesPerSecond(bytesPerSecond int64)

	// GetBytesPerSecond returns the current rate limit.
	GetBytesPerSecond() int64

	// GetTotalBytesThrough returns total bytes passed through the limiter.
	GetTotalBytesThrough(priority IOPriority) int64

	// GetTotalRequests returns total request count.
	GetTotalRequests(priority IOPriority) int64

	// IsRateLimited returns true if the priority is rate limited.
	IsRateLimited(priority IOPriority) bool
}

type RateLimiterMode int

type RateLimiterOptions struct {
	// BytesPerSecond is the maximum rate in bytes per second.
	BytesPerSecond int64

	// RefillPeriod is how often to refill the token bucket.
	// Default: 100ms
	RefillPeriod time.Duration

	// Fairness controls how aggressively high-priority requests preempt low-priority.
	// Range: 1-100, lower = more aggressive. Default: 10
	Fairness int64

	// Mode specifies what I/O to rate limit.
	Mode RateLimiterMode
}

type ReadOnlyDB interface {
	DB

	// NewCheckpoint returns a checkpoint helper bound to the same underlying DB.
	NewCheckpoint() *Checkpoint
}

type ReadOptions struct {
	// VerifyChecksums enables checksum verification when reading.
	VerifyChecksums bool

	// FillCache indicates whether to fill the block cache on reads.
	FillCache bool

	// Snapshot provides a consistent view of the database.
	// If nil, the most recent state is used.
	Snapshot *Snapshot

	// Timestamp specifies the timestamp for reading.
	// Read will return the latest data visible to the specified timestamp.
	// All timestamps of the same database must be of the same length.
	// For iterators, IterStartTimestamp is the lower bound (older) and
	// Timestamp serves as the upper bound.
	// If nil, timestamps are not used.
	//
	// Reference: RocksDB v10.7.5 include/rocksdb/options.h (ReadOptions::timestamp)
	Timestamp []byte

	// IterStartTimestamp is the lower bound (older) timestamp for iterators.
	// Versions of the same record that fall in the timestamp range
	// [IterStartTimestamp, Timestamp] will be returned.
	// If nil, only the most recent version visible to Timestamp is returned.
	//
	// Reference: RocksDB v10.7.5 include/rocksdb/options.h (ReadOptions::iter_start_ts)
	IterStartTimestamp []byte

	// TotalOrderSeek enables total order seek.
	// When true, prefix bloom filters are bypassed and all keys are considered.
	// When false (default), prefix seek optimization is used if a prefix extractor
	// is configured.
	TotalOrderSeek bool

	// PrefixSameAsStart optimizes iteration when the user knows the iteration
	// will stay within the same prefix.
	// When true, the iterator may skip to the next data block if it determines
	// all keys in the current block have a different prefix.
	PrefixSameAsStart bool

	// IterateUpperBound sets an upper bound for iteration.
	// The iterator will stop before any key >= this bound.
	// This can be used with prefix seek to efficiently limit iteration.
	IterateUpperBound []byte

	// IterateLowerBound sets a lower bound for iteration.
	// The iterator will skip any key < this bound.
	IterateLowerBound []byte
}

type RecoveredPreparedTxn struct {
	Name       string
	PrepareSeq uint64
	Keys       [][]byte // Keys that were written in this transaction
}

type RemoveByPrefixFilter struct {
	BaseCompactionFilter
	Prefix []byte
}

type RemoveByRangeFilter struct {
	BaseCompactionFilter
	StartKey []byte // Inclusive
	EndKey   []byte // Exclusive
}

type ReplicationDB interface {
	DB

	// GetUpdatesSince returns an iterator positioned at the first write batch whose sequence number is >= seqNumber.
	GetUpdatesSince(seqNumber uint64, readOpts TransactionLogIteratorReadOptions) (*TransactionLogIterator, error)

	// GetSortedWalFiles returns WAL files sorted by log number.
	GetSortedWalFiles() ([]WalFile, error)
}

type ReverseBytewiseComparatorWithU64Ts struct{}

type SecondaryDB interface {
	DB

	// TryCatchUpWithPrimary refreshes the secondary view by reading new MANIFEST records.
	TryCatchUpWithPrimary() error

	// NewCheckpoint returns a checkpoint helper bound to the same underlying DB.
	NewCheckpoint() *Checkpoint
}

type SizeApproximationFlags uint8

type SizeApproximationOptions struct {
	IncludeMemtables bool
	IncludeFiles     bool
}

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

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

type SstFileWriterOptions struct {
	// Comparator for key ordering. If nil, uses bytewise comparator.
	Comparator Comparator

	// Compression type for the SST file.
	Compression CompressionType

	// BlockSize is the target size for data blocks.
	BlockSize int

	// BlockRestartInterval is the number of keys between restart points.
	BlockRestartInterval int

	// FilterBitsPerKey for creating bloom filters. 0 means no filter.
	FilterBitsPerKey int

	// FormatVersion is the SST file format version.
	FormatVersion uint32
}

type Statistics interface {
	// GetTickerCount returns the current value of a ticker.
	GetTickerCount(tickerType TickerType) uint64

	// RecordTick increments a ticker by count.
	RecordTick(tickerType TickerType, count uint64)

	// SetTickerCount sets the ticker to a specific value.
	SetTickerCount(tickerType TickerType, count uint64)

	// GetHistogramData returns histogram statistics.
	GetHistogramData(histogramType HistogramType) HistogramData

	// MeasureTime records a value to a histogram.
	MeasureTime(histogramType HistogramType, value uint64)

	// Reset clears all statistics.
	Reset()

	// String returns a formatted string of all statistics.
	String() string
}

type StringAppendOperator struct {
	Delimiter string
}

type TTLCompactionFilter struct {
	BaseCompactionFilter
	TTL time.Duration
}

type TTLCompactionFilterFactory struct {
	TTL time.Duration
}

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

type TableFileCreationInfo struct {
	// DBName is the database name.
	DBName string
	// CFName is the column family name.
	CFName string
	// FilePath is the path to the created file.
	FilePath string
	// FileSize is the size of the file in bytes.
	FileSize uint64
	// JobID is the ID of the job that created the file.
	JobID int
	// Reason is why the file was created.
	Reason TableFileCreationReason
	// Status is the creation status (nil for success).
	Status error
	// TableProperties contains properties of the created SST file.
	TableProperties map[string]string
}

type TableFileCreationReason int

type TableFileDeletionInfo struct {
	// DBName is the database name.
	DBName string
	// FilePath is the path to the deleted file.
	FilePath string
	// JobID is the ID of the job that deleted the file.
	JobID int
	// Status is the deletion status (nil for success).
	Status error
}

type TickerType int

type TimestampedComparator interface {
	Comparator

	// TimestampSize returns the size of the timestamp in bytes.
	// Returns 0 if timestamps are not supported.
	TimestampSize() int

	// CompareTimestamp compares two timestamps.
	// Returns < 0 if ts1 < ts2, 0 if equal, > 0 if ts1 > ts2.
	CompareTimestamp(ts1, ts2 []byte) int

	// CompareWithoutTimestamp compares two keys ignoring their timestamps.
	CompareWithoutTimestamp(a, b []byte, aHasTS, bHasTS bool) int

	// GetMaxTimestamp returns the maximum timestamp value.
	GetMaxTimestamp() []byte

	// GetMinTimestamp returns the minimum timestamp value.
	GetMinTimestamp() []byte
}

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

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

type TimingEventListener struct {
	NoOpEventListener
	FlushTimes      []time.Time
	CompactionTimes []time.Time
	// contains filtered or unexported fields
}

type Transaction interface {
	// Put sets the value for the given key within the transaction.
	Put(key, value []byte) error

	// PutCF sets the value for the given key in the specified column family.
	PutCF(cf ColumnFamilyHandle, key, value []byte) error

	// Get retrieves the value for the given key.
	// It first checks the transaction's write batch, then falls back to the database.
	Get(key []byte) ([]byte, error)

	// GetCF retrieves the value from the specified column family.
	GetCF(cf ColumnFamilyHandle, key []byte) ([]byte, error)

	// GetForUpdate retrieves the value and marks it for conflict detection.
	// For optimistic transactions, this tracks the key for validation at commit.
	// For pessimistic transactions, this acquires a lock.
	GetForUpdate(key []byte, exclusive bool) ([]byte, error)

	// Delete removes the key from the transaction.
	Delete(key []byte) error

	// DeleteCF removes the key from the specified column family.
	DeleteCF(cf ColumnFamilyHandle, key []byte) error

	// Commit validates and applies the transaction.
	// Returns ErrTransactionConflict if there are write conflicts.
	Commit() error

	// Rollback discards the transaction.
	Rollback() error

	// SetSnapshot sets the transaction's snapshot to the current database state.
	SetSnapshot()

	// GetSnapshot returns the transaction's snapshot.
	GetSnapshot() *Snapshot
}

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

type TransactionDBOptions struct {
	// LockManagerOptions configures the lock manager.
	LockManagerOptions LockManagerOptions

	// MaxNumLocks is the maximum number of locks to track (0 = unlimited).
	MaxNumLocks uint64

	// NumStripes is the number of lock stripes for lock manager striping (for future use).
	NumStripes int

	// TransactionLockTimeout is the default lock timeout for transactions.
	TransactionLockTimeout int64 // in milliseconds
}

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

type TransactionLogIteratorReadOptions struct {
	// VerifyChecksums enables checksum verification when reading WAL records.
	VerifyChecksums bool
}

type TransactionOptions struct {
	// SetSnapshot determines if the transaction should set a snapshot at creation.
	SetSnapshot bool
}

type TransactionState int

type UInt64AddOperator struct{}

type UniversalCompactionOptions struct {
	// SizeRatio is the percentage trigger for size ratio compaction.
	// Default: 1
	SizeRatio int

	// MinMergeWidth is the minimum number of files to merge.
	// Default: 2
	MinMergeWidth int

	// MaxMergeWidth is the maximum number of files to merge.
	// Default: unlimited
	MaxMergeWidth int

	// MaxSizeAmplificationPercent triggers full compaction when exceeded.
	// Default: 200
	MaxSizeAmplificationPercent int

	// AllowTrivialMove allows trivial moves when possible.
	// Default: false
	AllowTrivialMove bool
}

type WaitForCompactOptions struct {
	// AbortOnPause makes WaitForCompact abort if compaction is paused.
	AbortOnPause bool
	// FlushFirst flushes memtable before waiting for compaction.
	FlushFirst bool
	// CloseDB closes the database after waiting (for graceful shutdown).
	CloseDB bool
	// Timeout is the maximum time to wait. Zero means wait forever.
	Timeout time.Duration
}

type WalFile struct {
	// PathName returns the full path to the WAL file.
	PathName string

	// LogNumber is the WAL file number.
	LogNumber uint64

	// Type indicates whether the file is live or archived.
	Type WalFileType

	// StartSequence is the starting sequence number of the first write batch.
	StartSequence uint64

	// SizeBytes is the size of the file in bytes.
	SizeBytes uint64
}

type WalFileType int

type WideColumn struct {
	Name  []byte
	Value []byte
}

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

type WideColumnDBInterface interface {
	// PutEntity stores an entity (key with multiple named columns)
	PutEntity(key []byte, columns WideColumns) error

	// GetEntity retrieves an entity's columns
	GetEntity(key []byte) (*PinnableWideColumns, error)

	// DeleteEntity deletes an entity
	DeleteEntity(key []byte) error
}

type WideColumns []WideColumn

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

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

type WriteBufferStats struct {
	TotalReserved   uint64 // Total memory reserved
	TotalFreed      uint64 // Total memory freed
	PeakUsage       uint64 // Peak memory usage
	FlushTriggers   uint64 // Number of times flush was triggered
	StallEvents     uint64 // Number of stall events
	StallDurationNs uint64 // Total stall duration in nanoseconds
}

type WriteOptions struct {
	// Sync causes writes to be flushed to the WAL and fsynced before returning.
	// This provides the strongest durability guarantee but reduces throughput.
	Sync bool

	// DisableWAL disables the write-ahead log for this write.
	//
	// WARNING: With DisableWAL=true, writes go directly to the memtable.
	// If the process crashes before Flush() is called, data will be lost.
	// This matches C++ RocksDB behavior exactly.
	//
	// Use only when you can tolerate data loss in exchange for higher throughput.
	// Call Flush() explicitly before shutdown to persist unflushed data.
	DisableWAL bool
}

type WritePreparedTxn struct {
	*PessimisticTransaction
	// contains filtered or unexported fields
}

type WritePreparedTxnDB struct {
	*TransactionDB
	// contains filtered or unexported fields
}

type WriteStallCause int

type WriteStallCondition int

type WriteStallController interface {
	DB

	ReleaseWriteStall()
}

type WriteStallInfo struct {
	// CFName is the column family name.
	CFName string
	// Condition is the stall condition.
	Condition WriteStallCondition
	// Prev is the previous stall condition.
	Prev WriteStallCondition
}