runtime

type Appendable interface {
	// Append appends the given value to the end of the collection or returns an error if the operation fails.
	Append(ctx context.Context, val Value) error
}

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

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

type Binary []byte

type Boolean bool

type Box[T any] struct {
	Value T
}

type Cloneable interface {
	Value
	// Clone creates a deep copy of the value.
	Clone(ctx context.Context) (Cloneable, error)
}

type Collection interface {
	Value
	Containable
	Comparable
	Measurable
	Cloneable
	Iterable

	// Clear removes all elements from the collection or returns an error if the operation fails.
	Clear(ctx context.Context) error
}

type Comparable interface {
	Compare(other Value) int
}

type Comparator = func(first, second Value) int

type Containable interface {
	// Contains method checks if the given value exists in the collection and returns a boolean result or an error if the operation fails.
	Contains(ctx context.Context, value Value) (Boolean, error)
}

type DateTime struct {
	time.Time
}

type DispatchEvent struct {
	Payload Value  `json:"payload"`
	Options Value  `json:"options"`
	Name    String `json:"name"`
}

type Dispatchable interface {
	Dispatch(ctx context.Context, event DispatchEvent) (Value, error)
}

type Float float64

type FnDef[T FunctionConstraint] interface {
	// Add adds a function to the builder.
	// If a function with the same name already exists, it will be ignored and an error will be recorded.
	Add(name string, fn T) FnDef[T]
	// Remove removes a function from the builder.
	// If a function with the same name does not exist, an error will be recorded.
	Remove(name string) FnDef[T]
	// Has checks if a function with the given name exists in the builder.
	Has(name string) bool
	// List retrieves the names of all functions currently registered in the builder.
	List() []string
	// ForEach iterates over all registered functions, calling the provided function with each function and its name.
	// Iteration stops if the provided function returns false.
	ForEach(fn func(fn T, name string) bool)
}

type Function = func(ctx context.Context, args ...Value) (Value, error)

type Function0 = func(ctx context.Context) (Value, error)

type Function1 = func(ctx context.Context, arg Value) (Value, error)

type Function2 = func(ctx context.Context, arg1, arg2 Value) (Value, error)

type Function3 = func(ctx context.Context, arg1, arg2, arg3 Value) (Value, error)

type Function4 = func(ctx context.Context, arg1, arg2, arg3, arg4 Value) (Value, error)

type FunctionCollection[T FunctionConstraint] interface {
	Has(name string) bool
	Get(name string) (T, bool)
	GetAll() map[string]T
	Names() []string
	Size() int
	ForEach(fn func(T, string) bool)
}

type FunctionConstraint interface {
	Function | Function0 | Function1 | Function2 | Function3 | Function4
}

type FunctionDefs interface {
	// Size returns the total number of function definitions present in the collection.
	Size() int
	// Has checks if an entity with the given name exists in the collection and returns true if found, false otherwise.
	Has(name string) bool
	// A0 returns a function definition interface for managing functions with 0 arguments.
	A0() FnDef[Function0]
	// A1 returns a function definition interface for managing functions with 1 argument.
	A1() FnDef[Function1]
	// A2 returns a function definition interface for managing functions with 2 arguments.
	A2() FnDef[Function2]
	// A3 returns a function definition interface for managing functions with 3 arguments.
	A3() FnDef[Function3]
	// A4 returns a function definition interface for managing functions with 4 arguments.
	A4() FnDef[Function4]
	// Var returns a function definition interface for managing dynamic functions with variable arguments.
	Var() FnDef[Function]
	// From initializes the builder with functions from the given Functions container.
	From(other FunctionDefs) FunctionDefs
}

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

type FunctionsBuilder struct {
	FunctionDefs
	// contains filtered or unexported fields
}

type Hashable interface {
	// Hash returns a hash value for the object.
	Hash() uint64
}

type IndexLookup interface {
	// LookupAt returns the value at index.
	// It returns found=false, err=nil when the index does not exist.
	// It returns a non-nil error only if the lookup itself fails.
	LookupAt(ctx context.Context, index Int) (Value, bool, error)
}

type IndexReadable interface {
	// At retrieves the value at the given index or returns an error if the index is invalid.
	At(ctx context.Context, idx Int) (Value, error)
}

type IndexReadablePredicate = func(ctx context.Context, value Value, idx Int) (Boolean, error)

type IndexRemovable interface {
	// RemoveAt method removes the value at the given index and returns it or returns an error if the index is invalid.
	RemoveAt(ctx context.Context, idx Int) (Value, error)
}

type IndexWritable interface {
	// SetAt method updates the value at the given index or returns an error if the index is invalid.
	SetAt(ctx context.Context, idx Int, value Value) error
}

type Int int64

type Iterable interface {
	Iterate(ctx context.Context) (Iterator, error)
}

type Iterator interface {
	Next(ctx context.Context) (value Value, key Value, err error)
}

type KeyLookup interface {
	// Lookup returns the value associated with key.
	// It returns found=false, err=nil when the key does not exist.
	// It returns a non-nil error only if the lookup itself fails.
	Lookup(ctx context.Context, key Value) (Value, bool, error)
}

type KeyReadable interface {
	// Get retrieves the value associated with the given key.
	// Implementations may represent missing keys as (None, nil), or return an error for backends
	// where lookup itself can fail (for example remote/IO-backed stores).
	Get(ctx context.Context, key Value) (Value, error)
}

type KeyReadablePredicate = func(ctx context.Context, value, key Value) (Boolean, error)

type KeyRemovable interface {
	// RemoveKey removes the value associated with the specified key from the collection or returns an error if the operation fails.
	RemoveKey(ctx context.Context, key Value) error
}

type KeyWritable interface {
	// Set method sets or updates the value associated with the given key or returns an error if the operation fails.
	Set(ctx context.Context, key, value Value) error
}

type Library interface {
	Namespace

	// Size returns the total number of elements or entities in the collection or namespace.
	Size() int

	// Build constructs and returns a finalized Functions instance or an error if the build process fails.
	Build() (*Functions, error)
}

type List interface {
	Collection
	Sortable
	Appendable
	IndexReadable
	IndexLookup
	IndexWritable
	IndexRemovable
	ValueRemovable
	Spawnable[List]

	// Insert adds a value at the specified index in a collection or returns an error if the index is invalid or operation fails.
	Insert(ctx context.Context, idx Int, value Value) error
	// Swap exchanges the values at two specified indices in a collection or returns an error if indices are invalid or operation fails.
	Swap(ctx context.Context, a, b Int) error
	// Concat concatenates another list to the current list or returns an error if the operation fails.
	Concat(ctx context.Context, other List) error

	// Filter creates a new list containing elements that satisfy the given predicate or returns an error if filtering fails.
	Filter(ctx context.Context, predicate IndexReadablePredicate) (List, error)
	// Find searches for the first element in the list that satisfies the given predicate or returns an error if search fails.
	Find(ctx context.Context, predicate IndexReadablePredicate) (Value, Boolean, error)
	// IndexOf returns the index of the first occurrence of the specified value in the list or -1 if not found.
	IndexOf(ctx context.Context, value Value) (Int, error)
	// First retrieves the first element of the collection or returns an error if the collection is empty or inaccessible.
	First(ctx context.Context) (Value, error)
	// Last retrieves the last element of the collection or returns an error if the collection is empty or inaccessible.
	Last(ctx context.Context) (Value, error)
	// Slice returns a new list containing elements from the specified range or returns an error if range is invalid or inaccessible.
	Slice(ctx context.Context, start, end Int) (List, error)

	// ForEach iterates over each element in the list and applies the given predicate function or returns an error if iteration fails.
	ForEach(ctx context.Context, predicate IndexReadablePredicate) error
}

type ListStorage interface {
	Iterable
	Measurable
	IndexReadable
	Sortable

	Add(ctx context.Context, value Value) error
	AddKV(ctx context.Context, key, value Value) error
}

type LogLevel int8

type LogSettings struct {
	Writer io.Writer
	Fields map[string]interface{}
	Level  LogLevel
}

type Map interface {
	Collection
	KeyReadable
	KeyLookup
	KeyWritable
	KeyRemovable
	ValueRemovable
	Spawnable[Map]

	// Merge merges another map into the current map, combining their key-value pairs or returns an error if merging fails.
	Merge(ctx context.Context, other Map) error

	// ContainsKey checks if the map contains the specified key or returns an error if key check fails.
	ContainsKey(ctx context.Context, key Value) (Boolean, error)
	// Keys returns a list of all keys in the map or an error if retrieval fails.
	Keys(ctx context.Context) (List, error)
	// Values returns a list of all values in the map or an error if retrieval fails.
	Values(ctx context.Context) (List, error)
	// Filter returns a list of values that satisfy the given predicate or an error if filtering fails.
	Filter(ctx context.Context, predicate KeyReadablePredicate) (List, error)
	// Find searches for the first value in the map that satisfies the given predicate or returns an error if search fails.
	Find(ctx context.Context, predicate KeyReadablePredicate) (Value, Boolean, error)

	// ForEach iterates over each key-value pair in the map and applies the given predicate function or returns an error if iteration fails.
	ForEach(ctx context.Context, predicate KeyReadablePredicate) error
}

type MapStorage interface {
	Iterable
	Measurable
	KeyReadable
	KeyWritable
}

type Measurable interface {
	Length(ctx context.Context) (Int, error)
}

type Message interface {
	// Value returns a value of the message.
	Value() Value
	// Err returns an error of the message.
	Err() error
}

type Namespace interface {
	// Namespace creates a new nested namespace with the given name and returns it.
	Namespace(name string) Namespace
	// Function returns a FunctionDefs interface that allows registering functions within this namespace.
	Function() FunctionDefs
}

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

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

type ObjectLike interface {
	Map
	ObjectLike()
}

type Observable interface {
	Subscribe(ctx context.Context, subscription Subscription) (Stream, error)
}

type Params map[string]Value

type Predicate = func(ctx context.Context, value, idx Value) (Boolean, error)

type Query struct {
	Options Value  `json:"options"`
	Kind    String `json:"kind"`
	Payload String `json:"payload"`
}

type Queryable interface {
	Query(ctx context.Context, q Query) (List, error)
}

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

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

type Resource interface {
	io.Closer
	ResourceID() uint64
}

type SortDirection = Int

type SortLess = func(ctx context.Context, a, b Int) (Boolean, error)

type SortSwap = func(ctx context.Context, a, b Int) error

type Sortable interface {
	// SortAsc sorts the collection in ascending order.
	SortAsc(context.Context) error

	// SortDesc sorts the collection in descending order.
	SortDesc(context.Context) error
}

type Spawnable[T any] interface {
	// Empty creates a new instance of the type or returns an error if the operation fails.
	// The new instance should be initialized with default values and ready for use.
	Empty(ctx context.Context) (T, error)
}

type StateManagerFactory interface {
	New(ctx context.Context) (StorageManager, error)
}

type StorageManager interface {
	io.Closer
	ValueStorage(ctx context.Context, name String) (ValueStorage, error)
	ListStorage(ctx context.Context, name String) (ListStorage, error)
	MapStorage(ctx context.Context, name String) (MapStorage, error)
}

type Stream interface {
	io.Closer
	Read(ctx context.Context) <-chan Message
}

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

type String string

type Subscription struct {
	Options   Map    `json:"options"`
	EventName String `json:"eventName"`
}

type Type interface {
	fmt.Stringer
	// Name returns the name of the type represented by this Type.
	Name() string
	// Is checks if the provided value is of the type represented by this Type.
	Is(Value) bool
}

type TypeMatcher func(Value) bool

type Typed interface {
	Type() Type
}

type Unwrappable interface {
	Unwrap() any
}

type Value interface {
	fmt.Stringer
	Hashable
	// Copy returns a shallow copy of the value.
	// TODO: Add context and error
	Copy() Value
}

type ValueAssertion func(input Value) error

type ValueRemovable interface {
	// Remove method removes the first occurrence of the given value or returns an error if the operation fails.
	Remove(ctx context.Context, value Value) error
}

type ValueStorage interface {
	Set(ctx context.Context, value Value) error
	Get(ctx context.Context) (Value, error)
}