source: trip-planner-front/node_modules/globby/index.d.ts@ eed0bf8

import {Options as FastGlobOptions, Entry as FastGlobEntry} from 'fast-glob';

declare namespace globby {
        type ExpandDirectoriesOption =
                | boolean
                | readonly string[]
                | {files?: readonly string[]; extensions?: readonly string[]};

        type Entry = FastGlobEntry;

        interface GlobbyOptions extends FastGlobOptions {
                /**
                If set to `true`, `globby` will automatically glob directories for you. If you define an `Array` it will only glob files that matches the patterns inside the `Array`. You can also define an `Object` with `files` and `extensions` like in the example below.

                Note that if you set this option to `false`, you won't get back matched directories unless you set `onlyFiles: false`.

                @default true

                @example
                ```
                import globby = require('globby');

                (async () => {
                        const paths = await globby('images', {
                                expandDirectories: {
                                        files: ['cat', 'unicorn', '*.jpg'],
                                        extensions: ['png']
                                }
                        });

                        console.log(paths);
                        //=> ['cat.png', 'unicorn.png', 'cow.jpg', 'rainbow.jpg']
                })();
                ```
                */
                readonly expandDirectories?: ExpandDirectoriesOption;

                /**
                Respect ignore patterns in `.gitignore` files that apply to the globbed files.

                @default false
                */
                readonly gitignore?: boolean;
        }

        interface GlobTask {
                readonly pattern: string;
                readonly options: GlobbyOptions;
        }

        interface GitignoreOptions {
                readonly cwd?: string;
                readonly ignore?: readonly string[];
        }

        type FilterFunction = (path: string) => boolean;
}

interface Gitignore {
        /**
        @returns A filter function indicating whether a given path is ignored via a `.gitignore` file.
        */
        sync: (options?: globby.GitignoreOptions) => globby.FilterFunction;

        /**
        `.gitignore` files matched by the ignore config are not used for the resulting filter function.

        @returns A filter function indicating whether a given path is ignored via a `.gitignore` file.

        @example
        ```
        import {gitignore} from 'globby';

        (async () => {
                const isIgnored = await gitignore();
                console.log(isIgnored('some/file'));
        })();
        ```
        */
        (options?: globby.GitignoreOptions): Promise<globby.FilterFunction>;
}

declare const globby: {
        /**
        Find files and directories using glob patterns.

        Note that glob patterns can only contain forward-slashes, not backward-slashes, so if you want to construct a glob pattern from path components, you need to use `path.posix.join()` instead of `path.join()`.

        @param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
        @param options - See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones in this package.
        @returns The matching paths.
        */
        sync: ((
                patterns: string | readonly string[],
                options: globby.GlobbyOptions & {objectMode: true}
        ) => globby.Entry[]) & ((
                patterns: string | readonly string[],
                options?: globby.GlobbyOptions
        ) => string[]);

        /**
        Find files and directories using glob patterns.

        Note that glob patterns can only contain forward-slashes, not backward-slashes, so if you want to construct a glob pattern from path components, you need to use `path.posix.join()` instead of `path.join()`.

        @param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
        @param options - See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones in this package.
        @returns The stream of matching paths.

        @example
        ```
        import globby = require('globby');

        (async () => {
                for await (const path of globby.stream('*.tmp')) {
                        console.log(path);
                }
        })();
        ```
        */
        stream: (
                patterns: string | readonly string[],
                options?: globby.GlobbyOptions
        ) => NodeJS.ReadableStream;

        /**
        Note that you should avoid running the same tasks multiple times as they contain a file system cache. Instead, run this method each time to ensure file system changes are taken into consideration.

        @param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
        @param options - See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones in this package.
        @returns An object in the format `{pattern: string, options: object}`, which can be passed as arguments to [`fast-glob`](https://github.com/mrmlnc/fast-glob). This is useful for other globbing-related packages.
        */
        generateGlobTasks: (
                patterns: string | readonly string[],
                options?: globby.GlobbyOptions
        ) => globby.GlobTask[];

        /**
        Note that the options affect the results.

        This function is backed by [`fast-glob`](https://github.com/mrmlnc/fast-glob#isdynamicpatternpattern-options).

        @param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
        @param options - See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-3).
        @returns Whether there are any special glob characters in the `patterns`.
        */
        hasMagic: (
                patterns: string | readonly string[],
                options?: FastGlobOptions
        ) => boolean;

        readonly gitignore: Gitignore;

        (
                patterns: string | readonly string[],
                options: globby.GlobbyOptions & {objectMode: true}
        ): Promise<globby.Entry[]>;

        /**
        Find files and directories using glob patterns.

        Note that glob patterns can only contain forward-slashes, not backward-slashes, so if you want to construct a glob pattern from path components, you need to use `path.posix.join()` instead of `path.join()`.

        @param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
        @param options - See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones in this package.
        @returns The matching paths.

        @example
        ```
        import globby = require('globby');

        (async () => {
                const paths = await globby(['*', '!cake']);

                console.log(paths);
                //=> ['unicorn', 'rainbow']
        })();
        ```
        */
        (
                patterns: string | readonly string[],
                options?: globby.GlobbyOptions
        ): Promise<string[]>;
};

export = globby;