// Generated by Lisette bindgen
// Source: reflect (Go stdlib)
// Go: 1.25.10
// Lisette: 0.3.0

import "go:iter"

/// ChanDir represents a channel type's direction.
pub struct ChanDir(int)

pub const BothDir: ChanDir = 3

pub const RecvDir: ChanDir = 1

pub const SendDir: ChanDir = 2

/// A Kind represents the specific kind of type that a [Type] represents.
/// The zero Kind is not a valid kind.
pub struct Kind(uint)

pub const Array: Kind = 17

pub const Bool: Kind = 1

pub const Chan: Kind = 18

pub const Complex128: Kind = 16

pub const Complex64: Kind = 15

pub const Float32: Kind = 13

pub const Float64: Kind = 14

pub const Func: Kind = 19

pub const Int: Kind = 2

pub const Int16: Kind = 4

pub const Int32: Kind = 5

pub const Int64: Kind = 6

pub const Int8: Kind = 3

pub const Interface: Kind = 20

pub const Invalid: Kind = 0

pub const Map: Kind = 21

pub const Pointer: Kind = 22

/// Ptr is the old name for the [Pointer] kind.
pub const Ptr: Kind = 22

pub const Slice: Kind = 23

pub const String: Kind = 24

pub const Struct: Kind = 25

pub const Uint: Kind = 7

pub const Uint16: Kind = 9

pub const Uint32: Kind = 10

pub const Uint64: Kind = 11

pub const Uint8: Kind = 8

pub const Uintptr: Kind = 12

pub const UnsafePointer: Kind = 26

/// A SelectDir describes the communication direction of a select case.
pub struct SelectDir(int)

pub const SelectDefault: SelectDir = 3

pub const SelectRecv: SelectDir = 2

pub const SelectSend: SelectDir = 1

/// Append appends the values x to a slice s and returns the resulting slice.
/// As in Go, each x's value must be assignable to the slice's element type.
pub fn Append(s: Value, x: VarArgs<Value>) -> Value

/// AppendSlice appends a slice t to a slice s and returns the resulting slice.
/// The slices s and t must have the same element type.
pub fn AppendSlice(s: Value, t: Value) -> Value

/// ArrayOf returns the array type with the given length and element type.
/// For example, if t represents int, ArrayOf(5, t) represents [5]int.
/// 
/// If the resulting type would be larger than the available address space,
/// ArrayOf panics.
pub fn ArrayOf(length: int, elem: Type) -> Type

/// ChanOf returns the channel type with the given direction and element type.
/// For example, if t represents int, ChanOf(RecvDir, t) represents <-chan int.
/// 
/// The gc runtime imposes a limit of 64 kB on channel element types.
/// If t's size is equal to or exceeds this limit, ChanOf panics.
pub fn ChanOf(dir: ChanDir, t: Type) -> Type

/// Copy copies the contents of src into dst until either
/// dst has been filled or src has been exhausted.
/// It returns the number of elements copied.
/// Dst and src each must have kind [Slice] or [Array], and
/// dst and src must have the same element type.
/// It dst is an [Array], it panics if [Value.CanSet] returns false.
/// 
/// As a special case, src can have kind [String] if the element type of dst is kind [Uint8].
pub fn Copy(dst: Value, src: Value) -> int

/// DeepEqual reports whether x and y are “deeply equal,” defined as follows.
/// Two values of identical type are deeply equal if one of the following cases applies.
/// Values of distinct types are never deeply equal.
/// 
/// Array values are deeply equal when their corresponding elements are deeply equal.
/// 
/// Struct values are deeply equal if their corresponding fields,
/// both exported and unexported, are deeply equal.
/// 
/// Func values are deeply equal if both are nil; otherwise they are not deeply equal.
/// 
/// Interface values are deeply equal if they hold deeply equal concrete values.
/// 
/// Map values are deeply equal when all of the following are true:
/// they are both nil or both non-nil, they have the same length,
/// and either they are the same map object or their corresponding keys
/// (matched using Go equality) map to deeply equal values.
/// 
/// Pointer values are deeply equal if they are equal using Go's == operator
/// or if they point to deeply equal values.
/// 
/// Slice values are deeply equal when all of the following are true:
/// they are both nil or both non-nil, they have the same length,
/// and either they point to the same initial entry of the same underlying array
/// (that is, &x[0] == &y[0]) or their corresponding elements (up to length) are deeply equal.
/// Note that a non-nil empty slice and a nil slice (for example, []byte{} and []byte(nil))
/// are not deeply equal.
/// 
/// Other values - numbers, bools, strings, and channels - are deeply equal
/// if they are equal using Go's == operator.
/// 
/// In general DeepEqual is a recursive relaxation of Go's == operator.
/// However, this idea is impossible to implement without some inconsistency.
/// Specifically, it is possible for a value to be unequal to itself,
/// either because it is of func type (uncomparable in general)
/// or because it is a floating-point NaN value (not equal to itself in floating-point comparison),
/// or because it is an array, struct, or interface containing
/// such a value.
/// On the other hand, pointer values are always equal to themselves,
/// even if they point at or contain such problematic values,
/// because they compare equal using Go's == operator, and that
/// is a sufficient condition to be deeply equal, regardless of content.
/// DeepEqual has been defined so that the same short-cut applies
/// to slices and maps: if x and y are the same slice or the same map,
/// they are deeply equal regardless of content.
/// 
/// As DeepEqual traverses the data values it may find a cycle. The
/// second and subsequent times that DeepEqual compares two pointer
/// values that have been compared before, it treats the values as
/// equal rather than examining the values to which they point.
/// This ensures that DeepEqual terminates.
pub fn DeepEqual(x: Unknown, y: Unknown) -> bool

/// FuncOf returns the function type with the given argument and result types.
/// For example if k represents int and e represents string,
/// FuncOf([]Type{k}, []Type{e}, false) represents func(int) string.
/// 
/// The variadic argument controls whether the function is variadic. FuncOf
/// panics if the in[len(in)-1] does not represent a slice and variadic is
/// true.
pub fn FuncOf(in_: Slice<Type>, out: Slice<Type>, variadic: bool) -> Type

/// Indirect returns the value that v points to.
/// If v is a nil pointer, Indirect returns a zero Value.
/// If v is not a pointer, Indirect returns v.
pub fn Indirect(v: Value) -> Value

/// MakeChan creates a new channel with the specified type and buffer size.
pub fn MakeChan(typ: Type, buffer: int) -> Value

/// MakeFunc returns a new function of the given [Type]
/// that wraps the function fn. When called, that new function
/// does the following:
/// 
///   - converts its arguments to a slice of Values.
///   - runs results := fn(args).
///   - returns the results as a slice of Values, one per formal result.
/// 
/// The implementation fn can assume that the argument [Value] slice
/// has the number and type of arguments given by typ.
/// If typ describes a variadic function, the final Value is itself
/// a slice representing the variadic arguments, as in the
/// body of a variadic function. The result Value slice returned by fn
/// must have the number and type of results given by typ.
/// 
/// The [Value.Call] method allows the caller to invoke a typed function
/// in terms of Values; in contrast, MakeFunc allows the caller to implement
/// a typed function in terms of Values.
/// 
/// The Examples section of the documentation includes an illustration
/// of how to use MakeFunc to build a swap function for different types.
pub fn MakeFunc(typ: Type, fn_: fn(Slice<Value>) -> Slice<Value>) -> Value

/// MakeMap creates a new map with the specified type.
pub fn MakeMap(typ: Type) -> Value

/// MakeMapWithSize creates a new map with the specified type
/// and initial space for approximately n elements.
pub fn MakeMapWithSize(typ: Type, n: int) -> Value

/// MakeSlice creates a new zero-initialized slice value
/// for the specified slice type, length, and capacity.
pub fn MakeSlice(typ: Type, len: int, cap: int) -> Value

/// MapOf returns the map type with the given key and element types.
/// For example, if k represents int and e represents string,
/// MapOf(k, e) represents map[int]string.
/// 
/// If the key type is not a valid map key type (that is, if it does
/// not implement Go's == operator), MapOf panics.
pub fn MapOf(key: Type, elem: Type) -> Type

/// New returns a Value representing a pointer to a new zero value
/// for the specified type. That is, the returned Value's Type is [PointerTo](typ).
pub fn New(typ: Type) -> Value

/// NewAt returns a Value representing a pointer to a value of the
/// specified type, using p as that pointer.
pub fn NewAt(typ: Type, p: Unknown) -> Value

/// PointerTo returns the pointer type with element t.
/// For example, if t represents type Foo, PointerTo(t) represents *Foo.
pub fn PointerTo(t: Type) -> Type

/// PtrTo returns the pointer type with element t.
/// For example, if t represents type Foo, PtrTo(t) represents *Foo.
/// 
/// PtrTo is the old spelling of [PointerTo].
/// The two functions behave identically.
/// 
/// Deprecated: Superseded by [PointerTo].
pub fn PtrTo(t: Type) -> Type

/// Select executes a select operation described by the list of cases.
/// Like the Go select statement, it blocks until at least one of the cases
/// can proceed, makes a uniform pseudo-random choice,
/// and then executes that case. It returns the index of the chosen case
/// and, if that case was a receive operation, the value received and a
/// boolean indicating whether the value corresponds to a send on the channel
/// (as opposed to a zero value received because the channel is closed).
/// Select supports a maximum of 65536 cases.
pub fn Select(cases: Slice<SelectCase>) -> (int, Value, bool)

/// SliceAt returns a [Value] representing a slice whose underlying
/// data starts at p, with length and capacity equal to n.
/// 
/// This is like [unsafe.Slice].
pub fn SliceAt(typ: Type, p: Unknown, n: int) -> Value

/// SliceOf returns the slice type with element type t.
/// For example, if t represents int, SliceOf(t) represents []int.
pub fn SliceOf(t: Type) -> Type

/// StructOf returns the struct type containing fields.
/// The Offset and Index fields are ignored and computed as they would be
/// by the compiler.
/// 
/// StructOf currently does not support promoted methods of embedded fields
/// and panics if passed unexported StructFields.
pub fn StructOf(fields: Slice<StructField>) -> Type

/// Swapper returns a function that swaps the elements in the provided
/// slice.
/// 
/// Swapper panics if the provided interface is not a slice.
pub fn Swapper(slice: Unknown) -> Option<fn(int, int) -> ()>

/// TypeAssert is semantically equivalent to:
/// 
/// 	v2, ok := v.Interface().(T)
pub fn TypeAssert<T>(v: Value) -> Option<T>

/// TypeFor returns the [Type] that represents the type argument T.
pub fn TypeFor<T>() -> Type

/// TypeOf returns the reflection [Type] that represents the dynamic type of i.
/// If i is a nil interface value, TypeOf returns nil.
pub fn TypeOf(i: Unknown) -> Option<Type>

/// ValueOf returns a new Value initialized to the concrete value
/// stored in the interface i. ValueOf(nil) returns the zero Value.
pub fn ValueOf(i: Unknown) -> Value

/// VisibleFields returns all the visible fields in t, which must be a
/// struct type. A field is defined as visible if it's accessible
/// directly with a FieldByName call. The returned fields include fields
/// inside anonymous struct members and unexported fields. They follow
/// the same order found in the struct, with anonymous fields followed
/// immediately by their promoted fields.
/// 
/// For each element e of the returned slice, the corresponding field
/// can be retrieved from a value v of type t by calling v.FieldByIndex(e.Index).
pub fn VisibleFields(t: Type) -> Slice<StructField>

/// Zero returns a Value representing the zero value for the specified type.
/// The result is different from the zero value of the Value struct,
/// which represents no value at all.
/// For example, Zero(TypeOf(42)) returns a Value with Kind [Int] and value 0.
/// The returned value is neither addressable nor settable.
pub fn Zero(typ: Type) -> Value

/// A MapIter is an iterator for ranging over a map.
/// See [Value.MapRange].
pub type MapIter

/// Method represents a single method.
pub struct Method {
  pub Name: string,
  pub PkgPath: string,
  pub Type: Option<Type>,
  pub Func: Value,
  pub Index: int,
}

/// A SelectCase describes a single case in a select operation.
/// The kind of case depends on Dir, the communication direction.
/// 
/// If Dir is SelectDefault, the case represents a default case.
/// Chan and Send must be zero Values.
/// 
/// If Dir is SelectSend, the case represents a send operation.
/// Normally Chan's underlying value must be a channel, and Send's underlying value must be
/// assignable to the channel's element type. As a special case, if Chan is a zero Value,
/// then the case is ignored, and the field Send will also be ignored and may be either zero
/// or non-zero.
/// 
/// If Dir is [SelectRecv], the case represents a receive operation.
/// Normally Chan's underlying value must be a channel and Send must be a zero Value.
/// If Chan is a zero Value, then the case is ignored, but Send must still be a zero Value.
/// When a receive operation is selected, the received Value is returned by Select.
pub struct SelectCase {
  pub Dir: SelectDir,
  pub Chan: Value,
  pub Send: Value,
}

/// SliceHeader is the runtime representation of a slice.
/// It cannot be used safely or portably and its representation may
/// change in a later release.
/// Moreover, the Data field is not sufficient to guarantee the data
/// it references will not be garbage collected, so programs must keep
/// a separate, correctly typed pointer to the underlying data.
/// 
/// Deprecated: Use unsafe.Slice or unsafe.SliceData instead.
pub struct SliceHeader {
  pub Data: uint,
  pub Len: int,
  pub Cap: int,
}

/// StringHeader is the runtime representation of a string.
/// It cannot be used safely or portably and its representation may
/// change in a later release.
/// Moreover, the Data field is not sufficient to guarantee the data
/// it references will not be garbage collected, so programs must keep
/// a separate, correctly typed pointer to the underlying data.
/// 
/// Deprecated: Use unsafe.String or unsafe.StringData instead.
pub struct StringHeader {
  pub Data: uint,
  pub Len: int,
}

/// A StructField describes a single field in a struct.
pub struct StructField {
  pub Name: string,
  pub PkgPath: string,
  pub Type: Option<Type>,
  pub Tag: StructTag,
  pub Offset: uint,
  pub Index: Slice<int>,
  pub Anonymous: bool,
}

/// A StructTag is the tag string in a struct field.
/// 
/// By convention, tag strings are a concatenation of
/// optionally space-separated key:"value" pairs.
/// Each key is a non-empty string consisting of non-control
/// characters other than space (U+0020 ' '), quote (U+0022 '"'),
/// and colon (U+003A ':').  Each value is quoted using U+0022 '"'
/// characters and Go string literal syntax.
pub struct StructTag(string)

/// Type is the representation of a Go type.
/// 
/// Not all methods apply to all kinds of types. Restrictions,
/// if any, are noted in the documentation for each method.
/// Use the Kind method to find out the kind of type before
/// calling kind-specific methods. Calling a method
/// inappropriate to the kind of type causes a run-time panic.
/// 
/// Type values are comparable, such as with the == operator,
/// so they can be used as map keys.
/// Two Type values are equal if they represent identical types.
pub interface Type {
  fn Align() -> int
  fn AssignableTo(u: Type) -> bool
  fn Bits() -> int
  fn CanSeq() -> bool
  fn CanSeq2() -> bool
  fn ChanDir() -> ChanDir
  fn Comparable() -> bool
  fn ConvertibleTo(u: Type) -> bool
  fn Elem() -> Option<Type>
  fn Field(i: int) -> StructField
  fn FieldAlign() -> int
  fn FieldByIndex(index: Slice<int>) -> StructField
  fn FieldByName(name: string) -> Option<StructField>
  fn FieldByNameFunc(match_: fn(string) -> bool) -> Option<StructField>
  fn Implements(u: Type) -> bool
  fn In(i: int) -> Option<Type>
  fn IsVariadic() -> bool
  fn Key() -> Option<Type>
  fn Kind() -> Kind
  fn Len() -> int
  fn Method(n: int) -> Method
  fn MethodByName(s: string) -> Option<Method>
  fn Name() -> string
  fn NumField() -> int
  fn NumIn() -> int
  fn NumMethod() -> int
  fn NumOut() -> int
  fn Out(i: int) -> Option<Type>
  fn OverflowComplex(x: complex128) -> bool
  fn OverflowFloat(x: float64) -> bool
  fn OverflowInt(x: int64) -> bool
  fn OverflowUint(x: uint64) -> bool
  fn PkgPath() -> string
  fn Size() -> uint
  fn String() -> string
}

/// Value is the reflection interface to a Go value.
/// 
/// Not all methods apply to all kinds of values. Restrictions,
/// if any, are noted in the documentation for each method.
/// Use the Kind method to find out the kind of value before
/// calling kind-specific methods. Calling a method
/// inappropriate to the kind of type causes a run time panic.
/// 
/// The zero Value represents no value.
/// Its [Value.IsValid] method returns false, its Kind method returns [Invalid],
/// its String method returns "<invalid Value>", and all other methods panic.
/// Most functions and methods never return an invalid value.
/// If one does, its documentation states the conditions explicitly.
/// 
/// A Value can be used concurrently by multiple goroutines provided that
/// the underlying Go value can be used concurrently for the equivalent
/// direct operations.
/// 
/// To compare two Values, compare the results of the Interface method.
/// Using == on two Values does not compare the underlying values
/// they represent.
pub type Value

/// A ValueError occurs when a Value method is invoked on
/// a [Value] that does not support it. Such cases are documented
/// in the description of each method.
pub struct ValueError {
  pub Method: string,
  pub Kind: Kind,
}

impl ChanDir {
  fn String(self) -> string
}

impl Kind {
  /// String returns the name of k.
  fn String(self) -> string
}

impl MapIter {
  /// Key returns the key of iter's current map entry.
  fn Key(self: Ref<MapIter>) -> Value

  /// Next advances the map iterator and reports whether there is another
  /// entry. It returns false when iter is exhausted; subsequent
  /// calls to [MapIter.Key], [MapIter.Value], or [MapIter.Next] will panic.
  fn Next(self: Ref<MapIter>) -> bool

  /// Reset modifies iter to iterate over v.
  /// It panics if v's Kind is not [Map] and v is not the zero Value.
  /// Reset(Value{}) causes iter to not to refer to any map,
  /// which may allow the previously iterated-over map to be garbage collected.
  fn Reset(self: Ref<MapIter>, v: Value)

  /// Value returns the value of iter's current map entry.
  fn Value(self: Ref<MapIter>) -> Value
}

impl Method {
  /// IsExported reports whether the method is exported.
  fn IsExported(self) -> bool
}

impl StructField {
  /// IsExported reports whether the field is exported.
  fn IsExported(self) -> bool
}

impl StructTag {
  /// Get returns the value associated with key in the tag string.
  /// If there is no such key in the tag, Get returns the empty string.
  /// If the tag does not have the conventional format, the value
  /// returned by Get is unspecified. To determine whether a tag is
  /// explicitly set to the empty string, use [StructTag.Lookup].
  fn Get(self, key: string) -> string

  /// Lookup returns the value associated with key in the tag string.
  /// If the key is present in the tag the value (which may be empty)
  /// is returned. Otherwise the returned value will be the empty string.
  /// The ok return value reports whether the value was explicitly set in
  /// the tag string. If the tag does not have the conventional format,
  /// the value returned by Lookup is unspecified.
  fn Lookup(self, key: string) -> Option<string>
}

impl Value {
  /// Addr returns a pointer value representing the address of v.
  /// It panics if [Value.CanAddr] returns false.
  /// Addr is typically used to obtain a pointer to a struct field
  /// or slice element in order to call a method that requires a
  /// pointer receiver.
  fn Addr(self) -> Value

  /// Bool returns v's underlying value.
  /// It panics if v's kind is not [Bool].
  fn Bool(self) -> bool

  /// Bytes returns v's underlying value.
  /// It panics if v's underlying value is not a slice of bytes or
  /// an addressable array of bytes.
  fn Bytes(self) -> Slice<byte>

  /// Call calls the function v with the input arguments in.
  /// For example, if len(in) == 3, v.Call(in) represents the Go call v(in[0], in[1], in[2]).
  /// Call panics if v's Kind is not [Func].
  /// It returns the output results as Values.
  /// As in Go, each input argument must be assignable to the
  /// type of the function's corresponding input parameter.
  /// If v is a variadic function, Call creates the variadic slice parameter
  /// itself, copying in the corresponding values.
  fn Call(self, in_: Slice<Value>) -> Slice<Value>

  /// CallSlice calls the variadic function v with the input arguments in,
  /// assigning the slice in[len(in)-1] to v's final variadic argument.
  /// For example, if len(in) == 3, v.CallSlice(in) represents the Go call v(in[0], in[1], in[2]...).
  /// CallSlice panics if v's Kind is not [Func] or if v is not variadic.
  /// It returns the output results as Values.
  /// As in Go, each input argument must be assignable to the
  /// type of the function's corresponding input parameter.
  fn CallSlice(self, in_: Slice<Value>) -> Slice<Value>

  /// CanAddr reports whether the value's address can be obtained with [Value.Addr].
  /// Such values are called addressable. A value is addressable if it is
  /// an element of a slice, an element of an addressable array,
  /// a field of an addressable struct, or the result of dereferencing a pointer.
  /// If CanAddr returns false, calling [Value.Addr] will panic.
  fn CanAddr(self) -> bool

  /// CanComplex reports whether [Value.Complex] can be used without panicking.
  fn CanComplex(self) -> bool

  /// CanConvert reports whether the value v can be converted to type t.
  /// If v.CanConvert(t) returns true then v.Convert(t) will not panic.
  fn CanConvert(self, t: Type) -> bool

  /// CanFloat reports whether [Value.Float] can be used without panicking.
  fn CanFloat(self) -> bool

  /// CanInt reports whether Int can be used without panicking.
  fn CanInt(self) -> bool

  /// CanInterface reports whether [Value.Interface] can be used without panicking.
  fn CanInterface(self) -> bool

  /// CanSet reports whether the value of v can be changed.
  /// A [Value] can be changed only if it is addressable and was not
  /// obtained by the use of unexported struct fields.
  /// If CanSet returns false, calling [Value.Set] or any type-specific
  /// setter (e.g., [Value.SetBool], [Value.SetInt]) will panic.
  fn CanSet(self) -> bool

  /// CanUint reports whether [Value.Uint] can be used without panicking.
  fn CanUint(self) -> bool

  /// Cap returns v's capacity.
  /// It panics if v's Kind is not [Array], [Chan], [Slice] or pointer to [Array].
  fn Cap(self) -> int

  /// Clear clears the contents of a map or zeros the contents of a slice.
  /// 
  /// It panics if v's Kind is not [Map] or [Slice].
  fn Clear(self)

  /// Close closes the channel v.
  /// It panics if v's Kind is not [Chan] or
  /// v is a receive-only channel.
  fn Close(self)

  /// Comparable reports whether the value v is comparable.
  /// If the type of v is an interface, this checks the dynamic type.
  /// If this reports true then v.Interface() == x will not panic for any x,
  /// nor will v.Equal(u) for any Value u.
  fn Comparable(self) -> bool

  /// Complex returns v's underlying value, as a complex128.
  /// It panics if v's Kind is not [Complex64] or [Complex128]
  fn Complex(self) -> complex128

  /// Convert returns the value v converted to type t.
  /// If the usual Go conversion rules do not allow conversion
  /// of the value v to type t, or if converting v to type t panics, Convert panics.
  fn Convert(self, t: Type) -> Value

  /// Elem returns the value that the interface v contains
  /// or that the pointer v points to.
  /// It panics if v's Kind is not [Interface] or [Pointer].
  /// It returns the zero Value if v is nil.
  fn Elem(self) -> Value

  /// Equal reports true if v is equal to u.
  /// For two invalid values, Equal will report true.
  /// For an interface value, Equal will compare the value within the interface.
  /// Otherwise, If the values have different types, Equal will report false.
  /// Otherwise, for arrays and structs Equal will compare each element in order,
  /// and report false if it finds non-equal elements.
  /// During all comparisons, if values of the same type are compared,
  /// and the type is not comparable, Equal will panic.
  fn Equal(self, u: Value) -> bool

  /// Field returns the i'th field of the struct v.
  /// It panics if v's Kind is not [Struct] or i is out of range.
  fn Field(self, i: int) -> Value

  /// FieldByIndex returns the nested field corresponding to index.
  /// It panics if evaluation requires stepping through a nil
  /// pointer or a field that is not a struct.
  fn FieldByIndex(self, index: Slice<int>) -> Value

  /// FieldByIndexErr returns the nested field corresponding to index.
  /// It returns an error if evaluation requires stepping through a nil
  /// pointer, but panics if it must step through a field that
  /// is not a struct.
  fn FieldByIndexErr(self, index: Slice<int>) -> Result<Value, error>

  /// FieldByName returns the struct field with the given name.
  /// It returns the zero Value if no field was found.
  /// It panics if v's Kind is not [Struct].
  fn FieldByName(self, name: string) -> Value

  /// FieldByNameFunc returns the struct field with a name
  /// that satisfies the match function.
  /// It panics if v's Kind is not [Struct].
  /// It returns the zero Value if no field was found.
  fn FieldByNameFunc(self, match_: fn(string) -> bool) -> Value

  /// Float returns v's underlying value, as a float64.
  /// It panics if v's Kind is not [Float32] or [Float64]
  fn Float(self) -> float64

  /// Grow increases the slice's capacity, if necessary, to guarantee space for
  /// another n elements. After Grow(n), at least n elements can be appended
  /// to the slice without another allocation.
  /// 
  /// It panics if v's Kind is not a [Slice], or if n is negative or too large to
  /// allocate the memory, or if [Value.CanSet] returns false.
  fn Grow(self, n: int)

  /// Index returns v's i'th element.
  /// It panics if v's Kind is not [Array], [Slice], or [String] or i is out of range.
  fn Index(self, i: int) -> Value

  /// Int returns v's underlying value, as an int64.
  /// It panics if v's Kind is not [Int], [Int8], [Int16], [Int32], or [Int64].
  fn Int(self) -> int64

  /// Interface returns v's current value as an interface{}.
  /// It is equivalent to:
  /// 
  /// 	var i interface{} = (v's underlying value)
  /// 
  /// It panics if the Value was obtained by accessing
  /// unexported struct fields.
  fn Interface(self) -> Unknown

  /// InterfaceData returns a pair of unspecified uintptr values.
  /// It panics if v's Kind is not Interface.
  /// 
  /// In earlier versions of Go, this function returned the interface's
  /// value as a uintptr pair. As of Go 1.4, the implementation of
  /// interface values precludes any defined use of InterfaceData.
  /// 
  /// Deprecated: The memory representation of interface values is not
  /// compatible with InterfaceData.
  #[go(array_return)]
  fn InterfaceData(self) -> Slice<uint>

  /// IsNil reports whether its argument v is nil. The argument must be
  /// a chan, func, interface, map, pointer, or slice value; if it is
  /// not, IsNil panics. Note that IsNil is not always equivalent to a
  /// regular comparison with nil in Go. For example, if v was created
  /// by calling [ValueOf] with an uninitialized interface variable i,
  /// i==nil will be true but v.IsNil will panic as v will be the zero
  /// Value.
  fn IsNil(self) -> bool

  /// IsValid reports whether v represents a value.
  /// It returns false if v is the zero Value.
  /// If [Value.IsValid] returns false, all other methods except String panic.
  /// Most functions and methods never return an invalid Value.
  /// If one does, its documentation states the conditions explicitly.
  fn IsValid(self) -> bool

  /// IsZero reports whether v is the zero value for its type.
  /// It panics if the argument is invalid.
  fn IsZero(self) -> bool

  /// Kind returns v's Kind.
  /// If v is the zero Value ([Value.IsValid] returns false), Kind returns Invalid.
  fn Kind(self) -> Kind

  /// Len returns v's length.
  /// It panics if v's Kind is not [Array], [Chan], [Map], [Slice], [String], or pointer to [Array].
  fn Len(self) -> int

  /// MapIndex returns the value associated with key in the map v.
  /// It panics if v's Kind is not [Map].
  /// It returns the zero Value if key is not found in the map or if v represents a nil map.
  /// As in Go, the key's value must be assignable to the map's key type.
  fn MapIndex(self, key: Value) -> Value

  /// MapKeys returns a slice containing all the keys present in the map,
  /// in unspecified order.
  /// It panics if v's Kind is not [Map].
  /// It returns an empty slice if v represents a nil map.
  fn MapKeys(self) -> Slice<Value>

  /// MapRange returns a range iterator for a map.
  /// It panics if v's Kind is not [Map].
  /// 
  /// Call [MapIter.Next] to advance the iterator, and [MapIter.Key]/[MapIter.Value] to access each entry.
  /// [MapIter.Next] returns false when the iterator is exhausted.
  /// MapRange follows the same iteration semantics as a range statement.
  /// 
  /// Example:
  /// 
  /// 	iter := reflect.ValueOf(m).MapRange()
  /// 	for iter.Next() {
  /// 		k := iter.Key()
  /// 		v := iter.Value()
  /// 		...
  /// 	}
  fn MapRange(self) -> Ref<MapIter>

  /// Method returns a function value corresponding to v's i'th method.
  /// The arguments to a Call on the returned function should not include
  /// a receiver; the returned function will always use v as the receiver.
  /// Method panics if i is out of range or if v is a nil interface value.
  /// 
  /// Calling this method will force the linker to retain all exported methods in all packages.
  /// This may make the executable binary larger but will not affect execution time.
  fn Method(self, i: int) -> Value

  /// MethodByName returns a function value corresponding to the method
  /// of v with the given name.
  /// The arguments to a Call on the returned function should not include
  /// a receiver; the returned function will always use v as the receiver.
  /// It returns the zero Value if no method was found.
  /// 
  /// Calling this method will cause the linker to retain all methods with this name in all packages.
  /// If the linker can't determine the name, it will retain all exported methods.
  /// This may make the executable binary larger but will not affect execution time.
  fn MethodByName(self, name: string) -> Value

  /// NumField returns the number of fields in the struct v.
  /// It panics if v's Kind is not [Struct].
  fn NumField(self) -> int

  /// NumMethod returns the number of methods in the value's method set.
  /// 
  /// For a non-interface type, it returns the number of exported methods.
  /// 
  /// For an interface type, it returns the number of exported and unexported methods.
  fn NumMethod(self) -> int

  /// OverflowComplex reports whether the complex128 x cannot be represented by v's type.
  /// It panics if v's Kind is not [Complex64] or [Complex128].
  fn OverflowComplex(self, x: complex128) -> bool

  /// OverflowFloat reports whether the float64 x cannot be represented by v's type.
  /// It panics if v's Kind is not [Float32] or [Float64].
  fn OverflowFloat(self, x: float64) -> bool

  /// OverflowInt reports whether the int64 x cannot be represented by v's type.
  /// It panics if v's Kind is not [Int], [Int8], [Int16], [Int32], or [Int64].
  fn OverflowInt(self, x: int64) -> bool

  /// OverflowUint reports whether the uint64 x cannot be represented by v's type.
  /// It panics if v's Kind is not [Uint], [Uintptr], [Uint8], [Uint16], [Uint32], or [Uint64].
  fn OverflowUint(self, x: uint64) -> bool

  /// Pointer returns v's value as a uintptr.
  /// It panics if v's Kind is not [Chan], [Func], [Map], [Pointer], [Slice], [String], or [UnsafePointer].
  /// 
  /// If v's Kind is [Func], the returned pointer is an underlying
  /// code pointer, but not necessarily enough to identify a
  /// single function uniquely. The only guarantee is that the
  /// result is zero if and only if v is a nil func Value.
  /// 
  /// If v's Kind is [Slice], the returned pointer is to the first
  /// element of the slice. If the slice is nil the returned value
  /// is 0.  If the slice is empty but non-nil the return value is non-zero.
  /// 
  /// If v's Kind is [String], the returned pointer is to the first
  /// element of the underlying bytes of string.
  /// 
  /// It's preferred to use uintptr(Value.UnsafePointer()) to get the equivalent result.
  fn Pointer(self) -> uint

  /// Recv receives and returns a value from the channel v.
  /// It panics if v's Kind is not [Chan].
  /// The receive blocks until a value is ready.
  /// The boolean value ok is true if the value x corresponds to a send
  /// on the channel, false if it is a zero value received because the channel is closed.
  fn Recv(self) -> Option<Value>

  /// Send sends x on the channel v.
  /// It panics if v's kind is not [Chan] or if x's type is not the same type as v's element type.
  /// As in Go, x's value must be assignable to the channel's element type.
  fn Send(self, x: Value)

  /// Seq returns an iter.Seq[Value] that loops over the elements of v.
  /// If v's kind is Func, it must be a function that has no results and
  /// that takes a single argument of type func(T) bool for some type T.
  /// If v's kind is Pointer, the pointer element type must have kind Array.
  /// Otherwise v's kind must be Int, Int8, Int16, Int32, Int64,
  /// Uint, Uint8, Uint16, Uint32, Uint64, Uintptr,
  /// Array, Chan, Map, Slice, or String.
  fn Seq(self) -> iter.Seq<Value>

  /// Seq2 returns an iter.Seq2[Value, Value] that loops over the elements of v.
  /// If v's kind is Func, it must be a function that has no results and
  /// that takes a single argument of type func(K, V) bool for some type K, V.
  /// If v's kind is Pointer, the pointer element type must have kind Array.
  /// Otherwise v's kind must be Array, Map, Slice, or String.
  fn Seq2(self) -> iter.Seq2<Value, Value>

  /// Set assigns x to the value v.
  /// It panics if [Value.CanSet] returns false.
  /// As in Go, x's value must be assignable to v's type and
  /// must not be derived from an unexported field.
  fn Set(self, x: Value)

  /// SetBool sets v's underlying value.
  /// It panics if v's Kind is not [Bool] or if [Value.CanSet] returns false.
  fn SetBool(self, x: bool)

  /// SetBytes sets v's underlying value.
  /// It panics if v's underlying value is not a slice of bytes
  /// or if [Value.CanSet] returns false.
  fn SetBytes(self, x: Slice<byte>)

  /// SetCap sets v's capacity to n.
  /// It panics if v's Kind is not [Slice], or if n is smaller than the length or
  /// greater than the capacity of the slice,
  /// or if [Value.CanSet] returns false.
  fn SetCap(self, n: int)

  /// SetComplex sets v's underlying value to x.
  /// It panics if v's Kind is not [Complex64] or [Complex128],
  /// or if [Value.CanSet] returns false.
  fn SetComplex(self, x: complex128)

  /// SetFloat sets v's underlying value to x.
  /// It panics if v's Kind is not [Float32] or [Float64],
  /// or if [Value.CanSet] returns false.
  fn SetFloat(self, x: float64)

  /// SetInt sets v's underlying value to x.
  /// It panics if v's Kind is not [Int], [Int8], [Int16], [Int32], or [Int64],
  /// or if [Value.CanSet] returns false.
  fn SetInt(self, x: int64)

  /// SetIterKey assigns to v the key of iter's current map entry.
  /// It is equivalent to v.Set(iter.Key()), but it avoids allocating a new Value.
  /// As in Go, the key must be assignable to v's type and
  /// must not be derived from an unexported field.
  /// It panics if [Value.CanSet] returns false.
  fn SetIterKey(self, iter: Ref<MapIter>)

  /// SetIterValue assigns to v the value of iter's current map entry.
  /// It is equivalent to v.Set(iter.Value()), but it avoids allocating a new Value.
  /// As in Go, the value must be assignable to v's type and
  /// must not be derived from an unexported field.
  /// It panics if [Value.CanSet] returns false.
  fn SetIterValue(self, iter: Ref<MapIter>)

  /// SetLen sets v's length to n.
  /// It panics if v's Kind is not [Slice], or if n is negative or
  /// greater than the capacity of the slice,
  /// or if [Value.CanSet] returns false.
  fn SetLen(self, n: int)

  /// SetMapIndex sets the element associated with key in the map v to elem.
  /// It panics if v's Kind is not [Map].
  /// If elem is the zero Value, SetMapIndex deletes the key from the map.
  /// Otherwise if v holds a nil map, SetMapIndex will panic.
  /// As in Go, key's elem must be assignable to the map's key type,
  /// and elem's value must be assignable to the map's elem type.
  fn SetMapIndex(self, key: Value, elem: Value)

  /// SetPointer sets the [unsafe.Pointer] value v to x.
  /// It panics if v's Kind is not [UnsafePointer]
  /// or if [Value.CanSet] returns false.
  fn SetPointer(self, x: Unknown)

  /// SetString sets v's underlying value to x.
  /// It panics if v's Kind is not [String] or if [Value.CanSet] returns false.
  fn SetString(self, x: string)

  /// SetUint sets v's underlying value to x.
  /// It panics if v's Kind is not [Uint], [Uintptr], [Uint8], [Uint16], [Uint32], or [Uint64],
  /// or if [Value.CanSet] returns false.
  fn SetUint(self, x: uint64)

  /// SetZero sets v to be the zero value of v's type.
  /// It panics if [Value.CanSet] returns false.
  fn SetZero(self)

  /// Slice returns v[i:j].
  /// It panics if v's Kind is not [Array], [Slice] or [String], or if v is an unaddressable array,
  /// or if the indexes are out of bounds.
  fn Slice(self, i: int, j: int) -> Value

  /// Slice3 is the 3-index form of the slice operation: it returns v[i:j:k].
  /// It panics if v's Kind is not [Array] or [Slice], or if v is an unaddressable array,
  /// or if the indexes are out of bounds.
  fn Slice3(self, i: int, j: int, k: int) -> Value

  /// String returns the string v's underlying value, as a string.
  /// String is a special case because of Go's String method convention.
  /// Unlike the other getters, it does not panic if v's Kind is not [String].
  /// Instead, it returns a string of the form "<T value>" where T is v's type.
  /// The fmt package treats Values specially. It does not call their String
  /// method implicitly but instead prints the concrete values they hold.
  fn String(self) -> string

  /// TryRecv attempts to receive a value from the channel v but will not block.
  /// It panics if v's Kind is not [Chan].
  /// If the receive delivers a value, x is the transferred value and ok is true.
  /// If the receive cannot finish without blocking, x is the zero Value and ok is false.
  /// If the channel is closed, x is the zero value for the channel's element type and ok is false.
  fn TryRecv(self) -> Option<Value>

  /// TrySend attempts to send x on the channel v but will not block.
  /// It panics if v's Kind is not [Chan].
  /// It reports whether the value was sent.
  /// As in Go, x's value must be assignable to the channel's element type.
  fn TrySend(self, x: Value) -> bool

  /// Type returns v's type.
  fn Type(self) -> Type

  /// Uint returns v's underlying value, as a uint64.
  /// It panics if v's Kind is not [Uint], [Uintptr], [Uint8], [Uint16], [Uint32], or [Uint64].
  fn Uint(self) -> uint64

  /// UnsafeAddr returns a pointer to v's data, as a uintptr.
  /// It panics if v is not addressable.
  /// 
  /// It's preferred to use uintptr(Value.Addr().UnsafePointer()) to get the equivalent result.
  fn UnsafeAddr(self) -> uint

  /// UnsafePointer returns v's value as a [unsafe.Pointer].
  /// It panics if v's Kind is not [Chan], [Func], [Map], [Pointer], [Slice], [String] or [UnsafePointer].
  /// 
  /// If v's Kind is [Func], the returned pointer is an underlying
  /// code pointer, but not necessarily enough to identify a
  /// single function uniquely. The only guarantee is that the
  /// result is zero if and only if v is a nil func Value.
  /// 
  /// If v's Kind is [Slice], the returned pointer is to the first
  /// element of the slice. If the slice is nil the returned value
  /// is nil.  If the slice is empty but non-nil the return value is non-nil.
  /// 
  /// If v's Kind is [String], the returned pointer is to the first
  /// element of the underlying bytes of string.
  fn UnsafePointer(self) -> Unknown
}

impl ValueError {
  fn Error(self: Ref<ValueError>) -> string
}
