// Generated by Lisette bindgen
// Source: strconv (Go stdlib)
// Go: 1.25.5
// Lisette: 0.1.14

/// AppendBool appends "true" or "false", according to the value of b,
/// to dst and returns the extended buffer.
pub fn AppendBool(mut dst: Slice<uint8>, b: bool) -> Slice<uint8>

/// AppendFloat appends the string form of the floating-point number f,
/// as generated by [FormatFloat], to dst and returns the extended buffer.
pub fn AppendFloat(
  mut dst: Slice<uint8>,
  f: float64,
  fmt: uint8,
  prec: int,
  bitSize: int,
) -> Slice<uint8>

/// AppendInt appends the string form of the integer i,
/// as generated by [FormatInt], to dst and returns the extended buffer.
pub fn AppendInt(mut dst: Slice<uint8>, i: int64, base: int) -> Slice<uint8>

/// AppendQuote appends a double-quoted Go string literal representing s,
/// as generated by [Quote], to dst and returns the extended buffer.
pub fn AppendQuote(mut dst: Slice<uint8>, s: string) -> Slice<uint8>

/// AppendQuoteRune appends a single-quoted Go character literal representing the rune,
/// as generated by [QuoteRune], to dst and returns the extended buffer.
pub fn AppendQuoteRune(mut dst: Slice<uint8>, r: int32) -> Slice<uint8>

/// AppendQuoteRuneToASCII appends a single-quoted Go character literal representing the rune,
/// as generated by [QuoteRuneToASCII], to dst and returns the extended buffer.
pub fn AppendQuoteRuneToASCII(mut dst: Slice<uint8>, r: int32) -> Slice<uint8>

/// AppendQuoteRuneToGraphic appends a single-quoted Go character literal representing the rune,
/// as generated by [QuoteRuneToGraphic], to dst and returns the extended buffer.
pub fn AppendQuoteRuneToGraphic(mut dst: Slice<uint8>, r: int32) -> Slice<uint8>

/// AppendQuoteToASCII appends a double-quoted Go string literal representing s,
/// as generated by [QuoteToASCII], to dst and returns the extended buffer.
pub fn AppendQuoteToASCII(mut dst: Slice<uint8>, s: string) -> Slice<uint8>

/// AppendQuoteToGraphic appends a double-quoted Go string literal representing s,
/// as generated by [QuoteToGraphic], to dst and returns the extended buffer.
pub fn AppendQuoteToGraphic(mut dst: Slice<uint8>, s: string) -> Slice<uint8>

/// AppendUint appends the string form of the unsigned integer i,
/// as generated by [FormatUint], to dst and returns the extended buffer.
pub fn AppendUint(mut dst: Slice<uint8>, i: uint64, base: int) -> Slice<uint8>

/// Atoi is equivalent to ParseInt(s, 10, 0), converted to type int.
pub fn Atoi(s: string) -> Result<int, error>

/// CanBackquote reports whether the string s can be represented
/// unchanged as a single-line backquoted string without control
/// characters other than tab.
pub fn CanBackquote(s: string) -> bool

/// FormatBool returns "true" or "false" according to the value of b.
pub fn FormatBool(b: bool) -> string

/// FormatComplex converts the complex number c to a string of the
/// form (a+bi) where a and b are the real and imaginary parts,
/// formatted according to the format fmt and precision prec.
/// 
/// The format fmt and precision prec have the same meaning as in [FormatFloat].
/// It rounds the result assuming that the original was obtained from a complex
/// value of bitSize bits, which must be 64 for complex64 and 128 for complex128.
pub fn FormatComplex(c: complex128, fmt: uint8, prec: int, bitSize: int) -> string

/// FormatFloat converts the floating-point number f to a string,
/// according to the format fmt and precision prec. It rounds the
/// result assuming that the original was obtained from a floating-point
/// value of bitSize bits (32 for float32, 64 for float64).
/// 
/// The format fmt is one of
///   - 'b' (-ddddp±ddd, a binary exponent),
///   - 'e' (-d.dddde±dd, a decimal exponent),
///   - 'E' (-d.ddddE±dd, a decimal exponent),
///   - 'f' (-ddd.dddd, no exponent),
///   - 'g' ('e' for large exponents, 'f' otherwise),
///   - 'G' ('E' for large exponents, 'f' otherwise),
///   - 'x' (-0xd.ddddp±ddd, a hexadecimal fraction and binary exponent), or
///   - 'X' (-0Xd.ddddP±ddd, a hexadecimal fraction and binary exponent).
/// 
/// The precision prec controls the number of digits (excluding the exponent)
/// printed by the 'e', 'E', 'f', 'g', 'G', 'x', and 'X' formats.
/// For 'e', 'E', 'f', 'x', and 'X', it is the number of digits after the decimal point.
/// For 'g' and 'G' it is the maximum number of significant digits (trailing
/// zeros are removed).
/// The special precision -1 uses the smallest number of digits
/// necessary such that ParseFloat will return f exactly.
/// The exponent is written as a decimal integer;
/// for all formats other than 'b', it will be at least two digits.
pub fn FormatFloat(f: float64, fmt: uint8, prec: int, bitSize: int) -> string

/// FormatInt returns the string representation of i in the given base,
/// for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z'
/// for digit values >= 10.
pub fn FormatInt(i: int64, base: int) -> string

/// FormatUint returns the string representation of i in the given base,
/// for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z'
/// for digit values >= 10.
pub fn FormatUint(i: uint64, base: int) -> string

/// IsGraphic reports whether the rune is defined as a Graphic by Unicode. Such
/// characters include letters, marks, numbers, punctuation, symbols, and
/// spaces, from categories L, M, N, P, S, and Zs.
pub fn IsGraphic(r: int32) -> bool

/// IsPrint reports whether the rune is defined as printable by Go, with
/// the same definition as [unicode.IsPrint]: letters, numbers, punctuation,
/// symbols and ASCII space.
pub fn IsPrint(r: int32) -> bool

/// Itoa is equivalent to [FormatInt](int64(i), 10).
pub fn Itoa(i: int) -> string

/// ParseBool returns the boolean value represented by the string.
/// It accepts 1, t, T, TRUE, true, True, 0, f, F, FALSE, false, False.
/// Any other value returns an error.
pub fn ParseBool(str: string) -> Result<bool, error>

/// ParseComplex converts the string s to a complex number
/// with the precision specified by bitSize: 64 for complex64, or 128 for complex128.
/// When bitSize=64, the result still has type complex128, but it will be
/// convertible to complex64 without changing its value.
/// 
/// The number represented by s must be of the form N, Ni, or N±Ni, where N stands
/// for a floating-point number as recognized by [ParseFloat], and i is the imaginary
/// component. If the second N is unsigned, a + sign is required between the two components
/// as indicated by the ±. If the second N is NaN, only a + sign is accepted.
/// The form may be parenthesized and cannot contain any spaces.
/// The resulting complex number consists of the two components converted by ParseFloat.
/// 
/// The errors that ParseComplex returns have concrete type [*NumError]
/// and include err.Num = s.
/// 
/// If s is not syntactically well-formed, ParseComplex returns err.Err = ErrSyntax.
/// 
/// If s is syntactically well-formed but either component is more than 1/2 ULP
/// away from the largest floating point number of the given component's size,
/// ParseComplex returns err.Err = ErrRange and c = ±Inf for the respective component.
pub fn ParseComplex(s: string, bitSize: int) -> Result<complex128, error>

/// ParseFloat converts the string s to a floating-point number
/// with the precision specified by bitSize: 32 for float32, or 64 for float64.
/// When bitSize=32, the result still has type float64, but it will be
/// convertible to float32 without changing its value.
/// 
/// ParseFloat accepts decimal and hexadecimal floating-point numbers
/// as defined by the Go syntax for [floating-point literals].
/// If s is well-formed and near a valid floating-point number,
/// ParseFloat returns the nearest floating-point number rounded
/// using IEEE754 unbiased rounding.
/// (Parsing a hexadecimal floating-point value only rounds when
/// there are more bits in the hexadecimal representation than
/// will fit in the mantissa.)
/// 
/// The errors that ParseFloat returns have concrete type *NumError
/// and include err.Num = s.
/// 
/// If s is not syntactically well-formed, ParseFloat returns err.Err = ErrSyntax.
/// 
/// If s is syntactically well-formed but is more than 1/2 ULP
/// away from the largest floating point number of the given size,
/// ParseFloat returns f = ±Inf, err.Err = ErrRange.
/// 
/// ParseFloat recognizes the string "NaN", and the (possibly signed) strings "Inf" and "Infinity"
/// as their respective special floating point values. It ignores case when matching.
/// 
/// [floating-point literals]: https://go.dev/ref/spec#Floating-point_literals
pub fn ParseFloat(s: string, bitSize: int) -> Result<float64, error>

/// ParseInt interprets a string s in the given base (0, 2 to 36) and
/// bit size (0 to 64) and returns the corresponding value i.
/// 
/// The string may begin with a leading sign: "+" or "-".
/// 
/// If the base argument is 0, the true base is implied by the string's
/// prefix following the sign (if present): 2 for "0b", 8 for "0" or "0o",
/// 16 for "0x", and 10 otherwise. Also, for argument base 0 only,
/// underscore characters are permitted as defined by the Go syntax for
/// [integer literals].
/// 
/// The bitSize argument specifies the integer type
/// that the result must fit into. Bit sizes 0, 8, 16, 32, and 64
/// correspond to int, int8, int16, int32, and int64.
/// If bitSize is below 0 or above 64, an error is returned.
/// 
/// The errors that ParseInt returns have concrete type [*NumError]
/// and include err.Num = s. If s is empty or contains invalid
/// digits, err.Err = [ErrSyntax] and the returned value is 0;
/// if the value corresponding to s cannot be represented by a
/// signed integer of the given size, err.Err = [ErrRange] and the
/// returned value is the maximum magnitude integer of the
/// appropriate bitSize and sign.
/// 
/// [integer literals]: https://go.dev/ref/spec#Integer_literals
pub fn ParseInt(s: string, base: int, bitSize: int) -> Result<int64, error>

/// ParseUint is like [ParseInt] but for unsigned numbers.
/// 
/// A sign prefix is not permitted.
pub fn ParseUint(s: string, base: int, bitSize: int) -> Result<uint64, error>

/// Quote returns a double-quoted Go string literal representing s. The
/// returned string uses Go escape sequences (\t, \n, \xFF, \u0100) for
/// control characters and non-printable characters as defined by
/// [IsPrint].
pub fn Quote(s: string) -> string

/// QuoteRune returns a single-quoted Go character literal representing the
/// rune. The returned string uses Go escape sequences (\t, \n, \xFF, \u0100)
/// for control characters and non-printable characters as defined by [IsPrint].
/// If r is not a valid Unicode code point, it is interpreted as the Unicode
/// replacement character U+FFFD.
pub fn QuoteRune(r: int32) -> string

/// QuoteRuneToASCII returns a single-quoted Go character literal representing
/// the rune. The returned string uses Go escape sequences (\t, \n, \xFF,
/// \u0100) for non-ASCII characters and non-printable characters as defined
/// by [IsPrint].
/// If r is not a valid Unicode code point, it is interpreted as the Unicode
/// replacement character U+FFFD.
pub fn QuoteRuneToASCII(r: int32) -> string

/// QuoteRuneToGraphic returns a single-quoted Go character literal representing
/// the rune. If the rune is not a Unicode graphic character,
/// as defined by [IsGraphic], the returned string will use a Go escape sequence
/// (\t, \n, \xFF, \u0100).
/// If r is not a valid Unicode code point, it is interpreted as the Unicode
/// replacement character U+FFFD.
pub fn QuoteRuneToGraphic(r: int32) -> string

/// QuoteToASCII returns a double-quoted Go string literal representing s.
/// The returned string uses Go escape sequences (\t, \n, \xFF, \u0100) for
/// non-ASCII characters and non-printable characters as defined by [IsPrint].
pub fn QuoteToASCII(s: string) -> string

/// QuoteToGraphic returns a double-quoted Go string literal representing s.
/// The returned string leaves Unicode graphic characters, as defined by
/// [IsGraphic], unchanged and uses Go escape sequences (\t, \n, \xFF, \u0100)
/// for non-graphic characters.
pub fn QuoteToGraphic(s: string) -> string

/// QuotedPrefix returns the quoted string (as understood by [Unquote]) at the prefix of s.
/// If s does not start with a valid quoted string, QuotedPrefix returns an error.
pub fn QuotedPrefix(s: string) -> Result<string, error>

/// Unquote interprets s as a single-quoted, double-quoted,
/// or backquoted Go string literal, returning the string value
/// that s quotes.  (If s is single-quoted, it would be a Go
/// character literal; Unquote returns the corresponding
/// one-character string. For an empty character literal
/// Unquote returns the empty string.)
pub fn Unquote(s: string) -> Result<string, error>

/// UnquoteChar decodes the first character or byte in the escaped string
/// or character literal represented by the string s.
/// It returns four values:
/// 
///  1. value, the decoded Unicode code point or byte value;
///  2. multibyte, a boolean indicating whether the decoded character requires a multibyte UTF-8 representation;
///  3. tail, the remainder of the string after the character; and
///  4. an error that will be nil if the character is syntactically valid.
/// 
/// The second argument, quote, specifies the type of literal being parsed
/// and therefore which escaped quote character is permitted.
/// If set to a single quote, it permits the sequence \' and disallows unescaped '.
/// If set to a double quote, it permits \" and disallows unescaped ".
/// If set to zero, it does not permit either escape and allows both quote characters to appear unescaped.
pub fn UnquoteChar(s: string, quote: uint8) -> Result<(int32, bool, string), error>

/// A NumError records a failed conversion.
pub struct NumError {
  pub Func: string,
  pub Num: string,
  pub Err: error,
}

/// IntSize is the size in bits of an int or uint value.
const IntSize = 64

/// ErrRange indicates that a value is out of range for the target type.
pub var ErrRange: error

/// ErrSyntax indicates that a value does not have the right syntax for the target type.
pub var ErrSyntax: error

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

  fn Unwrap(self: Ref<NumError>) -> Option<error>
}
