// Generated by Lisette bindgen
// Source: encoding/base32 (Go stdlib)
// Go: 1.25.10
// Lisette: 0.2.1

import "go:io"

/// NewDecoder constructs a new base32 stream decoder.
pub fn NewDecoder(enc: Ref<Encoding>, r: io.Reader) -> io.Reader

/// NewEncoder returns a new base32 stream encoder. Data written to
/// the returned writer will be encoded using enc and then written to w.
/// Base32 encodings operate in 5-byte blocks; when finished
/// writing, the caller must Close the returned encoder to flush any
/// partially written blocks.
pub fn NewEncoder(enc: Ref<Encoding>, w: io.Writer) -> io.WriteCloser

/// NewEncoding returns a new padded Encoding defined by the given alphabet,
/// which must be a 32-byte string that contains unique byte values and
/// does not contain the padding character or CR / LF ('\r', '\n').
/// The alphabet is treated as a sequence of byte values
/// without any special treatment for multi-byte UTF-8.
/// The resulting Encoding uses the default padding character ('='),
/// which may be changed or disabled via [Encoding.WithPadding].
pub fn NewEncoding(encoder: string) -> Ref<Encoding>

pub struct CorruptInputError(int64)

/// An Encoding is a radix 32 encoding/decoding scheme, defined by a
/// 32-character alphabet. The most common is the "base32" encoding
/// introduced for SASL GSSAPI and standardized in RFC 4648.
/// The alternate "base32hex" encoding is used in DNSSEC.
pub type Encoding

pub const NoPadding = -1

pub const StdPadding = 61

/// HexEncoding is the “Extended Hex Alphabet” defined in RFC 4648.
/// It is typically used in DNS.
pub var HexEncoding: Ref<Encoding>

/// StdEncoding is the standard base32 encoding, as defined in RFC 4648.
pub var StdEncoding: Ref<Encoding>

impl CorruptInputError {
  fn Error(self) -> string
}

impl Encoding {
  /// AppendDecode appends the base32 decoded src to dst
  /// and returns the extended buffer.
  /// If the input is malformed, it returns the partially decoded src and an error.
  /// New line characters (\r and \n) are ignored.
  fn AppendDecode(self: Ref<Encoding>, mut dst: Slice<byte>, src: Slice<byte>) -> Partial<Slice<byte>, error>

  /// AppendEncode appends the base32 encoded src to dst
  /// and returns the extended buffer.
  fn AppendEncode(self: Ref<Encoding>, mut dst: Slice<byte>, src: Slice<byte>) -> Slice<byte>

  /// Decode decodes src using the encoding enc. It writes at most
  /// [Encoding.DecodedLen](len(src)) bytes to dst and returns the number of bytes
  /// written. The caller must ensure that dst is large enough to hold all
  /// the decoded data. If src contains invalid base32 data, it will return the
  /// number of bytes successfully written and [CorruptInputError].
  /// Newline characters (\r and \n) are ignored.
  fn Decode(self: Ref<Encoding>, mut dst: Slice<byte>, src: Slice<byte>) -> Partial<int, error>

  /// DecodeString returns the bytes represented by the base32 string s.
  /// If the input is malformed, it returns the partially decoded data and
  /// [CorruptInputError]. New line characters (\r and \n) are ignored.
  fn DecodeString(self: Ref<Encoding>, s: string) -> Partial<Slice<byte>, error>

  /// DecodedLen returns the maximum length in bytes of the decoded data
  /// corresponding to n bytes of base32-encoded data.
  fn DecodedLen(self: Ref<Encoding>, n: int) -> int

  /// Encode encodes src using the encoding enc,
  /// writing [Encoding.EncodedLen](len(src)) bytes to dst.
  /// 
  /// The encoding pads the output to a multiple of 8 bytes,
  /// so Encode is not appropriate for use on individual blocks
  /// of a large data stream. Use [NewEncoder] instead.
  fn Encode(self: Ref<Encoding>, mut dst: Slice<byte>, src: Slice<byte>)

  /// EncodeToString returns the base32 encoding of src.
  fn EncodeToString(self: Ref<Encoding>, src: Slice<byte>) -> string

  /// EncodedLen returns the length in bytes of the base32 encoding
  /// of an input buffer of length n.
  fn EncodedLen(self: Ref<Encoding>, n: int) -> int

  /// WithPadding creates a new encoding identical to enc except
  /// with a specified padding character, or NoPadding to disable padding.
  /// The padding character must not be '\r' or '\n',
  /// must not be contained in the encoding's alphabet,
  /// must not be negative, and must be a rune equal or below '\xff'.
  /// Padding characters above '\x7f' are encoded as their exact byte value
  /// rather than using the UTF-8 representation of the codepoint.
  fn WithPadding(self, padding: rune) -> Ref<Encoding>
}
