• Version 8.1.0
  • Published
  • 6.66 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 allowWindowsEscape

                                                          allowWindowsEscape?: 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>