// Generated by Lisette bindgen
// Source: path/filepath (Go stdlib)
// Go: 1.25.5
// Lisette: 0.1.9
import "go:io/fs"
/// Abs returns an absolute representation of path.
/// If the path is not absolute it will be joined with the current
/// working directory to turn it into an absolute path. The absolute
/// path name for a given file is not guaranteed to be unique.
/// Abs calls [Clean] on the result.
pub fn Abs(path: string) -> Result<string, error>
/// Base returns the last element of path.
/// Trailing path separators are removed before extracting the last element.
/// If the path is empty, Base returns ".".
/// If the path consists entirely of separators, Base returns a single separator.
pub fn Base(path: string) -> string
/// Clean returns the shortest path name equivalent to path
/// by purely lexical processing. It applies the following rules
/// iteratively until no further processing can be done:
///
/// 1. Replace multiple [Separator] elements with a single one.
/// 2. Eliminate each . path name element (the current directory).
/// 3. Eliminate each inner .. path name element (the parent directory)
/// along with the non-.. element that precedes it.
/// 4. Eliminate .. elements that begin a rooted path:
/// that is, replace "/.." by "/" at the beginning of a path,
/// assuming Separator is '/'.
///
/// The returned path ends in a slash only if it represents a root directory,
/// such as "/" on Unix or `C:\` on Windows.
///
/// Finally, any occurrences of slash are replaced by Separator.
///
/// If the result of this process is an empty string, Clean
/// returns the string ".".
///
/// On Windows, Clean does not modify the volume name other than to replace
/// occurrences of "/" with `\`.
/// For example, Clean("//host/share/../x") returns `\\host\share\x`.
///
/// See also Rob Pike, “Lexical File Names in Plan 9 or
/// Getting Dot-Dot Right,”
/// https://9p.io/sys/doc/lexnames.html
pub fn Clean(path: string) -> string
/// Dir returns all but the last element of path, typically the path's directory.
/// After dropping the final element, Dir calls [Clean] on the path and trailing
/// slashes are removed.
/// If the path is empty, Dir returns ".".
/// If the path consists entirely of separators, Dir returns a single separator.
/// The returned path does not end in a separator unless it is the root directory.
pub fn Dir(path: string) -> string
/// EvalSymlinks returns the path name after the evaluation of any symbolic
/// links.
/// If path is relative the result will be relative to the current directory,
/// unless one of the components is an absolute symbolic link.
/// EvalSymlinks calls [Clean] on the result.
pub fn EvalSymlinks(path: string) -> Result<string, error>
/// Ext returns the file name extension used by path.
/// The extension is the suffix beginning at the final dot
/// in the final element of path; it is empty if there is
/// no dot.
pub fn Ext(path: string) -> string
/// FromSlash returns the result of replacing each slash ('/') character
/// in path with a separator character. Multiple slashes are replaced
/// by multiple separators.
///
/// See also the Localize function, which converts a slash-separated path
/// as used by the io/fs package to an operating system path.
pub fn FromSlash(path: string) -> string
/// Glob returns the names of all files matching pattern or nil
/// if there is no matching file. The syntax of patterns is the same
/// as in [Match]. The pattern may describe hierarchical names such as
/// /usr/*/bin/ed (assuming the [Separator] is '/').
///
/// Glob ignores file system errors such as I/O errors reading directories.
/// The only possible returned error is [ErrBadPattern], when pattern
/// is malformed.
pub fn Glob(pattern: string) -> Result<Slice<string>, error>
/// HasPrefix exists for historical compatibility and should not be used.
///
/// Deprecated: HasPrefix does not respect path boundaries and
/// does not ignore case when required.
pub fn HasPrefix(p: string, prefix: string) -> bool
/// IsAbs reports whether the path is absolute.
pub fn IsAbs(path: string) -> bool
/// IsLocal reports whether path, using lexical analysis only, has all of these properties:
///
/// - is within the subtree rooted at the directory in which path is evaluated
/// - is not an absolute path
/// - is not empty
/// - on Windows, is not a reserved name such as "NUL"
///
/// If IsLocal(path) returns true, then
/// Join(base, path) will always produce a path contained within base and
/// Clean(path) will always produce an unrooted path with no ".." path elements.
///
/// IsLocal is a purely lexical operation.
/// In particular, it does not account for the effect of any symbolic links
/// that may exist in the filesystem.
pub fn IsLocal(path: string) -> bool
/// Join joins any number of path elements into a single path,
/// separating them with an OS specific [Separator]. Empty elements
/// are ignored. The result is Cleaned. However, if the argument
/// list is empty or all its elements are empty, Join returns
/// an empty string.
/// On Windows, the result will only be a UNC path if the first
/// non-empty element is a UNC path.
pub fn Join(elem: VarArgs<string>) -> string
/// Localize converts a slash-separated path into an operating system path.
/// The input path must be a valid path as reported by [io/fs.ValidPath].
///
/// Localize returns an error if the path cannot be represented by the operating system.
/// For example, the path a\b is rejected on Windows, on which \ is a separator
/// character and cannot be part of a filename.
///
/// The path returned by Localize will always be local, as reported by IsLocal.
pub fn Localize(path: string) -> Result<string, error>
/// Match reports whether name matches the shell file name pattern.
/// The pattern syntax is:
///
/// pattern:
/// { term }
/// term:
/// '*' matches any sequence of non-Separator characters
/// '?' matches any single non-Separator character
/// '[' [ '^' ] { character-range } ']'
/// character class (must be non-empty)
/// c matches character c (c != '*', '?', '\\', '[')
/// '\\' c matches character c
///
/// character-range:
/// c matches character c (c != '\\', '-', ']')
/// '\\' c matches character c
/// lo '-' hi matches character c for lo <= c <= hi
///
/// Match requires pattern to match all of name, not just a substring.
/// The only possible returned error is [ErrBadPattern], when pattern
/// is malformed.
///
/// On Windows, escaping is disabled. Instead, '\\' is treated as
/// path separator.
pub fn Match(pattern: string, name: string) -> Result<bool, error>
/// Rel returns a relative path that is lexically equivalent to targpath when
/// joined to basepath with an intervening separator. That is,
/// [Join](basepath, Rel(basepath, targpath)) is equivalent to targpath itself.
/// On success, the returned path will always be relative to basepath,
/// even if basepath and targpath share no elements.
/// An error is returned if targpath can't be made relative to basepath or if
/// knowing the current working directory would be necessary to compute it.
/// Rel calls [Clean] on the result.
pub fn Rel(basepath: string, targpath: string) -> Result<string, error>
/// Split splits path immediately following the final [Separator],
/// separating it into a directory and file name component.
/// If there is no Separator in path, Split returns an empty dir
/// and file set to path.
/// The returned values have the property that path = dir+file.
pub fn Split(path: string) -> (string, string)
/// SplitList splits a list of paths joined by the OS-specific [ListSeparator],
/// usually found in PATH or GOPATH environment variables.
/// Unlike strings.Split, SplitList returns an empty slice when passed an empty
/// string.
pub fn SplitList(path: string) -> Slice<string>
/// ToSlash returns the result of replacing each separator character
/// in path with a slash ('/') character. Multiple separators are
/// replaced by multiple slashes.
pub fn ToSlash(path: string) -> string
/// VolumeName returns leading volume name.
/// Given "C:\foo\bar" it returns "C:" on Windows.
/// Given "\\host\share\foo" it returns "\\host\share".
/// On other platforms it returns "".
pub fn VolumeName(path: string) -> string
/// Walk walks the file tree rooted at root, calling fn for each file or
/// directory in the tree, including root.
///
/// All errors that arise visiting files and directories are filtered by fn:
/// see the [WalkFunc] documentation for details.
///
/// The files are walked in lexical order, which makes the output deterministic
/// but requires Walk to read an entire directory into memory before proceeding
/// to walk that directory.
///
/// Walk does not follow symbolic links.
///
/// Walk is less efficient than [WalkDir], introduced in Go 1.16,
/// which avoids calling os.Lstat on every visited file or directory.
pub fn Walk(root: string, fn_: WalkFunc) -> Result<(), error>
/// WalkDir walks the file tree rooted at root, calling fn for each file or
/// directory in the tree, including root.
///
/// All errors that arise visiting files and directories are filtered by fn:
/// see the [fs.WalkDirFunc] documentation for details.
///
/// The files are walked in lexical order, which makes the output deterministic
/// but requires WalkDir to read an entire directory into memory before proceeding
/// to walk that directory.
///
/// WalkDir does not follow symbolic links.
///
/// WalkDir calls fn with paths that use the separator character appropriate
/// for the operating system. This is unlike [io/fs.WalkDir], which always
/// uses slash separated paths.
pub fn WalkDir(root: string, fn_: fs.WalkDirFunc) -> Result<(), error>
/// WalkFunc is the type of the function called by [Walk] to visit each
/// file or directory.
///
/// The path argument contains the argument to Walk as a prefix.
/// That is, if Walk is called with root argument "dir" and finds a file
/// named "a" in that directory, the walk function will be called with
/// argument "dir/a".
///
/// The directory and file are joined with Join, which may clean the
/// directory name: if Walk is called with the root argument "x/../dir"
/// and finds a file named "a" in that directory, the walk function will
/// be called with argument "dir/a", not "x/../dir/a".
///
/// The info argument is the fs.FileInfo for the named path.
///
/// The error result returned by the function controls how Walk continues.
/// If the function returns the special value [SkipDir], Walk skips the
/// current directory (path if info.IsDir() is true, otherwise path's
/// parent directory). If the function returns the special value [SkipAll],
/// Walk skips all remaining files and directories. Otherwise, if the function
/// returns a non-nil error, Walk stops entirely and returns that error.
///
/// The err argument reports an error related to path, signaling that Walk
/// will not walk into that directory. The function can decide how to
/// handle that error; as described earlier, returning the error will
/// cause Walk to stop walking the entire tree.
///
/// Walk calls the function with a non-nil err argument in two cases.
///
/// First, if an [os.Lstat] on the root directory or any directory or file
/// in the tree fails, Walk calls the function with path set to that
/// directory or file's path, info set to nil, and err set to the error
/// from os.Lstat.
///
/// Second, if a directory's Readdirnames method fails, Walk calls the
/// function with path set to the directory's path, info, set to an
/// [fs.FileInfo] describing the directory, and err set to the error from
/// Readdirnames.
pub type WalkFunc = fn(string, fs.FileInfo, error) -> Result<(), error>
const ListSeparator = 58
const Separator = 47
/// ErrBadPattern indicates a pattern was malformed.
pub var ErrBadPattern: error
/// SkipAll is used as a return value from [WalkFunc] to indicate that
/// all remaining files and directories are to be skipped. It is not returned
/// as an error by any function.
pub var SkipAll: error
/// SkipDir is used as a return value from [WalkFunc] to indicate that
/// the directory named in the call is to be skipped. It is not returned
/// as an error by any function.
pub var SkipDir: error