// Generated by Lisette bindgen
// Source: compress/gzip (Go stdlib)
// Go: 1.25.10
// Lisette: 0.3.0

import "go:io"
import "go:time"

/// NewReader creates a new [Reader] reading the given reader.
/// If r does not also implement [io.ByteReader],
/// the decompressor may read more data than necessary from r.
/// 
/// It is the caller's responsibility to call [Reader.Close] when done.
/// 
/// The Reader.[Header] fields will be valid in the [Reader] returned.
pub fn NewReader(r: io.Reader) -> Result<Ref<Reader>, error>

/// NewWriter returns a new [Writer].
/// Writes to the returned writer are compressed and written to w.
/// 
/// It is the caller's responsibility to call Close on the [Writer] when done.
/// Writes may be buffered and not flushed until Close.
/// 
/// Callers that wish to set the fields in Writer.[Header] must do so before
/// the first call to Write, Flush, or Close.
pub fn NewWriter(w: io.Writer) -> Ref<Writer>

/// NewWriterLevel is like [NewWriter] but specifies the compression level instead
/// of assuming [DefaultCompression].
/// 
/// The compression level can be [DefaultCompression], [NoCompression], [HuffmanOnly]
/// or any integer value between [BestSpeed] and [BestCompression] inclusive.
/// The error returned will be nil if the level is valid.
pub fn NewWriterLevel(w: io.Writer, level: int) -> Result<Ref<Writer>, error>

/// The gzip file stores a header giving metadata about the compressed file.
/// That header is exposed as the fields of the [Writer] and [Reader] structs.
/// 
/// Strings must be UTF-8 encoded and may only contain Unicode code points
/// U+0001 through U+00FF, due to limitations of the GZIP file format.
pub struct Header {
  pub Comment: string,
  pub Extra: Slice<byte>,
  pub ModTime: time.Time,
  pub Name: string,
  pub OS: byte,
}

/// A Reader is an [io.Reader] that can be read to retrieve
/// uncompressed data from a gzip-format compressed file.
/// 
/// In general, a gzip file can be a concatenation of gzip files,
/// each with its own header. Reads from the Reader
/// return the concatenation of the uncompressed data of each.
/// Only the first header is recorded in the Reader fields.
/// 
/// Gzip files store a length and checksum of the uncompressed data.
/// The Reader will return an [ErrChecksum] when [Reader.Read]
/// reaches the end of the uncompressed data if it does not
/// have the expected length or checksum. Clients should treat data
/// returned by [Reader.Read] as tentative until they receive the [io.EOF]
/// marking the end of the data.
pub struct Reader {
  pub Header: Header,
}

/// A Writer is an [io.WriteCloser].
/// Writes to a Writer are compressed and written to w.
pub struct Writer {
  pub Header: Header,
}

/// These constants are copied from the [flate] package, so that code that imports
/// [compress/gzip] does not also have to import [compress/flate].
pub const BestCompression = 9

/// These constants are copied from the [flate] package, so that code that imports
/// [compress/gzip] does not also have to import [compress/flate].
pub const BestSpeed = 1

/// These constants are copied from the [flate] package, so that code that imports
/// [compress/gzip] does not also have to import [compress/flate].
pub const DefaultCompression = -1

/// These constants are copied from the [flate] package, so that code that imports
/// [compress/gzip] does not also have to import [compress/flate].
pub const HuffmanOnly = -2

/// These constants are copied from the [flate] package, so that code that imports
/// [compress/gzip] does not also have to import [compress/flate].
pub const NoCompression = 0

pub var ErrChecksum: error

pub var ErrHeader: error

impl Reader {
  /// Close closes the [Reader]. It does not close the underlying reader.
  /// In order for the GZIP checksum to be verified, the reader must be
  /// fully consumed until the [io.EOF].
  #[allow(unused_result)]
  fn Close(self: Ref<Reader>) -> Result<(), error>

  /// Multistream controls whether the reader supports multistream files.
  /// 
  /// If enabled (the default), the [Reader] expects the input to be a sequence
  /// of individually gzipped data streams, each with its own header and
  /// trailer, ending at EOF. The effect is that the concatenation of a sequence
  /// of gzipped files is treated as equivalent to the gzip of the concatenation
  /// of the sequence. This is standard behavior for gzip readers.
  /// 
  /// Calling Multistream(false) disables this behavior; disabling the behavior
  /// can be useful when reading file formats that distinguish individual gzip
  /// data streams or mix gzip data streams with other data streams.
  /// In this mode, when the [Reader] reaches the end of the data stream,
  /// [Reader.Read] returns [io.EOF]. The underlying reader must implement [io.ByteReader]
  /// in order to be left positioned just after the gzip stream.
  /// To start the next stream, call z.Reset(r) followed by z.Multistream(false).
  /// If there is no next stream, z.Reset(r) will return [io.EOF].
  fn Multistream(self: Ref<Reader>, ok: bool)

  /// Read implements [io.Reader], reading uncompressed bytes from its underlying reader.
  fn Read(self: Ref<Reader>, mut p: Slice<byte>) -> Partial<int, error>

  /// Reset discards the [Reader] z's state and makes it equivalent to the
  /// result of its original state from [NewReader], but reading from r instead.
  /// This permits reusing a [Reader] rather than allocating a new one.
  fn Reset(self: Ref<Reader>, r: io.Reader) -> Result<(), error>
}

impl Writer {
  /// Close closes the [Writer] by flushing any unwritten data to the underlying
  /// [io.Writer] and writing the GZIP footer.
  /// It does not close the underlying [io.Writer].
  #[allow(unused_result)]
  fn Close(self: Ref<Writer>) -> Result<(), error>

  /// Flush flushes any pending compressed data to the underlying writer.
  /// 
  /// It is useful mainly in compressed network protocols, to ensure that
  /// a remote reader has enough data to reconstruct a packet. Flush does
  /// not return until the data has been written. If the underlying
  /// writer returns an error, Flush returns that error.
  /// 
  /// In the terminology of the zlib library, Flush is equivalent to Z_SYNC_FLUSH.
  #[allow(unused_result)]
  fn Flush(self: Ref<Writer>) -> Result<(), error>

  /// Reset discards the [Writer] z's state and makes it equivalent to the
  /// result of its original state from [NewWriter] or [NewWriterLevel], but
  /// writing to w instead. This permits reusing a [Writer] rather than
  /// allocating a new one.
  fn Reset(self: Ref<Writer>, w: io.Writer)

  /// Write writes a compressed form of p to the underlying [io.Writer]. The
  /// compressed bytes are not necessarily flushed until the [Writer] is closed.
  fn Write(self: Ref<Writer>, p: Slice<byte>) -> Partial<int, error>
}
