// Generated by Lisette bindgen
// Source: encoding/base64 (Go stdlib)
// Go: 1.25.5
// Lisette: 0.1.12
import "go:io"
/// NewDecoder constructs a new base64 stream decoder.
pub fn NewDecoder(enc: Ref<Encoding>, r: io.Reader) -> io.Reader
/// NewEncoder returns a new base64 stream encoder. Data written to
/// the returned writer will be encoded using enc and then written to w.
/// Base64 encodings operate in 4-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 64 encoding/decoding scheme, defined by a
/// 64-character alphabet. The most common encoding is the "base64"
/// encoding defined in RFC 4648 and used in MIME (RFC 2045) and PEM
/// (RFC 1421). RFC 4648 also defines an alternate encoding, which is
/// the standard encoding with - and _ substituted for + and /.
pub type Encoding
const NoPadding = -1
const StdPadding = 61
/// RawStdEncoding is the standard raw, unpadded base64 encoding,
/// as defined in RFC 4648 section 3.2.
/// This is the same as [StdEncoding] but omits padding characters.
pub var RawStdEncoding: Ref<Encoding>
/// RawURLEncoding is the unpadded alternate base64 encoding defined in RFC 4648.
/// It is typically used in URLs and file names.
/// This is the same as [URLEncoding] but omits padding characters.
pub var RawURLEncoding: Ref<Encoding>
/// StdEncoding is the standard base64 encoding, as defined in RFC 4648.
pub var StdEncoding: Ref<Encoding>
/// URLEncoding is the alternate base64 encoding defined in RFC 4648.
/// It is typically used in URLs and file names.
pub var URLEncoding: Ref<Encoding>
impl CorruptInputError {
fn Error(self) -> string
}
impl Encoding {
/// AppendDecode appends the base64 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 base64 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 base64 data, it will return the
/// number of bytes successfully written and [CorruptInputError].
/// New line 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 base64 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 base64-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 4 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 base64 encoding of src.
fn EncodeToString(self: Ref<Encoding>, src: Slice<uint8>) -> string
/// EncodedLen returns the length in bytes of the base64 encoding
/// of an input buffer of length n.
fn EncodedLen(self: Ref<Encoding>, n: int) -> int
/// Strict creates a new encoding identical to enc except with
/// strict decoding enabled. In this mode, the decoder requires that
/// trailing padding bits are zero, as described in RFC 4648 section 3.5.
///
/// Note that the input is still malleable, as new line characters
/// (CR and LF) are still ignored.
fn Strict(self) -> Ref<Encoding>
/// 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>
}