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

import "go:io"

/// NewReadWriter allocates a new [ReadWriter] that dispatches to r and w.
pub fn NewReadWriter(r: Ref<Reader>, w: Ref<Writer>) -> Ref<ReadWriter>

/// NewReader returns a new [Reader] whose buffer has the default size.
pub fn NewReader(rd: io.Reader) -> Ref<Reader>

/// NewReaderSize returns a new [Reader] whose buffer has at least the specified
/// size. If the argument io.Reader is already a [Reader] with large enough
/// size, it returns the underlying [Reader].
pub fn NewReaderSize(rd: io.Reader, size: int) -> Ref<Reader>

/// NewScanner returns a new [Scanner] to read from r.
/// The split function defaults to [ScanLines].
pub fn NewScanner(r: io.Reader) -> Ref<Scanner>

/// NewWriter returns a new [Writer] whose buffer has the default size.
/// If the argument io.Writer is already a [Writer] with large enough buffer size,
/// it returns the underlying [Writer].
pub fn NewWriter(w: io.Writer) -> Ref<Writer>

/// NewWriterSize returns a new [Writer] whose buffer has at least the specified
/// size. If the argument io.Writer is already a [Writer] with large enough
/// size, it returns the underlying [Writer].
pub fn NewWriterSize(w: io.Writer, size: int) -> Ref<Writer>

/// ScanBytes is a split function for a [Scanner] that returns each byte as a token.
pub fn ScanBytes(data: Slice<byte>, atEOF: bool) -> Result<(int, Slice<byte>), error>

/// ScanLines is a split function for a [Scanner] that returns each line of
/// text, stripped of any trailing end-of-line marker. The returned line may
/// be empty. The end-of-line marker is one optional carriage return followed
/// by one mandatory newline. In regular expression notation, it is `\r?\n`.
/// The last non-empty line of input will be returned even if it has no
/// newline.
pub fn ScanLines(data: Slice<byte>, atEOF: bool) -> Result<(int, Slice<byte>), error>

/// ScanRunes is a split function for a [Scanner] that returns each
/// UTF-8-encoded rune as a token. The sequence of runes returned is
/// equivalent to that from a range loop over the input as a string, which
/// means that erroneous UTF-8 encodings translate to U+FFFD = "\xef\xbf\xbd".
/// Because of the Scan interface, this makes it impossible for the client to
/// distinguish correctly encoded replacement runes from encoding errors.
pub fn ScanRunes(data: Slice<byte>, atEOF: bool) -> Result<(int, Slice<byte>), error>

/// ScanWords is a split function for a [Scanner] that returns each
/// space-separated word of text, with surrounding spaces deleted. It will
/// never return an empty string. The definition of space is set by
/// unicode.IsSpace.
pub fn ScanWords(data: Slice<byte>, atEOF: bool) -> Result<(int, Slice<byte>), error>

/// ReadWriter stores pointers to a [Reader] and a [Writer].
/// It implements [io.ReadWriter].
pub struct ReadWriter {
  pub Reader: Option<Ref<Reader>>,
  pub Writer: Option<Ref<Writer>>,
}

/// Reader implements buffering for an io.Reader object.
/// A new Reader is created by calling [NewReader] or [NewReaderSize];
/// alternatively the zero value of a Reader may be used after calling [Reset]
/// on it.
pub type Reader

/// Scanner provides a convenient interface for reading data such as
/// a file of newline-delimited lines of text. Successive calls to
/// the [Scanner.Scan] method will step through the 'tokens' of a file, skipping
/// the bytes between the tokens. The specification of a token is
/// defined by a split function of type [SplitFunc]; the default split
/// function breaks the input into lines with line termination stripped. [Scanner.Split]
/// functions are defined in this package for scanning a file into
/// lines, bytes, UTF-8-encoded runes, and space-delimited words. The
/// client may instead provide a custom split function.
/// 
/// Scanning stops unrecoverably at EOF, the first I/O error, or a token too
/// large to fit in the [Scanner.Buffer]. When a scan stops, the reader may have
/// advanced arbitrarily far past the last token. Programs that need more
/// control over error handling or large tokens, or must run sequential scans
/// on a reader, should use [bufio.Reader] instead.
pub type Scanner

/// SplitFunc is the signature of the split function used to tokenize the
/// input. The arguments are an initial substring of the remaining unprocessed
/// data and a flag, atEOF, that reports whether the [Reader] has no more data
/// to give. The return values are the number of bytes to advance the input
/// and the next token to return to the user, if any, plus an error, if any.
/// 
/// Scanning stops if the function returns an error, in which case some of
/// the input may be discarded. If that error is [ErrFinalToken], scanning
/// stops with no error. A non-nil token delivered with [ErrFinalToken]
/// will be the last token, and a nil token with [ErrFinalToken]
/// immediately stops the scanning.
/// 
/// Otherwise, the [Scanner] advances the input. If the token is not nil,
/// the [Scanner] returns it to the user. If the token is nil, the
/// Scanner reads more data and continues scanning; if there is no more
/// data--if atEOF was true--the [Scanner] returns. If the data does not
/// yet hold a complete token, for instance if it has no newline while
/// scanning lines, a [SplitFunc] can return (0, nil, nil) to signal the
/// [Scanner] to read more data into the slice and try again with a
/// longer slice starting at the same point in the input.
/// 
/// The function is never called with an empty data slice unless atEOF
/// is true. If atEOF is true, however, data may be non-empty and,
/// as always, holds unprocessed text.
pub type SplitFunc = fn(Slice<byte>, bool) -> Result<(int, Slice<byte>), error>

/// Writer implements buffering for an [io.Writer] object.
/// If an error occurs writing to a [Writer], no more data will be
/// accepted and all subsequent writes, and [Writer.Flush], will return the error.
/// 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].
pub type Writer

pub const MaxScanTokenSize = 65536

/// Errors returned by Scanner.
pub var ErrAdvanceTooFar: error

/// Errors returned by Scanner.
pub var ErrBadReadCount: error

pub var ErrBufferFull: error

/// ErrFinalToken is a special sentinel error value. It is intended to be
/// returned by a Split function to indicate that the scanning should stop
/// with no error. If the token being delivered with this error is not nil,
/// the token is the last token.
/// 
/// The value is useful to stop processing early or when it is necessary to
/// deliver a final empty token (which is different from a nil token).
/// One could achieve the same behavior with a custom error value but
/// providing one here is tidier.
/// See the emptyFinalToken example for a use of this value.
pub var ErrFinalToken: error

pub var ErrInvalidUnreadByte: error

pub var ErrInvalidUnreadRune: error

/// Errors returned by Scanner.
pub var ErrNegativeAdvance: error

pub var ErrNegativeCount: error

/// Errors returned by Scanner.
pub var ErrTooLong: error

impl ReadWriter {
  /// Available returns how many bytes are unused in the buffer.
  fn Available(self: Ref<ReadWriter>) -> int

  /// AvailableBuffer returns an empty buffer with b.Available() capacity.
  /// This buffer is intended to be appended to and
  /// passed to an immediately succeeding [Writer.Write] call.
  /// The buffer is only valid until the next write operation on b.
  fn AvailableBuffer(self: Ref<ReadWriter>) -> Slice<byte>

  /// Discard skips the next n bytes, returning the number of bytes discarded.
  /// 
  /// If Discard skips fewer than n bytes, it also returns an error.
  /// If 0 <= n <= b.Buffered(), Discard is guaranteed to succeed without
  /// reading from the underlying io.Reader.
  fn Discard(self: Ref<ReadWriter>, n: int) -> Partial<int, error>

  /// Flush writes any buffered data to the underlying [io.Writer].
  #[allow(unused_result)]
  fn Flush(self: Ref<ReadWriter>) -> Result<(), error>

  /// Peek returns the next n bytes without advancing the reader. The bytes stop
  /// being valid at the next read call. If necessary, Peek will read more bytes
  /// into the buffer in order to make n bytes available. If Peek returns fewer
  /// than n bytes, it also returns an error explaining why the read is short.
  /// The error is [ErrBufferFull] if n is larger than b's buffer size.
  /// 
  /// Calling Peek prevents a [Reader.UnreadByte] or [Reader.UnreadRune] call from succeeding
  /// until the next read operation.
  fn Peek(self: Ref<ReadWriter>, n: int) -> Partial<Slice<byte>, error>

  /// Read reads data into p.
  /// It returns the number of bytes read into p.
  /// The bytes are taken from at most one Read on the underlying [Reader],
  /// hence n may be less than len(p).
  /// To read exactly len(p) bytes, use io.ReadFull(b, p).
  /// If the underlying [Reader] can return a non-zero count with io.EOF,
  /// then this Read method can do so as well; see the [io.Reader] docs.
  fn Read(self: Ref<ReadWriter>, mut p: Slice<byte>) -> Partial<int, error>

  /// ReadByte reads and returns a single byte.
  /// If no byte is available, returns an error.
  fn ReadByte(self: Ref<ReadWriter>) -> Result<byte, error>

  /// ReadBytes reads until the first occurrence of delim in the input,
  /// returning a slice containing the data up to and including the delimiter.
  /// If ReadBytes encounters an error before finding a delimiter,
  /// it returns the data read before the error and the error itself (often io.EOF).
  /// ReadBytes returns err != nil if and only if the returned data does not end in
  /// delim.
  /// For simple uses, a Scanner may be more convenient.
  fn ReadBytes(self: Ref<ReadWriter>, delim: byte) -> Partial<Slice<byte>, error>

  /// ReadFrom implements [io.ReaderFrom]. If the underlying writer
  /// supports the ReadFrom method, this calls the underlying ReadFrom.
  /// If there is buffered data and an underlying ReadFrom, this fills
  /// the buffer and writes it before calling ReadFrom.
  fn ReadFrom(self: Ref<ReadWriter>, r: io.Reader) -> Partial<int64, error>

  /// ReadLine is a low-level line-reading primitive. Most callers should use
  /// [Reader.ReadBytes]('\n') or [Reader.ReadString]('\n') instead or use a [Scanner].
  /// 
  /// ReadLine tries to return a single line, not including the end-of-line bytes.
  /// If the line was too long for the buffer then isPrefix is set and the
  /// beginning of the line is returned. The rest of the line will be returned
  /// from future calls. isPrefix will be false when returning the last fragment
  /// of the line. The returned buffer is only valid until the next call to
  /// ReadLine. ReadLine either returns a non-nil line or it returns an error,
  /// never both.
  /// 
  /// The text returned from ReadLine does not include the line end ("\r\n" or "\n").
  /// No indication or error is given if the input ends without a final line end.
  /// Calling [Reader.UnreadByte] after ReadLine will always unread the last byte read
  /// (possibly a character belonging to the line end) even if that byte is not
  /// part of the line returned by ReadLine.
  fn ReadLine(self: Ref<ReadWriter>) -> Result<(Slice<byte>, bool), error>

  /// ReadRune reads a single UTF-8 encoded Unicode character and returns the
  /// rune and its size in bytes. If the encoded rune is invalid, it consumes one byte
  /// and returns unicode.ReplacementChar (U+FFFD) with a size of 1.
  fn ReadRune(self: Ref<ReadWriter>) -> Result<(rune, int), error>

  /// ReadSlice reads until the first occurrence of delim in the input,
  /// returning a slice pointing at the bytes in the buffer.
  /// The bytes stop being valid at the next read.
  /// If ReadSlice encounters an error before finding a delimiter,
  /// it returns all the data in the buffer and the error itself (often io.EOF).
  /// ReadSlice fails with error [ErrBufferFull] if the buffer fills without a delim.
  /// Because the data returned from ReadSlice will be overwritten
  /// by the next I/O operation, most clients should use
  /// [Reader.ReadBytes] or ReadString instead.
  /// ReadSlice returns err != nil if and only if line does not end in delim.
  fn ReadSlice(self: Ref<ReadWriter>, delim: byte) -> Partial<Slice<byte>, error>

  /// ReadString reads until the first occurrence of delim in the input,
  /// returning a string containing the data up to and including the delimiter.
  /// If ReadString encounters an error before finding a delimiter,
  /// it returns the data read before the error and the error itself (often io.EOF).
  /// ReadString returns err != nil if and only if the returned data does not end in
  /// delim.
  /// For simple uses, a Scanner may be more convenient.
  fn ReadString(self: Ref<ReadWriter>, delim: byte) -> Partial<string, error>

  /// UnreadByte unreads the last byte. Only the most recently read byte can be unread.
  /// 
  /// UnreadByte returns an error if the most recent method called on the
  /// [Reader] was not a read operation. Notably, [Reader.Peek], [Reader.Discard], and [Reader.WriteTo] are not
  /// considered read operations.
  fn UnreadByte(self: Ref<ReadWriter>) -> Result<(), error>

  /// UnreadRune unreads the last rune. If the most recent method called on
  /// the [Reader] was not a [Reader.ReadRune], [Reader.UnreadRune] returns an error. (In this
  /// regard it is stricter than [Reader.UnreadByte], which will unread the last byte
  /// from any read operation.)
  fn UnreadRune(self: Ref<ReadWriter>) -> Result<(), error>

  /// Write writes the contents of p into the buffer.
  /// It returns the number of bytes written.
  /// If nn < len(p), it also returns an error explaining
  /// why the write is short.
  fn Write(self: Ref<ReadWriter>, p: Slice<byte>) -> Partial<int, error>

  /// WriteByte writes a single byte.
  fn WriteByte(self: Ref<ReadWriter>, c: byte) -> Result<(), error>

  /// WriteRune writes a single Unicode code point, returning
  /// the number of bytes written and any error.
  fn WriteRune(self: Ref<ReadWriter>, r: rune) -> Partial<int, error>

  /// WriteString writes a string.
  /// It returns the number of bytes written.
  /// If the count is less than len(s), it also returns an error explaining
  /// why the write is short.
  fn WriteString(self: Ref<ReadWriter>, s: string) -> Partial<int, error>

  /// WriteTo implements io.WriterTo.
  /// This may make multiple calls to the [Reader.Read] method of the underlying [Reader].
  /// If the underlying reader supports the [Reader.WriteTo] method,
  /// this calls the underlying [Reader.WriteTo] without buffering.
  fn WriteTo(self: Ref<ReadWriter>, w: io.Writer) -> Partial<int64, error>
}

impl Reader {
  /// Buffered returns the number of bytes that can be read from the current buffer.
  fn Buffered(self: Ref<Reader>) -> int

  /// Discard skips the next n bytes, returning the number of bytes discarded.
  /// 
  /// If Discard skips fewer than n bytes, it also returns an error.
  /// If 0 <= n <= b.Buffered(), Discard is guaranteed to succeed without
  /// reading from the underlying io.Reader.
  fn Discard(self: Ref<Reader>, n: int) -> Partial<int, error>

  /// Peek returns the next n bytes without advancing the reader. The bytes stop
  /// being valid at the next read call. If necessary, Peek will read more bytes
  /// into the buffer in order to make n bytes available. If Peek returns fewer
  /// than n bytes, it also returns an error explaining why the read is short.
  /// The error is [ErrBufferFull] if n is larger than b's buffer size.
  /// 
  /// Calling Peek prevents a [Reader.UnreadByte] or [Reader.UnreadRune] call from succeeding
  /// until the next read operation.
  fn Peek(self: Ref<Reader>, n: int) -> Partial<Slice<byte>, error>

  /// Read reads data into p.
  /// It returns the number of bytes read into p.
  /// The bytes are taken from at most one Read on the underlying [Reader],
  /// hence n may be less than len(p).
  /// To read exactly len(p) bytes, use io.ReadFull(b, p).
  /// If the underlying [Reader] can return a non-zero count with io.EOF,
  /// then this Read method can do so as well; see the [io.Reader] docs.
  fn Read(self: Ref<Reader>, mut p: Slice<byte>) -> Partial<int, error>

  /// ReadByte reads and returns a single byte.
  /// If no byte is available, returns an error.
  fn ReadByte(self: Ref<Reader>) -> Result<byte, error>

  /// ReadBytes reads until the first occurrence of delim in the input,
  /// returning a slice containing the data up to and including the delimiter.
  /// If ReadBytes encounters an error before finding a delimiter,
  /// it returns the data read before the error and the error itself (often io.EOF).
  /// ReadBytes returns err != nil if and only if the returned data does not end in
  /// delim.
  /// For simple uses, a Scanner may be more convenient.
  fn ReadBytes(self: Ref<Reader>, delim: byte) -> Partial<Slice<byte>, error>

  /// ReadLine is a low-level line-reading primitive. Most callers should use
  /// [Reader.ReadBytes]('\n') or [Reader.ReadString]('\n') instead or use a [Scanner].
  /// 
  /// ReadLine tries to return a single line, not including the end-of-line bytes.
  /// If the line was too long for the buffer then isPrefix is set and the
  /// beginning of the line is returned. The rest of the line will be returned
  /// from future calls. isPrefix will be false when returning the last fragment
  /// of the line. The returned buffer is only valid until the next call to
  /// ReadLine. ReadLine either returns a non-nil line or it returns an error,
  /// never both.
  /// 
  /// The text returned from ReadLine does not include the line end ("\r\n" or "\n").
  /// No indication or error is given if the input ends without a final line end.
  /// Calling [Reader.UnreadByte] after ReadLine will always unread the last byte read
  /// (possibly a character belonging to the line end) even if that byte is not
  /// part of the line returned by ReadLine.
  fn ReadLine(self: Ref<Reader>) -> Result<(Slice<byte>, bool), error>

  /// ReadRune reads a single UTF-8 encoded Unicode character and returns the
  /// rune and its size in bytes. If the encoded rune is invalid, it consumes one byte
  /// and returns unicode.ReplacementChar (U+FFFD) with a size of 1.
  fn ReadRune(self: Ref<Reader>) -> Result<(rune, int), error>

  /// ReadSlice reads until the first occurrence of delim in the input,
  /// returning a slice pointing at the bytes in the buffer.
  /// The bytes stop being valid at the next read.
  /// If ReadSlice encounters an error before finding a delimiter,
  /// it returns all the data in the buffer and the error itself (often io.EOF).
  /// ReadSlice fails with error [ErrBufferFull] if the buffer fills without a delim.
  /// Because the data returned from ReadSlice will be overwritten
  /// by the next I/O operation, most clients should use
  /// [Reader.ReadBytes] or ReadString instead.
  /// ReadSlice returns err != nil if and only if line does not end in delim.
  fn ReadSlice(self: Ref<Reader>, delim: byte) -> Partial<Slice<byte>, error>

  /// ReadString reads until the first occurrence of delim in the input,
  /// returning a string containing the data up to and including the delimiter.
  /// If ReadString encounters an error before finding a delimiter,
  /// it returns the data read before the error and the error itself (often io.EOF).
  /// ReadString returns err != nil if and only if the returned data does not end in
  /// delim.
  /// For simple uses, a Scanner may be more convenient.
  fn ReadString(self: Ref<Reader>, delim: byte) -> Partial<string, error>

  /// Reset discards any buffered data, resets all state, and switches
  /// the buffered reader to read from r.
  /// Calling Reset on the zero value of [Reader] initializes the internal buffer
  /// to the default size.
  /// Calling b.Reset(b) (that is, resetting a [Reader] to itself) does nothing.
  fn Reset(self: Ref<Reader>, r: io.Reader)

  /// Size returns the size of the underlying buffer in bytes.
  fn Size(self: Ref<Reader>) -> int

  /// UnreadByte unreads the last byte. Only the most recently read byte can be unread.
  /// 
  /// UnreadByte returns an error if the most recent method called on the
  /// [Reader] was not a read operation. Notably, [Reader.Peek], [Reader.Discard], and [Reader.WriteTo] are not
  /// considered read operations.
  fn UnreadByte(self: Ref<Reader>) -> Result<(), error>

  /// UnreadRune unreads the last rune. If the most recent method called on
  /// the [Reader] was not a [Reader.ReadRune], [Reader.UnreadRune] returns an error. (In this
  /// regard it is stricter than [Reader.UnreadByte], which will unread the last byte
  /// from any read operation.)
  fn UnreadRune(self: Ref<Reader>) -> Result<(), error>

  /// WriteTo implements io.WriterTo.
  /// This may make multiple calls to the [Reader.Read] method of the underlying [Reader].
  /// If the underlying reader supports the [Reader.WriteTo] method,
  /// this calls the underlying [Reader.WriteTo] without buffering.
  fn WriteTo(self: Ref<Reader>, w: io.Writer) -> Partial<int64, error>
}

impl Scanner {
  /// Buffer controls memory allocation by the Scanner.
  /// It sets the initial buffer to use when scanning
  /// and the maximum size of buffer that may be allocated during scanning.
  /// The contents of the buffer are ignored.
  /// 
  /// The maximum token size must be less than the larger of max and cap(buf).
  /// If max <= cap(buf), [Scanner.Scan] will use this buffer only and do no allocation.
  /// 
  /// By default, [Scanner.Scan] uses an internal buffer and sets the
  /// maximum token size to [MaxScanTokenSize].
  /// 
  /// Buffer panics if it is called after scanning has started.
  fn Buffer(self: Ref<Scanner>, mut buf: Slice<byte>, max: int)

  /// Bytes returns the most recent token generated by a call to [Scanner.Scan].
  /// The underlying array may point to data that will be overwritten
  /// by a subsequent call to Scan. It does no allocation.
  fn Bytes(self: Ref<Scanner>) -> Slice<byte>

  /// Err returns the first non-EOF error that was encountered by the [Scanner].
  fn Err(self: Ref<Scanner>) -> Option<error>

  /// Scan advances the [Scanner] to the next token, which will then be
  /// available through the [Scanner.Bytes] or [Scanner.Text] method. It returns false when
  /// there are no more tokens, either by reaching the end of the input or an error.
  /// After Scan returns false, the [Scanner.Err] method will return any error that
  /// occurred during scanning, except that if it was [io.EOF], [Scanner.Err]
  /// will return nil.
  /// Scan panics if the split function returns too many empty
  /// tokens without advancing the input. This is a common error mode for
  /// scanners.
  fn Scan(self: Ref<Scanner>) -> bool

  /// Split sets the split function for the [Scanner].
  /// The default split function is [ScanLines].
  /// 
  /// Split panics if it is called after scanning has started.
  fn Split(self: Ref<Scanner>, split: SplitFunc)

  /// Text returns the most recent token generated by a call to [Scanner.Scan]
  /// as a newly allocated string holding its bytes.
  fn Text(self: Ref<Scanner>) -> string
}

impl Writer {
  /// Available returns how many bytes are unused in the buffer.
  fn Available(self: Ref<Writer>) -> int

  /// AvailableBuffer returns an empty buffer with b.Available() capacity.
  /// This buffer is intended to be appended to and
  /// passed to an immediately succeeding [Writer.Write] call.
  /// The buffer is only valid until the next write operation on b.
  fn AvailableBuffer(self: Ref<Writer>) -> Slice<byte>

  /// Buffered returns the number of bytes that have been written into the current buffer.
  fn Buffered(self: Ref<Writer>) -> int

  /// Flush writes any buffered data to the underlying [io.Writer].
  #[allow(unused_result)]
  fn Flush(self: Ref<Writer>) -> Result<(), error>

  /// ReadFrom implements [io.ReaderFrom]. If the underlying writer
  /// supports the ReadFrom method, this calls the underlying ReadFrom.
  /// If there is buffered data and an underlying ReadFrom, this fills
  /// the buffer and writes it before calling ReadFrom.
  fn ReadFrom(self: Ref<Writer>, r: io.Reader) -> Partial<int64, error>

  /// Reset discards any unflushed buffered data, clears any error, and
  /// resets b to write its output to w.
  /// Calling Reset on the zero value of [Writer] initializes the internal buffer
  /// to the default size.
  /// Calling w.Reset(w) (that is, resetting a [Writer] to itself) does nothing.
  fn Reset(self: Ref<Writer>, w: io.Writer)

  /// Size returns the size of the underlying buffer in bytes.
  fn Size(self: Ref<Writer>) -> int

  /// Write writes the contents of p into the buffer.
  /// It returns the number of bytes written.
  /// If nn < len(p), it also returns an error explaining
  /// why the write is short.
  fn Write(self: Ref<Writer>, p: Slice<byte>) -> Partial<int, error>

  /// WriteByte writes a single byte.
  fn WriteByte(self: Ref<Writer>, c: byte) -> Result<(), error>

  /// WriteRune writes a single Unicode code point, returning
  /// the number of bytes written and any error.
  fn WriteRune(self: Ref<Writer>, r: rune) -> Partial<int, error>

  /// WriteString writes a string.
  /// It returns the number of bytes written.
  /// If the count is less than len(s), it also returns an error explaining
  /// why the write is short.
  fn WriteString(self: Ref<Writer>, s: string) -> Partial<int, error>
}
