@roberttlange/agentlens 0.1.0

package/node_modules/path-scurry/dist/commonjs/index.d.ts

@@ -0,0 +1,1115 @@
+import { LRUCache } from 'lru-cache';
+import { posix, win32 } from 'node:path';
+import { Minipass } from 'minipass';
+import type { Dirent, Stats } from 'node:fs';
+/**
+ * An object that will be used to override the default `fs`
+ * methods.  Any methods that are not overridden will use Node's
+ * built-in implementations.
+ *
+ * - lstatSync
+ * - readdir (callback `withFileTypes` Dirent variant, used for
+ *   readdirCB and most walks)
+ * - readdirSync
+ * - readlinkSync
+ * - realpathSync
+ * - promises: Object containing the following async methods:
+ *   - lstat
+ *   - readdir (Dirent variant only)
+ *   - readlink
+ *   - realpath
+ */
+export interface FSOption {
+    lstatSync?: (path: string) => Stats;
+    readdir?: (path: string, options: {
+        withFileTypes: true;
+    }, cb: (er: NodeJS.ErrnoException | null, entries?: Dirent[]) => any) => void;
+    readdirSync?: (path: string, options: {
+        withFileTypes: true;
+    }) => Dirent[];
+    readlinkSync?: (path: string) => string;
+    realpathSync?: (path: string) => string;
+    promises?: {
+        lstat?: (path: string) => Promise<Stats>;
+        readdir?: (path: string, options: {
+            withFileTypes: true;
+        }) => Promise<Dirent[]>;
+        readlink?: (path: string) => Promise<string>;
+        realpath?: (path: string) => Promise<string>;
+        [k: string]: any;
+    };
+    [k: string]: any;
+}
+interface FSValue {
+    lstatSync: (path: string) => Stats;
+    readdir: (path: string, options: {
+        withFileTypes: true;
+    }, cb: (er: NodeJS.ErrnoException | null, entries?: Dirent[]) => any) => void;
+    readdirSync: (path: string, options: {
+        withFileTypes: true;
+    }) => Dirent[];
+    readlinkSync: (path: string) => string;
+    realpathSync: (path: string) => string;
+    promises: {
+        lstat: (path: string) => Promise<Stats>;
+        readdir: (path: string, options: {
+            withFileTypes: true;
+        }) => Promise<Dirent[]>;
+        readlink: (path: string) => Promise<string>;
+        realpath: (path: string) => Promise<string>;
+        [k: string]: any;
+    };
+    [k: string]: any;
+}
+export type Type = 'Unknown' | 'FIFO' | 'CharacterDevice' | 'Directory' | 'BlockDevice' | 'File' | 'SymbolicLink' | 'Socket';
+/**
+ * Options that may be provided to the Path constructor
+ */
+export interface PathOpts {
+    fullpath?: string;
+    relative?: string;
+    relativePosix?: string;
+    parent?: PathBase;
+    /**
+     * See {@link FSOption}
+     */
+    fs?: FSOption;
+}
+/**
+ * An LRUCache for storing resolved path strings or Path objects.
+ * @internal
+ */
+export declare class ResolveCache extends LRUCache<string, string> {
+    constructor();
+}
+/**
+ * an LRUCache for storing child entries.
+ * @internal
+ */
+export declare class ChildrenCache extends LRUCache<PathBase, Children> {
+    constructor(maxSize?: number);
+}
+/**
+ * Array of Path objects, plus a marker indicating the first provisional entry
+ *
+ * @internal
+ */
+export type Children = PathBase[] & {
+    provisional: number;
+};
+declare const setAsCwd: unique symbol;
+/**
+ * Path objects are sort of like a super-powered
+ * {@link https://nodejs.org/docs/latest/api/fs.html#class-fsdirent fs.Dirent}
+ *
+ * Each one represents a single filesystem entry on disk, which may or may not
+ * exist. It includes methods for reading various types of information via
+ * lstat, readlink, and readdir, and caches all information to the greatest
+ * degree possible.
+ *
+ * Note that fs operations that would normally throw will instead return an
+ * "empty" value. This is in order to prevent excessive overhead from error
+ * stack traces.
+ */
+export declare abstract class PathBase implements Dirent {
+    #private;
+    /**
+     * the basename of this path
+     *
+     * **Important**: *always* test the path name against any test string
+     * usingthe {@link isNamed} method, and not by directly comparing this
+     * string. Otherwise, unicode path strings that the system sees as identical
+     * will not be properly treated as the same path, leading to incorrect
+     * behavior and possible security issues.
+     */
+    name: string;
+    /**
+     * the Path entry corresponding to the path root.
+     *
+     * @internal
+     */
+    root: PathBase;
+    /**
+     * All roots found within the current PathScurry family
+     *
+     * @internal
+     */
+    roots: {
+        [k: string]: PathBase;
+    };
+    /**
+     * a reference to the parent path, or undefined in the case of root entries
+     *
+     * @internal
+     */
+    parent?: PathBase;
+    /**
+     * boolean indicating whether paths are compared case-insensitively
+     * @internal
+     */
+    nocase: boolean;
+    /**
+     * boolean indicating that this path is the current working directory
+     * of the PathScurry collection that contains it.
+     */
+    isCWD: boolean;
+    /**
+     * the string or regexp used to split paths. On posix, it is `'/'`, and on
+     * windows it is a RegExp matching either `'/'` or `'\\'`
+     */
+    abstract splitSep: string | RegExp;
+    /**
+     * The path separator string to use when joining paths
+     */
+    abstract sep: string;
+    get dev(): number | undefined;
+    get mode(): number | undefined;
+    get nlink(): number | undefined;
+    get uid(): number | undefined;
+    get gid(): number | undefined;
+    get rdev(): number | undefined;
+    get blksize(): number | undefined;
+    get ino(): number | undefined;
+    get size(): number | undefined;
+    get blocks(): number | undefined;
+    get atimeMs(): number | undefined;
+    get mtimeMs(): number | undefined;
+    get ctimeMs(): number | undefined;
+    get birthtimeMs(): number | undefined;
+    get atime(): Date | undefined;
+    get mtime(): Date | undefined;
+    get ctime(): Date | undefined;
+    get birthtime(): Date | undefined;
+    /**
+     * This property is for compatibility with the Dirent class as of
+     * Node v20, where Dirent['parentPath'] refers to the path of the
+     * directory that was passed to readdir. For root entries, it's the path
+     * to the entry itself.
+     */
+    get parentPath(): string;
+    /**
+     * Deprecated alias for Dirent['parentPath'] Somewhat counterintuitively,
+     * this property refers to the *parent* path, not the path object itself.
+     *
+     * @deprecated
+     */
+    get path(): string;
+    /**
+     * Do not create new Path objects directly.  They should always be accessed
+     * via the PathScurry class or other methods on the Path class.
+     *
+     * @internal
+     */
+    constructor(name: string, type: number | undefined, root: PathBase | undefined, roots: {
+        [k: string]: PathBase;
+    }, nocase: boolean, children: ChildrenCache, opts: PathOpts);
+    /**
+     * Returns the depth of the Path object from its root.
+     *
+     * For example, a path at `/foo/bar` would have a depth of 2.
+     */
+    depth(): number;
+    /**
+     * @internal
+     */
+    abstract getRootString(path: string): string;
+    /**
+     * @internal
+     */
+    abstract getRoot(rootPath: string): PathBase;
+    /**
+     * @internal
+     */
+    abstract newChild(name: string, type?: number, opts?: PathOpts): PathBase;
+    /**
+     * @internal
+     */
+    childrenCache(): ChildrenCache;
+    /**
+     * Get the Path object referenced by the string path, resolved from this Path
+     */
+    resolve(path?: string): PathBase;
+    /**
+     * Returns the cached children Path objects, if still available.  If they
+     * have fallen out of the cache, then returns an empty array, and resets the
+     * READDIR_CALLED bit, so that future calls to readdir() will require an fs
+     * lookup.
+     *
+     * @internal
+     */
+    children(): Children;
+    /**
+     * Resolves a path portion and returns or creates the child Path.
+     *
+     * Returns `this` if pathPart is `''` or `'.'`, or `parent` if pathPart is
+     * `'..'`.
+     *
+     * This should not be called directly.  If `pathPart` contains any path
+     * separators, it will lead to unsafe undefined behavior.
+     *
+     * Use `Path.resolve()` instead.
+     *
+     * @internal
+     */
+    child(pathPart: string, opts?: PathOpts): PathBase;
+    /**
+     * The relative path from the cwd. If it does not share an ancestor with
+     * the cwd, then this ends up being equivalent to the fullpath()
+     */
+    relative(): string;
+    /**
+     * The relative path from the cwd, using / as the path separator.
+     * If it does not share an ancestor with
+     * the cwd, then this ends up being equivalent to the fullpathPosix()
+     * On posix systems, this is identical to relative().
+     */
+    relativePosix(): string;
+    /**
+     * The fully resolved path string for this Path entry
+     */
+    fullpath(): string;
+    /**
+     * On platforms other than windows, this is identical to fullpath.
+     *
+     * On windows, this is overridden to return the forward-slash form of the
+     * full UNC path.
+     */
+    fullpathPosix(): string;
+    /**
+     * Is the Path of an unknown type?
+     *
+     * Note that we might know *something* about it if there has been a previous
+     * filesystem operation, for example that it does not exist, or is not a
+     * link, or whether it has child entries.
+     */
+    isUnknown(): boolean;
+    isType(type: Type): boolean;
+    getType(): Type;
+    /**
+     * Is the Path a regular file?
+     */
+    isFile(): boolean;
+    /**
+     * Is the Path a directory?
+     */
+    isDirectory(): boolean;
+    /**
+     * Is the path a character device?
+     */
+    isCharacterDevice(): boolean;
+    /**
+     * Is the path a block device?
+     */
+    isBlockDevice(): boolean;
+    /**
+     * Is the path a FIFO pipe?
+     */
+    isFIFO(): boolean;
+    /**
+     * Is the path a socket?
+     */
+    isSocket(): boolean;
+    /**
+     * Is the path a symbolic link?
+     */
+    isSymbolicLink(): boolean;
+    /**
+     * Return the entry if it has been subject of a successful lstat, or
+     * undefined otherwise.
+     *
+     * Does not read the filesystem, so an undefined result *could* simply
+     * mean that we haven't called lstat on it.
+     */
+    lstatCached(): PathBase | undefined;
+    /**
+     * Return the cached link target if the entry has been the subject of a
+     * successful readlink, or undefined otherwise.
+     *
+     * Does not read the filesystem, so an undefined result *could* just mean we
+     * don't have any cached data. Only use it if you are very sure that a
+     * readlink() has been called at some point.
+     */
+    readlinkCached(): PathBase | undefined;
+    /**
+     * Returns the cached realpath target if the entry has been the subject
+     * of a successful realpath, or undefined otherwise.
+     *
+     * Does not read the filesystem, so an undefined result *could* just mean we
+     * don't have any cached data. Only use it if you are very sure that a
+     * realpath() has been called at some point.
+     */
+    realpathCached(): PathBase | undefined;
+    /**
+     * Returns the cached child Path entries array if the entry has been the
+     * subject of a successful readdir(), or [] otherwise.
+     *
+     * Does not read the filesystem, so an empty array *could* just mean we
+     * don't have any cached data. Only use it if you are very sure that a
+     * readdir() has been called recently enough to still be valid.
+     */
+    readdirCached(): PathBase[];
+    /**
+     * Return true if it's worth trying to readlink.  Ie, we don't (yet) have
+     * any indication that readlink will definitely fail.
+     *
+     * Returns false if the path is known to not be a symlink, if a previous
+     * readlink failed, or if the entry does not exist.
+     */
+    canReadlink(): boolean;
+    /**
+     * Return true if readdir has previously been successfully called on this
+     * path, indicating that cachedReaddir() is likely valid.
+     */
+    calledReaddir(): boolean;
+    /**
+     * Returns true if the path is known to not exist. That is, a previous lstat
+     * or readdir failed to verify its existence when that would have been
+     * expected, or a parent entry was marked either enoent or enotdir.
+     */
+    isENOENT(): boolean;
+    /**
+     * Return true if the path is a match for the given path name.  This handles
+     * case sensitivity and unicode normalization.
+     *
+     * Note: even on case-sensitive systems, it is **not** safe to test the
+     * equality of the `.name` property to determine whether a given pathname
+     * matches, due to unicode normalization mismatches.
+     *
+     * Always use this method instead of testing the `path.name` property
+     * directly.
+     */
+    isNamed(n: string): boolean;
+    /**
+     * Return the Path object corresponding to the target of a symbolic link.
+     *
+     * If the Path is not a symbolic link, or if the readlink call fails for any
+     * reason, `undefined` is returned.
+     *
+     * Result is cached, and thus may be outdated if the filesystem is mutated.
+     */
+    readlink(): Promise<PathBase | undefined>;
+    /**
+     * Synchronous {@link PathBase.readlink}
+     */
+    readlinkSync(): PathBase | undefined;
+    /**
+     * Call lstat() on this Path, and update all known information that can be
+     * determined.
+     *
+     * Note that unlike `fs.lstat()`, the returned value does not contain some
+     * information, such as `mode`, `dev`, `nlink`, and `ino`.  If that
+     * information is required, you will need to call `fs.lstat` yourself.
+     *
+     * If the Path refers to a nonexistent file, or if the lstat call fails for
+     * any reason, `undefined` is returned.  Otherwise the updated Path object is
+     * returned.
+     *
+     * Results are cached, and thus may be out of date if the filesystem is
+     * mutated.
+     */
+    lstat(): Promise<PathBase | undefined>;
+    /**
+     * synchronous {@link PathBase.lstat}
+     */
+    lstatSync(): PathBase | undefined;
+    /**
+     * Standard node-style callback interface to get list of directory entries.
+     *
+     * If the Path cannot or does not contain any children, then an empty array
+     * is returned.
+     *
+     * Results are cached, and thus may be out of date if the filesystem is
+     * mutated.
+     *
+     * @param cb The callback called with (er, entries).  Note that the `er`
+     * param is somewhat extraneous, as all readdir() errors are handled and
+     * simply result in an empty set of entries being returned.
+     * @param allowZalgo Boolean indicating that immediately known results should
+     * *not* be deferred with `queueMicrotask`. Defaults to `false`. Release
+     * zalgo at your peril, the dark pony lord is devious and unforgiving.
+     */
+    readdirCB(cb: (er: NodeJS.ErrnoException | null, entries: PathBase[]) => any, allowZalgo?: boolean): void;
+    /**
+     * Return an array of known child entries.
+     *
+     * If the Path cannot or does not contain any children, then an empty array
+     * is returned.
+     *
+     * Results are cached, and thus may be out of date if the filesystem is
+     * mutated.
+     */
+    readdir(): Promise<PathBase[]>;
+    /**
+     * synchronous {@link PathBase.readdir}
+     */
+    readdirSync(): PathBase[];
+    canReaddir(): boolean;
+    shouldWalk(dirs: Set<PathBase | undefined>, walkFilter?: (e: PathBase) => boolean): boolean;
+    /**
+     * Return the Path object corresponding to path as resolved
+     * by realpath(3).
+     *
+     * If the realpath call fails for any reason, `undefined` is returned.
+     *
+     * Result is cached, and thus may be outdated if the filesystem is mutated.
+     * On success, returns a Path object.
+     */
+    realpath(): Promise<PathBase | undefined>;
+    /**
+     * Synchronous {@link realpath}
+     */
+    realpathSync(): PathBase | undefined;
+    /**
+     * Internal method to mark this Path object as the scurry cwd,
+     * called by {@link PathScurry#chdir}
+     *
+     * @internal
+     */
+    [setAsCwd](oldCwd: PathBase): void;
+}
+/**
+ * Path class used on win32 systems
+ *
+ * Uses `'\\'` as the path separator for returned paths, either `'\\'` or `'/'`
+ * as the path separator for parsing paths.
+ */
+export declare class PathWin32 extends PathBase {
+    /**
+     * Separator for generating path strings.
+     */
+    sep: '\\';
+    /**
+     * Separator for parsing path strings.
+     */
+    splitSep: RegExp;
+    /**
+     * Do not create new Path objects directly.  They should always be accessed
+     * via the PathScurry class or other methods on the Path class.
+     *
+     * @internal
+     */
+    constructor(name: string, type: number | undefined, root: PathBase | undefined, roots: {
+        [k: string]: PathBase;
+    }, nocase: boolean, children: ChildrenCache, opts: PathOpts);
+    /**
+     * @internal
+     */
+    newChild(name: string, type?: number, opts?: PathOpts): PathWin32;
+    /**
+     * @internal
+     */
+    getRootString(path: string): string;
+    /**
+     * @internal
+     */
+    getRoot(rootPath: string): PathBase;
+    /**
+     * @internal
+     */
+    sameRoot(rootPath: string, compare?: string): boolean;
+}
+/**
+ * Path class used on all posix systems.
+ *
+ * Uses `'/'` as the path separator.
+ */
+export declare class PathPosix extends PathBase {
+    /**
+     * separator for parsing path strings
+     */
+    splitSep: '/';
+    /**
+     * separator for generating path strings
+     */
+    sep: '/';
+    /**
+     * Do not create new Path objects directly.  They should always be accessed
+     * via the PathScurry class or other methods on the Path class.
+     *
+     * @internal
+     */
+    constructor(name: string, type: number | undefined, root: PathBase | undefined, roots: {
+        [k: string]: PathBase;
+    }, nocase: boolean, children: ChildrenCache, opts: PathOpts);
+    /**
+     * @internal
+     */
+    getRootString(path: string): string;
+    /**
+     * @internal
+     */
+    getRoot(_rootPath: string): PathBase;
+    /**
+     * @internal
+     */
+    newChild(name: string, type?: number, opts?: PathOpts): PathPosix;
+}
+/**
+ * Options that may be provided to the PathScurry constructor
+ */
+export interface PathScurryOpts {
+    /**
+     * perform case-insensitive path matching. Default based on platform
+     * subclass.
+     */
+    nocase?: boolean;
+    /**
+     * Number of Path entries to keep in the cache of Path child references.
+     *
+     * Setting this higher than 65536 will dramatically increase the data
+     * consumption and construction time overhead of each PathScurry.
+     *
+     * Setting this value to 256 or lower will significantly reduce the data
+     * consumption and construction time overhead, but may also reduce resolve()
+     * and readdir() performance on large filesystems.
+     *
+     * Default `16384`.
+     */
+    childrenCacheSize?: number;
+    /**
+     * An object that overrides the built-in functions from the fs and
+     * fs/promises modules.
+     *
+     * See {@link FSOption}
+     */
+    fs?: FSOption;
+}
+/**
+ * The base class for all PathScurry classes, providing the interface for path
+ * resolution and filesystem operations.
+ *
+ * Typically, you should *not* instantiate this class directly, but rather one
+ * of the platform-specific classes, or the exported {@link PathScurry} which
+ * defaults to the current platform.
+ */
+export declare abstract class PathScurryBase {
+    #private;
+    /**
+     * The root Path entry for the current working directory of this Scurry
+     */
+    root: PathBase;
+    /**
+     * The string path for the root of this Scurry's current working directory
+     */
+    rootPath: string;
+    /**
+     * A collection of all roots encountered, referenced by rootPath
+     */
+    roots: {
+        [k: string]: PathBase;
+    };
+    /**
+     * The Path entry corresponding to this PathScurry's current working directory.
+     */
+    cwd: PathBase;
+    /**
+     * Perform path comparisons case-insensitively.
+     *
+     * Defaults true on Darwin and Windows systems, false elsewhere.
+     */
+    nocase: boolean;
+    /**
+     * The path separator used for parsing paths
+     *
+     * `'/'` on Posix systems, either `'/'` or `'\\'` on Windows
+     */
+    abstract sep: string | RegExp;
+    /**
+     * This class should not be instantiated directly.
+     *
+     * Use PathScurryWin32, PathScurryDarwin, PathScurryPosix, or PathScurry
+     *
+     * @internal
+     */
+    constructor(cwd: (URL | string) | undefined, pathImpl: typeof win32 | typeof posix, sep: string | RegExp, { nocase, childrenCacheSize, fs, }?: PathScurryOpts);
+    /**
+     * Get the depth of a provided path, string, or the cwd
+     */
+    depth(path?: Path | string): number;
+    /**
+     * Parse the root portion of a path string
+     *
+     * @internal
+     */
+    abstract parseRootPath(dir: string): string;
+    /**
+     * create a new Path to use as root during construction.
+     *
+     * @internal
+     */
+    abstract newRoot(fs: FSValue): PathBase;
+    /**
+     * Determine whether a given path string is absolute
+     */
+    abstract isAbsolute(p: string): boolean;
+    /**
+     * Return the cache of child entries.  Exposed so subclasses can create
+     * child Path objects in a platform-specific way.
+     *
+     * @internal
+     */
+    childrenCache(): ChildrenCache;
+    /**
+     * Resolve one or more path strings to a resolved string
+     *
+     * Same interface as require('path').resolve.
+     *
+     * Much faster than path.resolve() when called multiple times for the same
+     * path, because the resolved Path objects are cached.  Much slower
+     * otherwise.
+     */
+    resolve(...paths: string[]): string;
+    /**
+     * Resolve one or more path strings to a resolved string, returning
+     * the posix path.  Identical to .resolve() on posix systems, but on
+     * windows will return a forward-slash separated UNC path.
+     *
+     * Same interface as require('path').resolve.
+     *
+     * Much faster than path.resolve() when called multiple times for the same
+     * path, because the resolved Path objects are cached.  Much slower
+     * otherwise.
+     */
+    resolvePosix(...paths: string[]): string;
+    /**
+     * find the relative path from the cwd to the supplied path string or entry
+     */
+    relative(entry?: PathBase | string): string;
+    /**
+     * find the relative path from the cwd to the supplied path string or
+     * entry, using / as the path delimiter, even on Windows.
+     */
+    relativePosix(entry?: PathBase | string): string;
+    /**
+     * Return the basename for the provided string or Path object
+     */
+    basename(entry?: PathBase | string): string;
+    /**
+     * Return the dirname for the provided string or Path object
+     */
+    dirname(entry?: PathBase | string): string;
+    /**
+     * Return an array of known child entries.
+     *
+     * First argument may be either a string, or a Path object.
+     *
+     * If the Path cannot or does not contain any children, then an empty array
+     * is returned.
+     *
+     * Results are cached, and thus may be out of date if the filesystem is
+     * mutated.
+     *
+     * Unlike `fs.readdir()`, the `withFileTypes` option defaults to `true`. Set
+     * `{ withFileTypes: false }` to return strings.
+     */
+    readdir(): Promise<PathBase[]>;
+    readdir(opts: {
+        withFileTypes: true;
+    }): Promise<PathBase[]>;
+    readdir(opts: {
+        withFileTypes: false;
+    }): Promise<string[]>;
+    readdir(opts: {
+        withFileTypes: boolean;
+    }): Promise<PathBase[] | string[]>;
+    readdir(entry: PathBase | string): Promise<PathBase[]>;
+    readdir(entry: PathBase | string, opts: {
+        withFileTypes: true;
+    }): Promise<PathBase[]>;
+    readdir(entry: PathBase | string, opts: {
+        withFileTypes: false;
+    }): Promise<string[]>;
+    readdir(entry: PathBase | string, opts: {
+        withFileTypes: boolean;
+    }): Promise<PathBase[] | string[]>;
+    /**
+     * synchronous {@link PathScurryBase.readdir}
+     */
+    readdirSync(): PathBase[];
+    readdirSync(opts: {
+        withFileTypes: true;
+    }): PathBase[];
+    readdirSync(opts: {
+        withFileTypes: false;
+    }): string[];
+    readdirSync(opts: {
+        withFileTypes: boolean;
+    }): PathBase[] | string[];
+    readdirSync(entry: PathBase | string): PathBase[];
+    readdirSync(entry: PathBase | string, opts: {
+        withFileTypes: true;
+    }): PathBase[];
+    readdirSync(entry: PathBase | string, opts: {
+        withFileTypes: false;
+    }): string[];
+    readdirSync(entry: PathBase | string, opts: {
+        withFileTypes: boolean;
+    }): PathBase[] | string[];
+    /**
+     * Call lstat() on the string or Path object, and update all known
+     * information that can be determined.
+     *
+     * Note that unlike `fs.lstat()`, the returned value does not contain some
+     * information, such as `mode`, `dev`, `nlink`, and `ino`.  If that
+     * information is required, you will need to call `fs.lstat` yourself.
+     *
+     * If the Path refers to a nonexistent file, or if the lstat call fails for
+     * any reason, `undefined` is returned.  Otherwise the updated Path object is
+     * returned.
+     *
+     * Results are cached, and thus may be out of date if the filesystem is
+     * mutated.
+     */
+    lstat(entry?: string | PathBase): Promise<PathBase | undefined>;
+    /**
+     * synchronous {@link PathScurryBase.lstat}
+     */
+    lstatSync(entry?: string | PathBase): PathBase | undefined;
+    /**
+     * Return the Path object or string path corresponding to the target of a
+     * symbolic link.
+     *
+     * If the path is not a symbolic link, or if the readlink call fails for any
+     * reason, `undefined` is returned.
+     *
+     * Result is cached, and thus may be outdated if the filesystem is mutated.
+     *
+     * `{withFileTypes}` option defaults to `false`.
+     *
+     * On success, returns a Path object if `withFileTypes` option is true,
+     * otherwise a string.
+     */
+    readlink(): Promise<string | undefined>;
+    readlink(opt: {
+        withFileTypes: false;
+    }): Promise<string | undefined>;
+    readlink(opt: {
+        withFileTypes: true;
+    }): Promise<PathBase | undefined>;
+    readlink(opt: {
+        withFileTypes: boolean;
+    }): Promise<PathBase | string | undefined>;
+    readlink(entry: string | PathBase, opt?: {
+        withFileTypes: false;
+    }): Promise<string | undefined>;
+    readlink(entry: string | PathBase, opt: {
+        withFileTypes: true;
+    }): Promise<PathBase | undefined>;
+    readlink(entry: string | PathBase, opt: {
+        withFileTypes: boolean;
+    }): Promise<string | PathBase | undefined>;
+    /**
+     * synchronous {@link PathScurryBase.readlink}
+     */
+    readlinkSync(): string | undefined;
+    readlinkSync(opt: {
+        withFileTypes: false;
+    }): string | undefined;
+    readlinkSync(opt: {
+        withFileTypes: true;
+    }): PathBase | undefined;
+    readlinkSync(opt: {
+        withFileTypes: boolean;
+    }): PathBase | string | undefined;
+    readlinkSync(entry: string | PathBase, opt?: {
+        withFileTypes: false;
+    }): string | undefined;
+    readlinkSync(entry: string | PathBase, opt: {
+        withFileTypes: true;
+    }): PathBase | undefined;
+    readlinkSync(entry: string | PathBase, opt: {
+        withFileTypes: boolean;
+    }): string | PathBase | undefined;
+    /**
+     * Return the Path object or string path corresponding to path as resolved
+     * by realpath(3).
+     *
+     * If the realpath call fails for any reason, `undefined` is returned.
+     *
+     * Result is cached, and thus may be outdated if the filesystem is mutated.
+     *
+     * `{withFileTypes}` option defaults to `false`.
+     *
+     * On success, returns a Path object if `withFileTypes` option is true,
+     * otherwise a string.
+     */
+    realpath(): Promise<string | undefined>;
+    realpath(opt: {
+        withFileTypes: false;
+    }): Promise<string | undefined>;
+    realpath(opt: {
+        withFileTypes: true;
+    }): Promise<PathBase | undefined>;
+    realpath(opt: {
+        withFileTypes: boolean;
+    }): Promise<PathBase | string | undefined>;
+    realpath(entry: string | PathBase, opt?: {
+        withFileTypes: false;
+    }): Promise<string | undefined>;
+    realpath(entry: string | PathBase, opt: {
+        withFileTypes: true;
+    }): Promise<PathBase | undefined>;
+    realpath(entry: string | PathBase, opt: {
+        withFileTypes: boolean;
+    }): Promise<string | PathBase | undefined>;
+    realpathSync(): string | undefined;
+    realpathSync(opt: {
+        withFileTypes: false;
+    }): string | undefined;
+    realpathSync(opt: {
+        withFileTypes: true;
+    }): PathBase | undefined;
+    realpathSync(opt: {
+        withFileTypes: boolean;
+    }): PathBase | string | undefined;
+    realpathSync(entry: string | PathBase, opt?: {
+        withFileTypes: false;
+    }): string | undefined;
+    realpathSync(entry: string | PathBase, opt: {
+        withFileTypes: true;
+    }): PathBase | undefined;
+    realpathSync(entry: string | PathBase, opt: {
+        withFileTypes: boolean;
+    }): string | PathBase | undefined;
+    /**
+     * Asynchronously walk the directory tree, returning an array of
+     * all path strings or Path objects found.
+     *
+     * Note that this will be extremely memory-hungry on large filesystems.
+     * In such cases, it may be better to use the stream or async iterator
+     * walk implementation.
+     */
+    walk(): Promise<PathBase[]>;
+    walk(opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset): Promise<PathBase[]>;
+    walk(opts: WalkOptionsWithFileTypesFalse): Promise<string[]>;
+    walk(opts: WalkOptions): Promise<string[] | PathBase[]>;
+    walk(entry: string | PathBase): Promise<PathBase[]>;
+    walk(entry: string | PathBase, opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset): Promise<PathBase[]>;
+    walk(entry: string | PathBase, opts: WalkOptionsWithFileTypesFalse): Promise<string[]>;
+    walk(entry: string | PathBase, opts: WalkOptions): Promise<PathBase[] | string[]>;
+    /**
+     * Synchronously walk the directory tree, returning an array of
+     * all path strings or Path objects found.
+     *
+     * Note that this will be extremely memory-hungry on large filesystems.
+     * In such cases, it may be better to use the stream or async iterator
+     * walk implementation.
+     */
+    walkSync(): PathBase[];
+    walkSync(opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset): PathBase[];
+    walkSync(opts: WalkOptionsWithFileTypesFalse): string[];
+    walkSync(opts: WalkOptions): string[] | PathBase[];
+    walkSync(entry: string | PathBase): PathBase[];
+    walkSync(entry: string | PathBase, opts: WalkOptionsWithFileTypesUnset | WalkOptionsWithFileTypesTrue): PathBase[];
+    walkSync(entry: string | PathBase, opts: WalkOptionsWithFileTypesFalse): string[];
+    walkSync(entry: string | PathBase, opts: WalkOptions): PathBase[] | string[];
+    /**
+     * Support for `for await`
+     *
+     * Alias for {@link PathScurryBase.iterate}
+     *
+     * Note: As of Node 19, this is very slow, compared to other methods of
+     * walking.  Consider using {@link PathScurryBase.stream} if memory overhead
+     * and backpressure are concerns, or {@link PathScurryBase.walk} if not.
+     */
+    [Symbol.asyncIterator](): AsyncGenerator<PathBase, void, void>;
+    /**
+     * Async generator form of {@link PathScurryBase.walk}
+     *
+     * Note: As of Node 19, this is very slow, compared to other methods of
+     * walking, especially if most/all of the directory tree has been previously
+     * walked.  Consider using {@link PathScurryBase.stream} if memory overhead
+     * and backpressure are concerns, or {@link PathScurryBase.walk} if not.
+     */
+    iterate(): AsyncGenerator<PathBase, void, void>;
+    iterate(opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset): AsyncGenerator<PathBase, void, void>;
+    iterate(opts: WalkOptionsWithFileTypesFalse): AsyncGenerator<string, void, void>;
+    iterate(opts: WalkOptions): AsyncGenerator<string | PathBase, void, void>;
+    iterate(entry: string | PathBase): AsyncGenerator<PathBase, void, void>;
+    iterate(entry: string | PathBase, opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset): AsyncGenerator<PathBase, void, void>;
+    iterate(entry: string | PathBase, opts: WalkOptionsWithFileTypesFalse): AsyncGenerator<string, void, void>;
+    iterate(entry: string | PathBase, opts: WalkOptions): AsyncGenerator<PathBase | string, void, void>;
+    /**
+     * Iterating over a PathScurry performs a synchronous walk.
+     *
+     * Alias for {@link PathScurryBase.iterateSync}
+     */
+    [Symbol.iterator](): Generator<PathBase, void, void>;
+    iterateSync(): Generator<PathBase, void, void>;
+    iterateSync(opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset): Generator<PathBase, void, void>;
+    iterateSync(opts: WalkOptionsWithFileTypesFalse): Generator<string, void, void>;
+    iterateSync(opts: WalkOptions): Generator<string | PathBase, void, void>;
+    iterateSync(entry: string | PathBase): Generator<PathBase, void, void>;
+    iterateSync(entry: string | PathBase, opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset): Generator<PathBase, void, void>;
+    iterateSync(entry: string | PathBase, opts: WalkOptionsWithFileTypesFalse): Generator<string, void, void>;
+    iterateSync(entry: string | PathBase, opts: WalkOptions): Generator<PathBase | string, void, void>;
+    /**
+     * Stream form of {@link PathScurryBase.walk}
+     *
+     * Returns a Minipass stream that emits {@link PathBase} objects by default,
+     * or strings if `{ withFileTypes: false }` is set in the options.
+     */
+    stream(): Minipass<PathBase>;
+    stream(opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset): Minipass<PathBase>;
+    stream(opts: WalkOptionsWithFileTypesFalse): Minipass<string>;
+    stream(opts: WalkOptions): Minipass<string | PathBase>;
+    stream(entry: string | PathBase): Minipass<PathBase>;
+    stream(entry: string | PathBase, opts: WalkOptionsWithFileTypesUnset | WalkOptionsWithFileTypesTrue): Minipass<PathBase>;
+    stream(entry: string | PathBase, opts: WalkOptionsWithFileTypesFalse): Minipass<string>;
+    stream(entry: string | PathBase, opts: WalkOptions): Minipass<string> | Minipass<PathBase>;
+    /**
+     * Synchronous form of {@link PathScurryBase.stream}
+     *
+     * Returns a Minipass stream that emits {@link PathBase} objects by default,
+     * or strings if `{ withFileTypes: false }` is set in the options.
+     *
+     * Will complete the walk in a single tick if the stream is consumed fully.
+     * Otherwise, will pause as needed for stream backpressure.
+     */
+    streamSync(): Minipass<PathBase>;
+    streamSync(opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset): Minipass<PathBase>;
+    streamSync(opts: WalkOptionsWithFileTypesFalse): Minipass<string>;
+    streamSync(opts: WalkOptions): Minipass<string | PathBase>;
+    streamSync(entry: string | PathBase): Minipass<PathBase>;
+    streamSync(entry: string | PathBase, opts: WalkOptionsWithFileTypesUnset | WalkOptionsWithFileTypesTrue): Minipass<PathBase>;
+    streamSync(entry: string | PathBase, opts: WalkOptionsWithFileTypesFalse): Minipass<string>;
+    streamSync(entry: string | PathBase, opts: WalkOptions): Minipass<string> | Minipass<PathBase>;
+    chdir(path?: string | Path): void;
+}
+/**
+ * Options provided to all walk methods.
+ */
+export interface WalkOptions {
+    /**
+     * Return results as {@link PathBase} objects rather than strings.
+     * When set to false, results are fully resolved paths, as returned by
+     * {@link PathBase.fullpath}.
+     * @default true
+     */
+    withFileTypes?: boolean;
+    /**
+     *  Attempt to read directory entries from symbolic links. Otherwise, only
+     *  actual directories are traversed. Regardless of this setting, a given
+     *  target path will only ever be walked once, meaning that a symbolic link
+     *  to a previously traversed directory will never be followed.
+     *
+     *  Setting this imposes a slight performance penalty, because `readlink`
+     *  must be called on all symbolic links encountered, in order to avoid
+     *  infinite cycles.
+     * @default false
+     */
+    follow?: boolean;
+    /**
+     * Only return entries where the provided function returns true.
+     *
+     * This will not prevent directories from being traversed, even if they do
+     * not pass the filter, though it will prevent directories themselves from
+     * being included in the result set.  See {@link walkFilter}
+     *
+     * Asynchronous functions are not supported here.
+     *
+     * By default, if no filter is provided, all entries and traversed
+     * directories are included.
+     */
+    filter?: (entry: PathBase) => boolean;
+    /**
+     * Only traverse directories (and in the case of {@link follow} being set to
+     * true, symbolic links to directories) if the provided function returns
+     * true.
+     *
+     * This will not prevent directories from being included in the result set,
+     * even if they do not pass the supplied filter function.  See {@link filter}
+     * to do that.
+     *
+     * Asynchronous functions are not supported here.
+     */
+    walkFilter?: (entry: PathBase) => boolean;
+}
+export type WalkOptionsWithFileTypesUnset = WalkOptions & {
+    withFileTypes?: undefined;
+};
+export type WalkOptionsWithFileTypesTrue = WalkOptions & {
+    withFileTypes: true;
+};
+export type WalkOptionsWithFileTypesFalse = WalkOptions & {
+    withFileTypes: false;
+};
+/**
+ * Windows implementation of {@link PathScurryBase}
+ *
+ * Defaults to case insensitve, uses `'\\'` to generate path strings.  Uses
+ * {@link PathWin32} for Path objects.
+ */
+export declare class PathScurryWin32 extends PathScurryBase {
+    /**
+     * separator for generating path strings
+     */
+    sep: '\\';
+    constructor(cwd?: URL | string, opts?: PathScurryOpts);
+    /**
+     * @internal
+     */
+    parseRootPath(dir: string): string;
+    /**
+     * @internal
+     */
+    newRoot(fs: FSValue): PathWin32;
+    /**
+     * Return true if the provided path string is an absolute path
+     */
+    isAbsolute(p: string): boolean;
+}
+/**
+ * {@link PathScurryBase} implementation for all posix systems other than Darwin.
+ *
+ * Defaults to case-sensitive matching, uses `'/'` to generate path strings.
+ *
+ * Uses {@link PathPosix} for Path objects.
+ */
+export declare class PathScurryPosix extends PathScurryBase {
+    /**
+     * separator for generating path strings
+     */
+    sep: '/';
+    constructor(cwd?: URL | string, opts?: PathScurryOpts);
+    /**
+     * @internal
+     */
+    parseRootPath(_dir: string): string;
+    /**
+     * @internal
+     */
+    newRoot(fs: FSValue): PathPosix;
+    /**
+     * Return true if the provided path string is an absolute path
+     */
+    isAbsolute(p: string): boolean;
+}
+/**
+ * {@link PathScurryBase} implementation for Darwin (macOS) systems.
+ *
+ * Defaults to case-insensitive matching, uses `'/'` for generating path
+ * strings.
+ *
+ * Uses {@link PathPosix} for Path objects.
+ */
+export declare class PathScurryDarwin extends PathScurryPosix {
+    constructor(cwd?: URL | string, opts?: PathScurryOpts);
+}
+/**
+ * Default {@link PathBase} implementation for the current platform.
+ *
+ * {@link PathWin32} on Windows systems, {@link PathPosix} on all others.
+ */
+export declare const Path: typeof PathWin32 | typeof PathPosix;
+export type Path = PathBase | InstanceType<typeof Path>;
+/**
+ * Default {@link PathScurryBase} implementation for the current platform.
+ *
+ * {@link PathScurryWin32} on Windows systems, {@link PathScurryDarwin} on
+ * Darwin (macOS) systems, {@link PathScurryPosix} on all others.
+ */
+export declare const PathScurry: typeof PathScurryWin32 | typeof PathScurryDarwin | typeof PathScurryPosix;
+export type PathScurry = PathScurryBase | InstanceType<typeof PathScurry>;
+export {};
+//# sourceMappingURL=index.d.ts.map