declare namespace locatePath {
    interface Options {
        /**
        Current working directory.

        @default process.cwd()
        */
        readonly cwd?: string;

        /**
        Type of path to match.

        @default 'file'
        */
        readonly type?: 'file' | 'directory';

        /**
        Allow symbolic links to match if they point to the requested path type.

        @default true
        */
        readonly allowSymlinks?: boolean;
    }

    interface AsyncOptions extends Options {
        /**
        Number of concurrently pending promises. Minimum: `1`.

        @default Infinity
        */
        readonly concurrency?: number;

        /**
        Preserve `paths` order when searching.

        Disable this to improve performance if you don't care about the order.

        @default true
        */
        readonly preserveOrder?: boolean;
    }
}

declare const locatePath: {
    /**
    Synchronously get the first path that exists on disk of multiple paths.

    @param paths - Paths to check.
    @returns The first path that exists or `undefined` if none exists.
    */
    sync: (
        paths: Iterable<string>,
        options?: locatePath.Options
    ) => string | undefined;

    /**
    Get the first path that exists on disk of multiple paths.

    @param paths - Paths to check.
    @returns The first path that exists or `undefined` if none exists.

    @example
    ```
    import locatePath = require('locate-path');

    const files = [
        'unicorn.png',
        'rainbow.png', // Only this one actually exists on disk
        'pony.png'
    ];

    (async () => {
        console(await locatePath(files));
        //=> 'rainbow'
    })();
    ```
    */
    (paths: Iterable<string>, options?: locatePath.AsyncOptions): Promise<
    string | undefined
    >;
};

export = locatePath;