// Generated by Lisette bindgen
// Source: encoding/base64 (Go stdlib)
// Go: 1.25.5
// Lisette: 0.1.20

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

pub const NoPadding = -1

pub 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>
}
