// Generated by Lisette bindgen
// Source: path/filepath (Go stdlib)
// Go: 1.25.5
// Lisette: 0.1.20

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
