// Generated by Lisette bindgen
// Source: net/url (Go stdlib)
// Go: 1.25.5
// Lisette: 0.1.20

/// JoinPath returns a [URL] string with the provided path elements joined to
/// the existing path of base and the resulting path cleaned of any ./ or ../ elements.
pub fn JoinPath(base: string, elem: VarArgs<string>) -> Result<string, error>

pub fn Parse(rawURL: string) -> Result<Ref<URL>, error>

pub fn ParseQuery(query: string) -> Result<Values, error>

pub fn ParseRequestURI(rawURL: string) -> Result<Ref<URL>, error>

/// PathEscape escapes the string so it can be safely placed inside a [URL] path segment,
/// replacing special characters (including /) with %XX sequences as needed.
pub fn PathEscape(s: string) -> string

/// PathUnescape does the inverse transformation of [PathEscape],
/// converting each 3-byte encoded substring of the form "%AB" into the
/// hex-decoded byte 0xAB. It returns an error if any % is not followed
/// by two hexadecimal digits.
/// 
/// PathUnescape is identical to [QueryUnescape] except that it does not
/// unescape '+' to ' ' (space).
pub fn PathUnescape(s: string) -> Result<string, error>

/// QueryEscape escapes the string so it can be safely placed
/// inside a [URL] query.
pub fn QueryEscape(s: string) -> string

/// QueryUnescape does the inverse transformation of [QueryEscape],
/// converting each 3-byte encoded substring of the form "%AB" into the
/// hex-decoded byte 0xAB.
/// It returns an error if any % is not followed by two hexadecimal
/// digits.
pub fn QueryUnescape(s: string) -> Result<string, error>

pub fn User(username: string) -> Ref<Userinfo>

pub fn UserPassword(username: string, password: string) -> Ref<Userinfo>

/// Error reports an error and the operation and URL that caused it.
pub struct Error {
  pub Op: string,
  pub URL: string,
  pub Err: error,
}

pub struct EscapeError(string)

pub struct InvalidHostError(string)

/// A URL represents a parsed URL (technically, a URI reference).
/// 
/// The general form represented is:
/// 
/// 	[scheme:][//[userinfo@]host][/]path[?query][#fragment]
/// 
/// URLs that do not start with a slash after the scheme are interpreted as:
/// 
/// 	scheme:opaque[?query][#fragment]
/// 
/// The Host field contains the host and port subcomponents of the URL.
/// When the port is present, it is separated from the host with a colon.
/// When the host is an IPv6 address, it must be enclosed in square brackets:
/// "[fe80::1]:80". The [net.JoinHostPort] function combines a host and port
/// into a string suitable for the Host field, adding square brackets to
/// the host when necessary.
/// 
/// Note that the Path field is stored in decoded form: /%47%6f%2f becomes /Go/.
/// A consequence is that it is impossible to tell which slashes in the Path were
/// slashes in the raw URL and which were %2f. This distinction is rarely important,
/// but when it is, the code should use the [URL.EscapedPath] method, which preserves
/// the original encoding of Path.
/// 
/// The RawPath field is an optional field which is only set when the default
/// encoding of Path is different from the escaped path. See the EscapedPath method
/// for more details.
/// 
/// URL's String method uses the EscapedPath method to obtain the path.
pub struct URL {
  pub Scheme: string,
  pub Opaque: string,
  pub User: Option<Ref<Userinfo>>,
  pub Host: string,
  pub Path: string,
  pub RawPath: string,
  pub OmitHost: bool,
  pub ForceQuery: bool,
  pub RawQuery: string,
  pub Fragment: string,
  pub RawFragment: string,
}

/// The Userinfo type is an immutable encapsulation of username and
/// password details for a [URL]. An existing Userinfo value is guaranteed
/// to have a username set (potentially empty, as allowed by RFC 2396),
/// and optionally a password.
pub type Userinfo

/// Values maps a string key to a list of values.
/// It is typically used for query parameters and form values.
/// Unlike in the http.Header map, the keys in a Values map
/// are case-sensitive.
pub struct Values(Map<string, Slice<string>>)

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

  fn Temporary(self: Ref<Error>) -> bool

  fn Timeout(self: Ref<Error>) -> bool

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

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

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

impl URL {
  fn AppendBinary(self: Ref<URL>, mut b: Slice<uint8>) -> Result<Slice<uint8>, error>

  /// EscapedFragment returns the escaped form of u.Fragment.
  /// In general there are multiple possible escaped forms of any fragment.
  /// EscapedFragment returns u.RawFragment when it is a valid escaping of u.Fragment.
  /// Otherwise EscapedFragment ignores u.RawFragment and computes an escaped
  /// form on its own.
  /// The [URL.String] method uses EscapedFragment to construct its result.
  /// In general, code should call EscapedFragment instead of
  /// reading u.RawFragment directly.
  fn EscapedFragment(self: Ref<URL>) -> string

  /// EscapedPath returns the escaped form of u.Path.
  /// In general there are multiple possible escaped forms of any path.
  /// EscapedPath returns u.RawPath when it is a valid escaping of u.Path.
  /// Otherwise EscapedPath ignores u.RawPath and computes an escaped
  /// form on its own.
  /// The [URL.String] and [URL.RequestURI] methods use EscapedPath to construct
  /// their results.
  /// In general, code should call EscapedPath instead of
  /// reading u.RawPath directly.
  fn EscapedPath(self: Ref<URL>) -> string

  /// Hostname returns u.Host, stripping any valid port number if present.
  /// 
  /// If the result is enclosed in square brackets, as literal IPv6 addresses are,
  /// the square brackets are removed from the result.
  fn Hostname(self: Ref<URL>) -> string

  /// IsAbs reports whether the [URL] is absolute.
  /// Absolute means that it has a non-empty scheme.
  fn IsAbs(self: Ref<URL>) -> bool

  /// JoinPath returns a new [URL] with the provided path elements joined to
  /// any existing path and the resulting path cleaned of any ./ or ../ elements.
  /// Any sequences of multiple / characters will be reduced to a single /.
  fn JoinPath(self: Ref<URL>, elem: VarArgs<string>) -> Ref<URL>

  fn MarshalBinary(self: Ref<URL>) -> Result<Slice<uint8>, error>

  /// Parse parses a [URL] in the context of the receiver. The provided URL
  /// may be relative or absolute. Parse returns nil, err on parse
  /// failure, otherwise its return value is the same as [URL.ResolveReference].
  fn Parse(self: Ref<URL>, ref: string) -> Result<Ref<URL>, error>

  /// Port returns the port part of u.Host, without the leading colon.
  /// 
  /// If u.Host doesn't contain a valid numeric port, Port returns an empty string.
  fn Port(self: Ref<URL>) -> string

  /// Query parses RawQuery and returns the corresponding values.
  /// It silently discards malformed value pairs.
  /// To check errors use [ParseQuery].
  fn Query(self: Ref<URL>) -> Values

  /// Redacted is like [URL.String] but replaces any password with "xxxxx".
  /// Only the password in u.User is redacted.
  fn Redacted(self: Ref<URL>) -> string

  /// RequestURI returns the encoded path?query or opaque?query
  /// string that would be used in an HTTP request for u.
  fn RequestURI(self: Ref<URL>) -> string

  /// ResolveReference resolves a URI reference to an absolute URI from
  /// an absolute base URI u, per RFC 3986 Section 5.2. The URI reference
  /// may be relative or absolute. ResolveReference always returns a new
  /// [URL] instance, even if the returned URL is identical to either the
  /// base or reference. If ref is an absolute URL, then ResolveReference
  /// ignores base and returns a copy of ref.
  fn ResolveReference(self: Ref<URL>, ref: Ref<URL>) -> Ref<URL>

  /// String reassembles the [URL] into a valid URL string.
  /// The general form of the result is one of:
  /// 
  /// 	scheme:opaque?query#fragment
  /// 	scheme://userinfo@host/path?query#fragment
  /// 
  /// If u.Opaque is non-empty, String uses the first form;
  /// otherwise it uses the second form.
  /// Any non-ASCII characters in host are escaped.
  /// To obtain the path, String uses u.EscapedPath().
  /// 
  /// In the second form, the following rules apply:
  ///   - if u.Scheme is empty, scheme: is omitted.
  ///   - if u.User is nil, userinfo@ is omitted.
  ///   - if u.Host is empty, host/ is omitted.
  ///   - if u.Scheme and u.Host are empty and u.User is nil,
  ///     the entire scheme://userinfo@host/ is omitted.
  ///   - if u.Host is non-empty and u.Path begins with a /,
  ///     the form host/path does not add its own /.
  ///   - if u.RawQuery is empty, ?query is omitted.
  ///   - if u.Fragment is empty, #fragment is omitted.
  fn String(self: Ref<URL>) -> string

  fn UnmarshalBinary(self: Ref<URL>, text: Slice<uint8>) -> Result<(), error>
}

impl Userinfo {
  /// Password returns the password in case it is set, and whether it is set.
  fn Password(self: Ref<Userinfo>) -> Option<string>

  /// String returns the encoded userinfo information in the standard form
  /// of "username[:password]".
  fn String(self: Ref<Userinfo>) -> string

  /// Username returns the username.
  fn Username(self: Ref<Userinfo>) -> string
}

impl Values {
  /// Add adds the value to key. 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)

  /// Encode encodes the values into “URL encoded” form
  /// ("bar=baz&foo=quux") sorted by key.
  fn Encode(self) -> string

  /// Get gets the first value associated with the given key.
  /// If there are no values associated with the key, Get returns
  /// the empty string. To access multiple values, use the map
  /// directly.
  fn Get(self, key: string) -> string

  /// Has checks whether a given key is set.
  fn Has(self, key: string) -> bool

  /// Set sets the key to value. It replaces any existing
  /// values.
  fn Set(self, key: string, value: string)
}
