data

type Backend interface {
	// DataExists reports whether the declared data key exists.
	DataExists(context.Context, Key) (bool, error)
	// DataExpire changes an existing key's TTL without changing its contents.
	DataExpire(context.Context, Key, cache.TTL) (bool, error)
	// DataDeleteMany atomically deletes a canonical batch and returns the number of removed keys.
	DataDeleteMany(context.Context, []Key) (uint64, error)
	// DataCount returns collection cardinality within the supplied limits.
	DataCount(context.Context, Key, Limits) (uint64, error)
}

type Config struct {
	Namespace                                                 keyspace.Namespace
	MaxDeclarations, MaxKeyBytes, MaxConcurrent, MaxBatchKeys int
	Timeout                                                   time.Duration
	Limits                                                    Limits
}

type End uint8

type Handle[K any] struct {
	// contains filtered or unexported fields
}

type Hash[K, F, V any] struct {
	Handle[K]
	// contains filtered or unexported fields
}

type HashBackend interface {
	// HashGet returns an encoded field value and distinguishes a missing field.
	HashGet(context.Context, Key, string, Limits) (string, bool, error)
	// HashSet stores an encoded field value and reports whether the field was newly inserted.
	HashSet(context.Context, Key, string, string, Limits) (bool, error)
	// HashDelete removes a field and reports whether it existed.
	HashDelete(context.Context, Key, string, Limits) (bool, error)
}

type HashCounterBackend interface {
	// HashIncrement atomically adds delta to an integer field, starting a missing field at zero.
	HashIncrement(context.Context, Key, string, int64, Limits) (int64, error)
}

type HashDeclaration[K, F, V any] struct {
	// contains filtered or unexported fields
}

type HashEntry[F, V any] struct {
	Field F
	Value V
}

type HashReadBackend interface {
	// HashGetMany returns optional encoded values in requested field order.
	HashGetMany(context.Context, Key, []string, Limits) ([]value.Optional[string], error)
	// HashGetAll returns every encoded field and value ordered by field bytes.
	HashGetAll(context.Context, Key, Limits) ([]StoredField, error)
}

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

type Kind string

type Limits struct{ Entries, FieldBytes, ValueBytes, ReplyBytes int }

type List[K, V any] struct {
	Handle[K]
	// contains filtered or unexported fields
}

type ListBackend interface {
	// ListPush inserts values at the selected end and returns the new length.
	ListPush(context.Context, Key, []string, End, Limits) (uint64, error)
	// ListPop removes a size-checked element from the selected end and distinguishes absence.
	ListPop(context.Context, Key, End, Limits) (string, bool, error)
	// ListRange returns elements from start through stop inclusive, with negative indices relative to the tail.
	ListRange(context.Context, Key, int64, int64, Limits) ([]string, error)
	// ListTrim retains elements from start through stop inclusive, with negative indices relative to the tail.
	ListTrim(context.Context, Key, int64, int64, Limits) error
}

type ListDeclaration[K, V any] struct {
	// contains filtered or unexported fields
}

type Name string

type Order uint8

type ScoreRange struct {
	Min, Max               float64
	ExcludeMin, ExcludeMax bool
}

type Scored[V any] struct {
	Member V
	Score  float64
}

type Set[K, V any] struct {
	Handle[K]
	// contains filtered or unexported fields
}

type SetBackend interface {
	// SetAdd inserts an encoded member and reports whether it was new.
	SetAdd(context.Context, Key, string, Limits) (bool, error)
	// SetRemove removes an encoded member and reports whether it existed.
	SetRemove(context.Context, Key, string, Limits) (bool, error)
	// SetContains tests exact encoded member equality.
	SetContains(context.Context, Key, string, Limits) (bool, error)
	// SetMembers returns owned member strings in byte order within the reply limits.
	SetMembers(context.Context, Key, Limits) ([]string, error)
}

type SetDeclaration[K, V any] struct {
	// contains filtered or unexported fields
}

type SortedSet[K, V any] struct {
	Handle[K]
	// contains filtered or unexported fields
}

type SortedSetBackend interface {
	// SortedSetAdd inserts or re-scores a member and reports whether it was new.
	SortedSetAdd(context.Context, Key, string, float64, Limits) (bool, error)
	// SortedSetIncrement atomically adds delta to a member's score, starting a missing member at zero.
	SortedSetIncrement(context.Context, Key, string, float64, Limits) (float64, error)
	// SortedSetRemove removes a member and reports whether it existed.
	SortedSetRemove(context.Context, Key, string, Limits) (bool, error)
	// SortedSetScore returns a member's score and distinguishes absence.
	SortedSetScore(context.Context, Key, string, Limits) (float64, bool, error)
	// SortedSetRank returns a member's zero-based rank in the selected order and distinguishes absence.
	SortedSetRank(context.Context, Key, string, Order, Limits) (uint64, bool, error)
	// SortedSetRange returns members and scores within a bounded rank window.
	SortedSetRange(context.Context, Key, Window, Limits) ([]StoredMember, error)
	// SortedSetRangeByScore returns matching members and scores within a bounded window.
	SortedSetRangeByScore(context.Context, Key, ScoreRange, Window, Limits) ([]StoredMember, error)
	// SortedSetCountByScore counts members matching the score range.
	SortedSetCountByScore(context.Context, Key, ScoreRange, Limits) (uint64, error)
}

type SortedSetDeclaration[K, V any] struct {
	// contains filtered or unexported fields
}

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

type StoredField struct{ Field, Value string }

type StoredMember struct {
	Member string
	Score  float64
}

type Version uint32

type Window struct {
	Offset, Count int
	Order         Order
}