// Generated by Lisette bindgen
// Source: errors (Go stdlib)
// Go: 1.25.10
// Lisette: 0.3.0

/// As finds the first error in err's tree that matches target, and if one is found, sets
/// target to that error value and returns true. Otherwise, it returns false.
/// 
/// The tree consists of err itself, followed by the errors obtained by repeatedly
/// calling its Unwrap() error or Unwrap() []error method. When err wraps multiple
/// errors, As examines err followed by a depth-first traversal of its children.
/// 
/// An error matches target if the error's concrete value is assignable to the value
/// pointed to by target, or if the error has a method As(any) bool such that
/// As(target) returns true. In the latter case, the As method is responsible for
/// setting target.
/// 
/// An error type might provide an As method so it can be treated as if it were a
/// different error type.
/// 
/// As panics if target is not a non-nil pointer to either a type that implements
/// error, or to any interface type.
pub fn As(err: error, target: Unknown) -> bool

/// Is reports whether any error in err's tree matches target.
/// 
/// The tree consists of err itself, followed by the errors obtained by repeatedly
/// calling its Unwrap() error or Unwrap() []error method. When err wraps multiple
/// errors, Is examines err followed by a depth-first traversal of its children.
/// 
/// An error is considered to match a target if it is equal to that target or if
/// it implements a method Is(error) bool such that Is(target) returns true.
/// 
/// An error type might provide an Is method so it can be treated as equivalent
/// to an existing error. For example, if MyError defines
/// 
/// 	func (m MyError) Is(target error) bool { return target == fs.ErrExist }
/// 
/// then Is(MyError{}, fs.ErrExist) returns true. See [syscall.Errno.Is] for
/// an example in the standard library. An Is method should only shallowly
/// compare err and the target and not call [Unwrap] on either.
pub fn Is(err: error, target: error) -> bool

/// Join returns an error that wraps the given errors.
/// Any nil error values are discarded.
/// Join returns nil if every value in errs is nil.
/// The error formats as the concatenation of the strings obtained
/// by calling the Error method of each element of errs, with a newline
/// between each string.
/// 
/// A non-nil error returned by Join implements the Unwrap() []error method.
pub fn Join(errs: VarArgs<error>) -> Option<error>

/// New returns an error that formats as the given text.
/// Each call to New returns a distinct error value even if the text is identical.
pub fn New(text: string) -> error

/// Unwrap returns the result of calling the Unwrap method on err, if err's
/// type contains an Unwrap method returning error.
/// Otherwise, Unwrap returns nil.
/// 
/// Unwrap only calls a method of the form "Unwrap() error".
/// In particular Unwrap does not unwrap errors returned by [Join].
pub fn Unwrap(err: error) -> Option<error>

/// ErrUnsupported indicates that a requested operation cannot be performed,
/// because it is unsupported. For example, a call to [os.Link] when using a
/// file system that does not support hard links.
/// 
/// Functions and methods should not return this error but should instead
/// return an error including appropriate context that satisfies
/// 
/// 	errors.Is(err, errors.ErrUnsupported)
/// 
/// either by directly wrapping ErrUnsupported or by implementing an [Is] method.
/// 
/// Functions and methods should document the cases in which an error
/// wrapping this will be returned.
pub var ErrUnsupported: error
