// Generated by Lisette bindgen
// Source: encoding/csv (Go stdlib)
// Go: 1.25.10
// Lisette: 0.2.1

import "go:io"

/// NewReader returns a new Reader that reads from r.
pub fn NewReader(r: io.Reader) -> Ref<Reader>

/// NewWriter returns a new Writer that writes to w.
pub fn NewWriter(w: io.Writer) -> Ref<Writer>

/// A ParseError is returned for parsing errors.
/// Line and column numbers are 1-indexed.
pub struct ParseError {
  pub StartLine: int,
  pub Line: int,
  pub Column: int,
  pub Err: error,
}

/// A Reader reads records from a CSV-encoded file.
/// 
/// As returned by [NewReader], a Reader expects input conforming to RFC 4180.
/// The exported fields can be changed to customize the details before the
/// first call to [Reader.Read] or [Reader.ReadAll].
/// 
/// The Reader converts all \r\n sequences in its input to plain \n,
/// including in multiline field values, so that the returned data does
/// not depend on which line-ending convention an input file uses.
pub struct Reader {
  pub Comma: rune,
  pub Comment: rune,
  pub FieldsPerRecord: int,
  pub LazyQuotes: bool,
  pub TrimLeadingSpace: bool,
  pub ReuseRecord: bool,
  pub TrailingComma: bool,
}

/// A Writer writes records using CSV encoding.
/// 
/// As returned by [NewWriter], a Writer writes records terminated by a
/// newline and uses ',' as the field delimiter. The exported fields can be
/// changed to customize the details before
/// the first call to [Writer.Write] or [Writer.WriteAll].
/// 
/// [Writer.Comma] is the field delimiter.
/// 
/// If [Writer.UseCRLF] is true,
/// the Writer ends each output line with \r\n instead of \n.
/// 
/// The writes of individual records are buffered.
/// After all data has been written, the client should call the
/// [Writer.Flush] method to guarantee all data has been forwarded to
/// the underlying [io.Writer].  Any errors that occurred should
/// be checked by calling the [Writer.Error] method.
pub struct Writer {
  pub Comma: rune,
  pub UseCRLF: bool,
}

/// These are the errors that can be returned in [ParseError.Err].
pub var ErrBareQuote: error

/// These are the errors that can be returned in [ParseError.Err].
pub var ErrFieldCount: error

/// These are the errors that can be returned in [ParseError.Err].
pub var ErrQuote: error

/// These are the errors that can be returned in [ParseError.Err].
pub var ErrTrailingComma: error

impl ParseError {
  fn Error(self: Ref<ParseError>) -> string

  fn Unwrap(self: Ref<ParseError>) -> Option<error>
}

impl Reader {
  /// FieldPos returns the line and column corresponding to
  /// the start of the field with the given index in the slice most recently
  /// returned by [Reader.Read]. Numbering of lines and columns starts at 1;
  /// columns are counted in bytes, not runes.
  /// 
  /// If this is called with an out-of-bounds index, it panics.
  fn FieldPos(self: Ref<Reader>, field: int) -> (int, int)

  /// InputOffset returns the input stream byte offset of the current reader
  /// position. The offset gives the location of the end of the most recently
  /// read row and the beginning of the next row.
  fn InputOffset(self: Ref<Reader>) -> int64

  /// Read reads one record (a slice of fields) from r.
  /// If the record has an unexpected number of fields,
  /// Read returns the record along with the error [ErrFieldCount].
  /// If the record contains a field that cannot be parsed,
  /// Read returns a partial record along with the parse error.
  /// The partial record contains all fields read before the error.
  /// If there is no data left to be read, Read returns nil, [io.EOF].
  /// If [Reader.ReuseRecord] is true, the returned slice may be shared
  /// between multiple calls to Read.
  fn Read(self: Ref<Reader>) -> Partial<Slice<string>, error>

  /// ReadAll reads all the remaining records from r.
  /// Each record is a slice of fields.
  /// A successful call returns err == nil, not err == [io.EOF]. Because ReadAll is
  /// defined to read until EOF, it does not treat end of file as an error to be
  /// reported.
  fn ReadAll(self: Ref<Reader>) -> Result<Slice<Slice<string>>, error>
}

impl Writer {
  /// Error reports any error that has occurred during
  /// a previous [Writer.Write] or [Writer.Flush].
  fn Error(self: Ref<Writer>) -> Result<(), error>

  /// Flush writes any buffered data to the underlying [io.Writer].
  /// To check if an error occurred during Flush, call [Writer.Error].
  fn Flush(self: Ref<Writer>)

  /// Write writes a single CSV record to w along with any necessary quoting.
  /// A record is a slice of strings with each string being one field.
  /// Writes are buffered, so [Writer.Flush] must eventually be called to ensure
  /// that the record is written to the underlying [io.Writer].
  fn Write(self: Ref<Writer>, record: Slice<string>) -> Result<(), error>

  /// WriteAll writes multiple CSV records to w using [Writer.Write] and
  /// then calls [Writer.Flush], returning any error from the Flush.
  fn WriteAll(self: Ref<Writer>, records: Slice<Slice<string>>) -> Result<(), error>
}
