// Generated by Lisette bindgen
// Source: go/constant (Go stdlib)
// Go: 1.25.5
// Lisette: 0.1.11

import "go:go/token"

pub enum Kind: int {
  Bool = 1,
  Complex = 5,
  Float = 4,
  Int = 3,
  String = 2,
  Unknown = 0,
}

pub const Bool: Kind = 1

pub const Complex: Kind = 5

pub const Float: Kind = 4

pub const Int: Kind = 3

pub const String: Kind = 2

pub const Unknown: Kind = 0

pub fn BinaryOp(x_: Value, op: token.Token, y_: Value) -> Value

/// BitLen returns the number of bits required to represent
/// the absolute value x in binary representation; x must be an [Int] or an [Unknown].
/// If x is [Unknown], the result is 0.
pub fn BitLen(x: Value) -> int

/// BoolVal returns the Go boolean value of x, which must be a [Bool] or an [Unknown].
/// If x is [Unknown], the result is false.
pub fn BoolVal(x: Value) -> bool

/// Bytes returns the bytes for the absolute value of x in little-
/// endian binary representation; x must be an [Int].
pub fn Bytes(x: Value) -> Slice<uint8>

/// Compare returns the result of the comparison x op y.
/// The comparison must be defined for the operands.
/// If one of the operands is [Unknown], the result is
/// false.
pub fn Compare(x_: Value, op: token.Token, y_: Value) -> bool

pub fn Denom(x: Value) -> Value

/// Float32Val is like [Float64Val] but for float32 instead of float64.
pub fn Float32Val(x: Value) -> (float32, bool)

/// Float64Val returns the nearest Go float64 value of x and whether the result is exact;
/// x must be numeric or an [Unknown], but not [Complex]. For values too small (too close to 0)
/// to represent as float64, [Float64Val] silently underflows to 0. The result sign always
/// matches the sign of x, even for 0.
/// If x is [Unknown], the result is (0, false).
pub fn Float64Val(x: Value) -> (float64, bool)

pub fn Imag(x: Value) -> Value

/// Int64Val returns the Go int64 value of x and whether the result is exact;
/// x must be an [Int] or an [Unknown]. If the result is not exact, its value is undefined.
/// If x is [Unknown], the result is (0, false).
pub fn Int64Val(x: Value) -> (int64, bool)

pub fn Make(x: Unknown) -> Value

pub fn MakeBool(b: bool) -> Value

pub fn MakeFloat64(x: float64) -> Value

pub fn MakeFromBytes(bytes: Slice<uint8>) -> Value

pub fn MakeFromLiteral(lit: string, tok: token.Token, zero: uint) -> Value

pub fn MakeImag(x: Value) -> Value

pub fn MakeInt64(x: int64) -> Value

pub fn MakeString(s: string) -> Value

pub fn MakeUint64(x: uint64) -> Value

pub fn MakeUnknown() -> Value

pub fn Num(x: Value) -> Value

pub fn Real(x: Value) -> Value

pub fn Shift(x: Value, op: token.Token, s: uint) -> Value

/// Sign returns -1, 0, or 1 depending on whether x < 0, x == 0, or x > 0;
/// x must be numeric or [Unknown]. For complex values x, the sign is 0 if x == 0,
/// otherwise it is != 0. If x is [Unknown], the result is 1.
pub fn Sign(x: Value) -> int

/// StringVal returns the Go string value of x, which must be a [String] or an [Unknown].
/// If x is [Unknown], the result is "".
pub fn StringVal(x: Value) -> string

pub fn ToComplex(x: Value) -> Value

pub fn ToFloat(x: Value) -> Value

pub fn ToInt(x: Value) -> Value

/// Uint64Val returns the Go uint64 value of x and whether the result is exact;
/// x must be an [Int] or an [Unknown]. If the result is not exact, its value is undefined.
/// If x is [Unknown], the result is (0, false).
pub fn Uint64Val(x: Value) -> (uint64, bool)

pub fn UnaryOp(op: token.Token, y: Value, prec: uint) -> Value

/// Val returns the underlying value for a given constant. Since it returns an
/// interface, it is up to the caller to type assert the result to the expected
/// type. The possible dynamic return types are:
/// 
/// 	x Kind             type of result
/// 	-----------------------------------------
/// 	Bool               bool
/// 	String             string
/// 	Int                int64 or *big.Int
/// 	Float              *big.Float or *big.Rat
/// 	everything else    nil
pub fn Val(x: Value) -> Unknown

/// A Value represents the value of a Go constant.
pub interface Value {
  fn ExactString() -> string
  fn Kind() -> Kind
  fn String() -> string
}

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