// Generated by Lisette bindgen
// Source: net/url (Go stdlib)
// Go: 1.25.10
// Lisette: 0.2.1
/// 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>
/// Parse parses a raw url into a [URL] structure.
///
/// The url may be relative (a path, without a host) or absolute
/// (starting with a scheme). Trying to parse a hostname and path
/// without a scheme is invalid but may not necessarily return an
/// error, due to parsing ambiguities.
pub fn Parse(rawURL: string) -> Result<Ref<URL>, error>
/// ParseQuery parses the URL-encoded query string and returns
/// a map listing the values specified for each key.
/// ParseQuery always returns a non-nil map containing all the
/// valid query parameters found; err describes the first decoding error
/// encountered, if any.
///
/// Query is expected to be a list of key=value settings separated by ampersands.
/// A setting without an equals sign is interpreted as a key set to an empty
/// value.
/// Settings containing a non-URL-encoded semicolon are considered invalid.
pub fn ParseQuery(query: string) -> Result<Values, error>
/// ParseRequestURI parses a raw url into a [URL] structure. It assumes that
/// url was received in an HTTP request, so the url is interpreted
/// only as an absolute URI or an absolute path.
/// The string url is assumed not to have a #fragment suffix.
/// (Web browsers strip #fragment before sending the URL to a web server.)
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>
/// User returns a [Userinfo] containing the provided username
/// and no password set.
pub fn User(username: string) -> Ref<Userinfo>
/// UserPassword returns a [Userinfo] containing the provided username
/// and password.
///
/// This functionality should only be used with legacy web sites.
/// RFC 2396 warns that interpreting Userinfo this way
/// “is NOT RECOMMENDED, because the passing of authentication
/// information in clear text (such as URI) has proven to be a
/// security risk in almost every case where it has been used.”
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<byte>) -> Result<Slice<byte>, 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<byte>, 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<byte>) -> 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)
}