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

import "go:io"

/// Append appends the binary representation of data to buf.
/// buf may be nil, in which case a new buffer will be allocated.
/// See [Write] on which data are acceptable.
/// It returns the (possibly extended) buffer containing data or an error.
pub fn Append(mut buf: Slice<uint8>, order: ByteOrder, data: Unknown) -> Result<Slice<uint8>, error>

/// AppendUvarint appends the varint-encoded form of x,
/// as generated by [PutUvarint], to buf and returns the extended buffer.
pub fn AppendUvarint(mut buf: Slice<uint8>, x: uint64) -> Slice<uint8>

/// AppendVarint appends the varint-encoded form of x,
/// as generated by [PutVarint], to buf and returns the extended buffer.
pub fn AppendVarint(mut buf: Slice<uint8>, x: int64) -> Slice<uint8>

/// Decode decodes binary data from buf into data according to
/// the given byte order.
/// It returns an error if buf is too small, otherwise the number of
/// bytes consumed from buf.
pub fn Decode(buf: Slice<uint8>, order: ByteOrder, data: Unknown) -> Result<int, error>

/// Encode encodes the binary representation of data into buf according to
/// the given byte order.
/// It returns an error if buf is too small, otherwise the number of
/// bytes written into buf.
pub fn Encode(mut buf: Slice<uint8>, order: ByteOrder, data: Unknown) -> Result<int, error>

/// PutUvarint encodes a uint64 into buf and returns the number of bytes written.
/// If the buffer is too small, PutUvarint will panic.
pub fn PutUvarint(mut buf: Slice<uint8>, x: uint64) -> int

/// PutVarint encodes an int64 into buf and returns the number of bytes written.
/// If the buffer is too small, PutVarint will panic.
pub fn PutVarint(mut buf: Slice<uint8>, x: int64) -> int

/// Read reads structured binary data from r into data.
/// Data must be a pointer to a fixed-size value or a slice
/// of fixed-size values.
/// Bytes read from r are decoded using the specified byte order
/// and written to successive fields of the data.
/// When decoding boolean values, a zero byte is decoded as false, and
/// any other non-zero byte is decoded as true.
/// When reading into structs, the field data for fields with
/// blank (_) field names is skipped; i.e., blank field names
/// may be used for padding.
/// When reading into a struct, all non-blank fields must be exported
/// or Read may panic.
/// 
/// The error is [io.EOF] only if no bytes were read.
/// If an [io.EOF] happens after reading some but not all the bytes,
/// Read returns [io.ErrUnexpectedEOF].
pub fn Read<T>(r: io.Reader, order: ByteOrder, data: Ref<T>) -> Result<(), error>

/// ReadUvarint reads an encoded unsigned integer from r and returns it as a uint64.
/// The error is [io.EOF] only if no bytes were read.
/// If an [io.EOF] happens after reading some but not all the bytes,
/// ReadUvarint returns [io.ErrUnexpectedEOF].
pub fn ReadUvarint(r: io.ByteReader) -> Result<uint64, error>

/// ReadVarint reads an encoded signed integer from r and returns it as an int64.
/// The error is [io.EOF] only if no bytes were read.
/// If an [io.EOF] happens after reading some but not all the bytes,
/// ReadVarint returns [io.ErrUnexpectedEOF].
pub fn ReadVarint(r: io.ByteReader) -> Result<int64, error>

/// Size returns how many bytes [Write] would generate to encode the value v, which
/// must be a fixed-size value or a slice of fixed-size values, or a pointer to such data.
/// If v is neither of these, Size returns -1.
pub fn Size(v: Unknown) -> int

/// Uvarint decodes a uint64 from buf and returns that value and the
/// number of bytes read (> 0). If an error occurred, the value is 0
/// and the number of bytes n is <= 0 meaning:
///   - n == 0: buf too small;
///   - n < 0: value larger than 64 bits (overflow) and -n is the number of
///     bytes read.
pub fn Uvarint(buf: Slice<uint8>) -> (uint64, int)

/// Varint decodes an int64 from buf and returns that value and the
/// number of bytes read (> 0). If an error occurred, the value is 0
/// and the number of bytes n is <= 0 with the following meaning:
///   - n == 0: buf too small;
///   - n < 0: value larger than 64 bits (overflow)
///     and -n is the number of bytes read.
pub fn Varint(buf: Slice<uint8>) -> (int64, int)

/// Write writes the binary representation of data into w.
/// Data must be a fixed-size value or a slice of fixed-size
/// values, or a pointer to such data.
/// Boolean values encode as one byte: 1 for true, and 0 for false.
/// Bytes written to w are encoded using the specified byte order
/// and read from successive fields of the data.
/// When writing structs, zero values are written for fields
/// with blank (_) field names.
pub fn Write(w: io.Writer, order: ByteOrder, data: Unknown) -> Result<(), error>

/// AppendByteOrder specifies how to append 16-, 32-, or 64-bit unsigned integers
/// into a byte slice.
/// 
/// It is implemented by [LittleEndian], [BigEndian], and [NativeEndian].
pub interface AppendByteOrder {
  fn AppendUint16(mut arg0: Slice<uint8>, arg1: uint16) -> Slice<uint8>
  fn AppendUint32(mut arg0: Slice<uint8>, arg1: uint32) -> Slice<uint8>
  fn AppendUint64(mut arg0: Slice<uint8>, arg1: uint64) -> Slice<uint8>
  fn String() -> string
}

/// A ByteOrder specifies how to convert byte slices into
/// 16-, 32-, or 64-bit unsigned integers.
/// 
/// It is implemented by [LittleEndian], [BigEndian], and [NativeEndian].
pub interface ByteOrder {
  fn PutUint16(mut arg0: Slice<uint8>, arg1: uint16)
  fn PutUint32(mut arg0: Slice<uint8>, arg1: uint32)
  fn PutUint64(mut arg0: Slice<uint8>, arg1: uint64)
  fn String() -> string
  fn Uint16(arg0: Slice<uint8>) -> uint16
  fn Uint32(arg0: Slice<uint8>) -> uint32
  fn Uint64(arg0: Slice<uint8>) -> uint64
}

/// MaxVarintLenN is the maximum length of a varint-encoded N-bit integer.
pub const MaxVarintLen16 = 3

/// MaxVarintLenN is the maximum length of a varint-encoded N-bit integer.
pub const MaxVarintLen32 = 5

/// MaxVarintLenN is the maximum length of a varint-encoded N-bit integer.
pub const MaxVarintLen64 = 10

pub var BigEndian: ()

pub var LittleEndian: ()

// SKIPPED: NativeEndian - anonymous-struct
// anonymous struct types are not supported
