// Generated by Lisette bindgen
// Source: encoding/base32 (Go stdlib)
// Go: 1.25.5
// Lisette: 0.1.14
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
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
const NoPadding = -1
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<uint8>, src: Slice<uint8>) -> Result<Slice<uint8>, error>
/// AppendEncode appends the base32 encoded src to dst
/// and returns the extended buffer.
fn AppendEncode(self: Ref<Encoding>, mut dst: Slice<uint8>, src: Slice<uint8>) -> Slice<uint8>
/// 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<uint8>, src: Slice<uint8>) -> Result<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) -> Result<Slice<uint8>, 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<uint8>, src: Slice<uint8>)
/// EncodeToString returns the base32 encoding of src.
fn EncodeToString(self: Ref<Encoding>, src: Slice<uint8>) -> 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: int32) -> Ref<Encoding>
}