• Version 8.0.0
  • Published
  • 6.61 kB
  • 2 dependencies
  • MIT license


npm i @types/glob
yarn add @types/glob
pnpm add @types/glob


TypeScript definitions for glob



variable glob

let glob: typeof G;

    variable Glob

    let Glob: IGlobStatic;

      variable GlobSync

      let GlobSync: IGlobSyncStatic;


        function G

        G: typeof G;

          function hasMagic

          hasMagic: (pattern: string, options?: IOptions) => boolean;

            function sync

            sync: (pattern: string, options?: IOptions) => string[];


              interface IGlob

              interface IGlob extends IGlobBase, events.EventEmitter {}

                method abort

                abort: () => void;

                  method pause

                  pause: () => void;

                    method resume

                    resume: () => void;

                      interface IGlobBase

                      interface IGlobBase {}

                        property aborted

                        aborted: boolean;

                          property cache

                          cache: { [path: string]: boolean | 'DIR' | 'FILE' | ReadonlyArray<string> };

                            property found

                            found: string[];

                              property minimatch

                              minimatch: minimatch.IMinimatch;

                                property options

                                options: IOptions;

                                  property realpathCache

                                  realpathCache: { [path: string]: string };

                                    property statCache

                                    statCache: { [path: string]: false | { isDirectory(): boolean } | undefined };
                                      symlinks: { [path: string]: boolean | undefined };

                                        interface IGlobStatic

                                        interface IGlobStatic extends events.EventEmitter {}

                                          property prototype

                                          prototype: IGlob;

                                            construct signature

                                            new (
                                            pattern: string,
                                            cb?: (err: Error | null, matches: string[]) => void
                                            ): IGlob;

                                              construct signature

                                              new (
                                              pattern: string,
                                              options: IOptions,
                                              cb?: (err: Error | null, matches: string[]) => void
                                              ): IGlob;

                                                interface IGlobSyncStatic

                                                interface IGlobSyncStatic {}

                                                  property prototype

                                                  prototype: IGlobBase;

                                                    construct signature

                                                    new (pattern: string, options?: IOptions): IGlobBase;

                                                      interface IOptions

                                                      interface IOptions extends minimatch.IOptions {}

                                                        property absolute

                                                        absolute?: boolean | undefined;

                                                          property cache

                                                          | { [path: string]: boolean | 'DIR' | 'FILE' | ReadonlyArray<string> }
                                                          | undefined;

                                                            property cwd

                                                            cwd?: string | undefined;

                                                              property debug

                                                              debug?: boolean | undefined;

                                                                property dot

                                                                dot?: boolean | undefined;

                                                                  property follow

                                                                  follow?: boolean | undefined;

                                                                    property fs

                                                                    fs?: typeof fs;

                                                                      property ignore

                                                                      ignore?: string | ReadonlyArray<string> | undefined;

                                                                        property mark

                                                                        mark?: boolean | undefined;

                                                                          property matchBase

                                                                          matchBase?: any;

                                                                            property nobrace

                                                                            nobrace?: boolean | undefined;

                                                                              property nocase

                                                                              nocase?: boolean | undefined;

                                                                                property nocomment

                                                                                nocomment?: boolean | undefined;

                                                                                  property nodir

                                                                                  nodir?: boolean | undefined;

                                                                                    property noext

                                                                                    noext?: boolean | undefined;

                                                                                      property noglobstar

                                                                                      noglobstar?: boolean | undefined;

                                                                                        property nomount

                                                                                        nomount?: boolean | undefined;

                                                                                          property nonegate

                                                                                          nonegate?: boolean | undefined;

                                                                                            property nonull

                                                                                            nonull?: boolean | undefined;

                                                                                              property nosort

                                                                                              nosort?: boolean | undefined;

                                                                                                property nounique

                                                                                                nounique?: boolean | undefined;

                                                                                                  property realpath

                                                                                                  realpath?: boolean | undefined;

                                                                                                    property realpathCache

                                                                                                    realpathCache?: { [path: string]: string } | undefined;

                                                                                                      property root

                                                                                                      root?: string | undefined;

                                                                                                        property silent

                                                                                                        silent?: boolean | undefined;

                                                                                                          property stat

                                                                                                          stat?: boolean | undefined;

                                                                                                            property statCache

                                                                                                            | { [path: string]: false | { isDirectory(): boolean } | undefined }
                                                                                                            | undefined;

                                                                                                              property strict

                                                                                                              strict?: boolean | undefined;
                                                                                                                symlinks?: { [path: string]: boolean | undefined } | undefined;

                                                                                                                  property sync

                                                                                                                  sync?: boolean | undefined;

                                                                                                                    Package Files (1)

                                                                                                                    Dependencies (2)

                                                                                                                    Dev Dependencies (0)

                                                                                                                    No dev dependencies.

                                                                                                                    Peer Dependencies (0)

                                                                                                                    No peer dependencies.


                                                                                                                    To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                    You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/glob.

                                                                                                                    • Markdown
                                                                                                                    • HTML
                                                                                                                      <a href="https://www.jsdocs.io/package/@types/glob"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>