// Generated by Lisette bindgen
// Source: net/textproto (Go stdlib)
// Go: 1.25.5
// Lisette: 0.1.14

import "go:bufio"
import "go:io"

/// CanonicalMIMEHeaderKey returns the canonical format of the
/// MIME header key s. The canonicalization converts the first
/// letter and any letter following a hyphen to upper case;
/// the rest are converted to lowercase. For example, the
/// canonical key for "accept-encoding" is "Accept-Encoding".
/// MIME header keys are assumed to be ASCII only.
/// If s contains a space or invalid header field bytes as
/// defined by RFC 9112, it is returned without modifications.
pub fn CanonicalMIMEHeaderKey(s: string) -> string

pub fn Dial(network: string, addr: string) -> Result<Ref<Conn>, error>

pub fn NewConn(conn: io.ReadWriteCloser) -> Ref<Conn>

pub fn NewReader(r: Ref<bufio.Reader>) -> Ref<Reader>

pub fn NewWriter(w: Ref<bufio.Writer>) -> Ref<Writer>

/// TrimBytes returns b without leading and trailing ASCII space.
pub fn TrimBytes(b: Slice<uint8>) -> Slice<uint8>

/// TrimString returns s without leading and trailing ASCII space.
pub fn TrimString(s: string) -> string

/// A Conn represents a textual network protocol connection.
/// It consists of a [Reader] and [Writer] to manage I/O
/// and a [Pipeline] to sequence concurrent requests on the connection.
/// These embedded types carry methods with them;
/// see the documentation of those types for details.
pub struct Conn {
  pub Reader: Reader,
  pub Writer: Writer,
  pub Pipeline: Pipeline,
}

/// An Error represents a numeric error response from a server.
pub struct Error {
  pub Code: int,
  pub Msg: string,
}

/// A MIMEHeader represents a MIME-style header mapping
/// keys to sets of values.
pub struct MIMEHeader(Map<string, Slice<string>>)

/// A Pipeline manages a pipelined in-order request/response sequence.
/// 
/// To use a Pipeline p to manage multiple clients on a connection,
/// each client should run:
/// 
/// 	id := p.Next()	// take a number
/// 
/// 	p.StartRequest(id)	// wait for turn to send request
/// 	«send request»
/// 	p.EndRequest(id)	// notify Pipeline that request is sent
/// 
/// 	p.StartResponse(id)	// wait for turn to read response
/// 	«read response»
/// 	p.EndResponse(id)	// notify Pipeline that response is read
/// 
/// A pipelined server can use the same calls to ensure that
/// responses computed in parallel are written in the correct order.
pub type Pipeline

/// A ProtocolError describes a protocol violation such
/// as an invalid response or a hung-up connection.
pub struct ProtocolError(string)

/// A Reader implements convenience methods for reading requests
/// or responses from a text protocol network connection.
pub struct Reader {
  pub R: Option<Ref<bufio.Reader>>,
}

/// A Writer implements convenience methods for writing
/// requests or responses to a text protocol network connection.
pub struct Writer {
  pub W: Option<Ref<bufio.Writer>>,
}

impl Conn {
  /// Close closes the connection.
  #[allow(unused_result)]
  fn Close(self: Ref<Conn>) -> Result<(), error>

  /// Cmd is a convenience method that sends a command after
  /// waiting its turn in the pipeline. The command text is the
  /// result of formatting format with args and appending \r\n.
  /// Cmd returns the id of the command, for use with StartResponse and EndResponse.
  /// 
  /// For example, a client might run a HELP command that returns a dot-body
  /// by using:
  /// 
  /// 	id, err := c.Cmd("HELP")
  /// 	if err != nil {
  /// 		return nil, err
  /// 	}
  /// 
  /// 	c.StartResponse(id)
  /// 	defer c.EndResponse(id)
  /// 
  /// 	if _, _, err = c.ReadCodeLine(110); err != nil {
  /// 		return nil, err
  /// 	}
  /// 	text, err := c.ReadDotBytes()
  /// 	if err != nil {
  /// 		return nil, err
  /// 	}
  /// 	return c.ReadCodeLine(250)
  fn Cmd(self: Ref<Conn>, format: string, args: VarArgs<Unknown>) -> Result<uint, error>

  /// DotReader returns a new [Reader] that satisfies Reads using the
  /// decoded text of a dot-encoded block read from r.
  /// The returned Reader is only valid until the next call
  /// to a method on r.
  /// 
  /// Dot encoding is a common framing used for data blocks
  /// in text protocols such as SMTP.  The data consists of a sequence
  /// of lines, each of which ends in "\r\n".  The sequence itself
  /// ends at a line containing just a dot: ".\r\n".  Lines beginning
  /// with a dot are escaped with an additional dot to avoid
  /// looking like the end of the sequence.
  /// 
  /// The decoded form returned by the Reader's Read method
  /// rewrites the "\r\n" line endings into the simpler "\n",
  /// removes leading dot escapes if present, and stops with error [io.EOF]
  /// after consuming (and discarding) the end-of-sequence line.
  fn DotReader(self: Ref<Conn>) -> io.Reader

  /// DotWriter returns a writer that can be used to write a dot-encoding to w.
  /// It takes care of inserting leading dots when necessary,
  /// translating line-ending \n into \r\n, and adding the final .\r\n line
  /// when the DotWriter is closed. The caller should close the
  /// DotWriter before the next call to a method on w.
  /// 
  /// See the documentation for the [Reader.DotReader] method for details about dot-encoding.
  fn DotWriter(self: Ref<Conn>) -> io.WriteCloser

  /// EndRequest notifies p that the request with the given id has been sent
  /// (or, if this is a server, received).
  fn EndRequest(self: Ref<Conn>, id: uint)

  /// EndResponse notifies p that the response with the given id has been received
  /// (or, if this is a server, sent).
  fn EndResponse(self: Ref<Conn>, id: uint)

  /// Next returns the next id for a request/response pair.
  fn Next(self: Ref<Conn>) -> uint

  /// PrintfLine writes the formatted output followed by \r\n.
  fn PrintfLine(self: Ref<Conn>, format: string, args: VarArgs<Unknown>) -> Result<(), error>

  /// ReadCodeLine reads a response code line of the form
  /// 
  /// 	code message
  /// 
  /// where code is a three-digit status code and the message
  /// extends to the rest of the line. An example of such a line is:
  /// 
  /// 	220 plan9.bell-labs.com ESMTP
  /// 
  /// If the prefix of the status does not match the digits in expectCode,
  /// ReadCodeLine returns with err set to &Error{code, message}.
  /// For example, if expectCode is 31, an error will be returned if
  /// the status is not in the range [310,319].
  /// 
  /// If the response is multi-line, ReadCodeLine returns an error.
  /// 
  /// An expectCode <= 0 disables the check of the status code.
  fn ReadCodeLine(self: Ref<Conn>, expectCode: int) -> Result<(int, string), error>

  /// ReadContinuedLine reads a possibly continued line from r,
  /// eliding the final trailing ASCII white space.
  /// Lines after the first are considered continuations if they
  /// begin with a space or tab character. In the returned data,
  /// continuation lines are separated from the previous line
  /// only by a single space: the newline and leading white space
  /// are removed.
  /// 
  /// For example, consider this input:
  /// 
  /// 	Line 1
  /// 	  continued...
  /// 	Line 2
  /// 
  /// The first call to ReadContinuedLine will return "Line 1 continued..."
  /// and the second will return "Line 2".
  /// 
  /// Empty lines are never continued.
  fn ReadContinuedLine(self: Ref<Conn>) -> Result<string, error>

  /// ReadContinuedLineBytes is like [Reader.ReadContinuedLine] but
  /// returns a []byte instead of a string.
  fn ReadContinuedLineBytes(self: Ref<Conn>) -> Result<Slice<uint8>, error>

  /// ReadDotBytes reads a dot-encoding and returns the decoded data.
  /// 
  /// See the documentation for the [Reader.DotReader] method for details about dot-encoding.
  fn ReadDotBytes(self: Ref<Conn>) -> Result<Slice<uint8>, error>

  /// ReadDotLines reads a dot-encoding and returns a slice
  /// containing the decoded lines, with the final \r\n or \n elided from each.
  /// 
  /// See the documentation for the [Reader.DotReader] method for details about dot-encoding.
  fn ReadDotLines(self: Ref<Conn>) -> Result<Slice<string>, error>

  /// ReadLine reads a single line from r,
  /// eliding the final \n or \r\n from the returned string.
  fn ReadLine(self: Ref<Conn>) -> Result<string, error>

  /// ReadLineBytes is like [Reader.ReadLine] but returns a []byte instead of a string.
  fn ReadLineBytes(self: Ref<Conn>) -> Result<Slice<uint8>, error>

  /// ReadMIMEHeader reads a MIME-style header from r.
  /// The header is a sequence of possibly continued Key: Value lines
  /// ending in a blank line.
  /// The returned map m maps [CanonicalMIMEHeaderKey](key) to a
  /// sequence of values in the same order encountered in the input.
  /// 
  /// For example, consider this input:
  /// 
  /// 	My-Key: Value 1
  /// 	Long-Key: Even
  /// 	       Longer Value
  /// 	My-Key: Value 2
  /// 
  /// Given that input, ReadMIMEHeader returns the map:
  /// 
  /// 	map[string][]string{
  /// 		"My-Key": {"Value 1", "Value 2"},
  /// 		"Long-Key": {"Even Longer Value"},
  /// 	}
  fn ReadMIMEHeader(self: Ref<Conn>) -> Result<MIMEHeader, error>

  /// ReadResponse reads a multi-line response of the form:
  /// 
  /// 	code-message line 1
  /// 	code-message line 2
  /// 	...
  /// 	code message line n
  /// 
  /// where code is a three-digit status code. The first line starts with the
  /// code and a hyphen. The response is terminated by a line that starts
  /// with the same code followed by a space. Each line in message is
  /// separated by a newline (\n).
  /// 
  /// See page 36 of RFC 959 (https://www.ietf.org/rfc/rfc959.txt) for
  /// details of another form of response accepted:
  /// 
  /// 	code-message line 1
  /// 	message line 2
  /// 	...
  /// 	code message line n
  /// 
  /// If the prefix of the status does not match the digits in expectCode,
  /// ReadResponse returns with err set to &Error{code, message}.
  /// For example, if expectCode is 31, an error will be returned if
  /// the status is not in the range [310,319].
  /// 
  /// An expectCode <= 0 disables the check of the status code.
  fn ReadResponse(self: Ref<Conn>, expectCode: int) -> Result<(int, string), error>

  /// StartRequest blocks until it is time to send (or, if this is a server, receive)
  /// the request with the given id.
  fn StartRequest(self: Ref<Conn>, id: uint)

  /// StartResponse blocks until it is time to receive (or, if this is a server, send)
  /// the request with the given id.
  fn StartResponse(self: Ref<Conn>, id: uint)
}

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

impl MIMEHeader {
  /// Add adds the key, value pair to the header.
  /// It appends to any existing values associated with key.
  fn Add(self, key: string, value: string)

  /// Del deletes the values associated with key.
  fn Del(self, key: string)

  /// Get gets the first value associated with the given key.
  /// It is case insensitive; [CanonicalMIMEHeaderKey] is used
  /// to canonicalize the provided key.
  /// If there are no values associated with the key, Get returns "".
  /// To use non-canonical keys, access the map directly.
  fn Get(self, key: string) -> string

  /// Set sets the header entries associated with key to
  /// the single element value. It replaces any existing
  /// values associated with key.
  fn Set(self, key: string, value: string)

  /// Values returns all values associated with the given key.
  /// It is case insensitive; [CanonicalMIMEHeaderKey] is
  /// used to canonicalize the provided key. To use non-canonical
  /// keys, access the map directly.
  /// The returned slice is not a copy.
  fn Values(self, key: string) -> Slice<string>
}

impl Pipeline {
  /// EndRequest notifies p that the request with the given id has been sent
  /// (or, if this is a server, received).
  fn EndRequest(self: Ref<Pipeline>, id: uint)

  /// EndResponse notifies p that the response with the given id has been received
  /// (or, if this is a server, sent).
  fn EndResponse(self: Ref<Pipeline>, id: uint)

  /// Next returns the next id for a request/response pair.
  fn Next(self: Ref<Pipeline>) -> uint

  /// StartRequest blocks until it is time to send (or, if this is a server, receive)
  /// the request with the given id.
  fn StartRequest(self: Ref<Pipeline>, id: uint)

  /// StartResponse blocks until it is time to receive (or, if this is a server, send)
  /// the request with the given id.
  fn StartResponse(self: Ref<Pipeline>, id: uint)
}

impl ProtocolError {
  fn Error(self) -> string
}

impl Reader {
  /// DotReader returns a new [Reader] that satisfies Reads using the
  /// decoded text of a dot-encoded block read from r.
  /// The returned Reader is only valid until the next call
  /// to a method on r.
  /// 
  /// Dot encoding is a common framing used for data blocks
  /// in text protocols such as SMTP.  The data consists of a sequence
  /// of lines, each of which ends in "\r\n".  The sequence itself
  /// ends at a line containing just a dot: ".\r\n".  Lines beginning
  /// with a dot are escaped with an additional dot to avoid
  /// looking like the end of the sequence.
  /// 
  /// The decoded form returned by the Reader's Read method
  /// rewrites the "\r\n" line endings into the simpler "\n",
  /// removes leading dot escapes if present, and stops with error [io.EOF]
  /// after consuming (and discarding) the end-of-sequence line.
  fn DotReader(self: Ref<Reader>) -> io.Reader

  /// ReadCodeLine reads a response code line of the form
  /// 
  /// 	code message
  /// 
  /// where code is a three-digit status code and the message
  /// extends to the rest of the line. An example of such a line is:
  /// 
  /// 	220 plan9.bell-labs.com ESMTP
  /// 
  /// If the prefix of the status does not match the digits in expectCode,
  /// ReadCodeLine returns with err set to &Error{code, message}.
  /// For example, if expectCode is 31, an error will be returned if
  /// the status is not in the range [310,319].
  /// 
  /// If the response is multi-line, ReadCodeLine returns an error.
  /// 
  /// An expectCode <= 0 disables the check of the status code.
  fn ReadCodeLine(self: Ref<Reader>, expectCode: int) -> Result<(int, string), error>

  /// ReadContinuedLine reads a possibly continued line from r,
  /// eliding the final trailing ASCII white space.
  /// Lines after the first are considered continuations if they
  /// begin with a space or tab character. In the returned data,
  /// continuation lines are separated from the previous line
  /// only by a single space: the newline and leading white space
  /// are removed.
  /// 
  /// For example, consider this input:
  /// 
  /// 	Line 1
  /// 	  continued...
  /// 	Line 2
  /// 
  /// The first call to ReadContinuedLine will return "Line 1 continued..."
  /// and the second will return "Line 2".
  /// 
  /// Empty lines are never continued.
  fn ReadContinuedLine(self: Ref<Reader>) -> Result<string, error>

  /// ReadContinuedLineBytes is like [Reader.ReadContinuedLine] but
  /// returns a []byte instead of a string.
  fn ReadContinuedLineBytes(self: Ref<Reader>) -> Result<Slice<uint8>, error>

  /// ReadDotBytes reads a dot-encoding and returns the decoded data.
  /// 
  /// See the documentation for the [Reader.DotReader] method for details about dot-encoding.
  fn ReadDotBytes(self: Ref<Reader>) -> Result<Slice<uint8>, error>

  /// ReadDotLines reads a dot-encoding and returns a slice
  /// containing the decoded lines, with the final \r\n or \n elided from each.
  /// 
  /// See the documentation for the [Reader.DotReader] method for details about dot-encoding.
  fn ReadDotLines(self: Ref<Reader>) -> Result<Slice<string>, error>

  /// ReadLine reads a single line from r,
  /// eliding the final \n or \r\n from the returned string.
  fn ReadLine(self: Ref<Reader>) -> Result<string, error>

  /// ReadLineBytes is like [Reader.ReadLine] but returns a []byte instead of a string.
  fn ReadLineBytes(self: Ref<Reader>) -> Result<Slice<uint8>, error>

  /// ReadMIMEHeader reads a MIME-style header from r.
  /// The header is a sequence of possibly continued Key: Value lines
  /// ending in a blank line.
  /// The returned map m maps [CanonicalMIMEHeaderKey](key) to a
  /// sequence of values in the same order encountered in the input.
  /// 
  /// For example, consider this input:
  /// 
  /// 	My-Key: Value 1
  /// 	Long-Key: Even
  /// 	       Longer Value
  /// 	My-Key: Value 2
  /// 
  /// Given that input, ReadMIMEHeader returns the map:
  /// 
  /// 	map[string][]string{
  /// 		"My-Key": {"Value 1", "Value 2"},
  /// 		"Long-Key": {"Even Longer Value"},
  /// 	}
  fn ReadMIMEHeader(self: Ref<Reader>) -> Result<MIMEHeader, error>

  /// ReadResponse reads a multi-line response of the form:
  /// 
  /// 	code-message line 1
  /// 	code-message line 2
  /// 	...
  /// 	code message line n
  /// 
  /// where code is a three-digit status code. The first line starts with the
  /// code and a hyphen. The response is terminated by a line that starts
  /// with the same code followed by a space. Each line in message is
  /// separated by a newline (\n).
  /// 
  /// See page 36 of RFC 959 (https://www.ietf.org/rfc/rfc959.txt) for
  /// details of another form of response accepted:
  /// 
  /// 	code-message line 1
  /// 	message line 2
  /// 	...
  /// 	code message line n
  /// 
  /// If the prefix of the status does not match the digits in expectCode,
  /// ReadResponse returns with err set to &Error{code, message}.
  /// For example, if expectCode is 31, an error will be returned if
  /// the status is not in the range [310,319].
  /// 
  /// An expectCode <= 0 disables the check of the status code.
  fn ReadResponse(self: Ref<Reader>, expectCode: int) -> Result<(int, string), error>
}

impl Writer {
  /// DotWriter returns a writer that can be used to write a dot-encoding to w.
  /// It takes care of inserting leading dots when necessary,
  /// translating line-ending \n into \r\n, and adding the final .\r\n line
  /// when the DotWriter is closed. The caller should close the
  /// DotWriter before the next call to a method on w.
  /// 
  /// See the documentation for the [Reader.DotReader] method for details about dot-encoding.
  fn DotWriter(self: Ref<Writer>) -> io.WriteCloser

  /// PrintfLine writes the formatted output followed by \r\n.
  fn PrintfLine(self: Ref<Writer>, format: string, args: VarArgs<Unknown>) -> Result<(), error>
}
