• Version 7.1.4
  • Published
  • 6.56 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 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>